Microsoft has been in the process of growth and expansion since its invention, with different
languages being implemented to make it more efficient and able to handle a wider diversity
of work. C# is one of the latest programming languages to be introduced in Microsoft.
Unlike the earlier programming languages that were closed sources, C sharp is an open
programming source that is easy to use, modern, and purpose-oriented. C# provides an
avenue to reuse existing codes crucial in enhancing object-oriented concepts such as classes
and inheritance. Class is a common term used when dealing with C# to refer to specific user-
defined data representing the states and behaviors of particular objects.C#, like any other
object-oriented programming language, is characterized by interdependence among different
classes in which one class either enhances the functioning of the other or overrides the other.
The relationship between classes in the inheritance concepts brings about the issue of the
base class and the derived class, where the former refers to the class from which the
functionality of the other class is derived. In developing a personal programming language, I
would have a class as a template for creating objects within, while the system objects would
be the specific objects fed into the different classes.
Object Oriented Programming, a framework for programming, is centred around classes,
which act as blueprints or patterns through which objects develop, and objects that exist in
reality are examples of a class. Inheritance is a means to illustrate the actual connections
between both of them. The process of inheriting the properties and functions of a different
class is known as inheritance. The parent class, sometimes referred to as the superclass,
represents the one from which the methods and characteristics are derived. And the child
class, referred to as a derived class, receives the parent class's attributes through inheritance.
Classes in C# offer the concepts of derived and parent classes, flexibility, and inheritance
(Surya and Padmavathi, 2019). for example, the base class Animal is being inherited by the
derived class Dog. The Animal class's attributes and techniques have been accessible to the
Dog class.
An illustration can be taken: Vehicle is a more general category that includes cars, buses,
and bicycles. This indicates that all of them have inherited the characteristics of the vehicles
that represent transportation. By using inheritance, we may describe this connection in
programming. An automobile is a real-world thing. The automobile comprises techniques
like acceleration and brake as well as characteristics like mass and color. A class is used to
build an object. After the class Car is established, we may use it to generate objects. An
example of object oriented programming or OOP utilizing C# would be Unity, there are
other object oriented programs and languages as well such as Unreal Engine which utilizes
C++. These two programs use a visual programming of C# or C++ to create video games
and almost all major game creators use one of these programs or their own in house form of
these visual editors to write in C# or C++. Almost all software is written with object
oriented programming as it is designed to run in .NET so no matter if its a video editor,
financial software, or even word processor it is mostly written in an object oriented
programming language such as C# or C++object oriented programming is essential in
smoothly and easily utilize different classes, system objects, and inheritance. Classes are
interrelated for specific reasons, and usually logically connected. A class is a group of
objects that are made up of code, where a object is a singular piece of code, inheritance is
when one class derives attributes from another class. All are equally important and have
different uses within object oriented programming. There are six main types of relationships
between classes: inheritance , realization / implementation , composition , aggregation ,
association, and dependency . The arrows for the six relationships are as follows:
Then we come to understand the specific content of the class relationship.
In the six types of relationships, the code structure of the three types of relationships such
as composition , aggregation , and association is the same as using attributes to store the
references of another class. Therefore, they must be distinguished by the relationship
between the contents.
Inheritance is also called generalization and is used to describe the relationship between
parent and child classes. A parent class is also called a base class, and a subclass is also
called a derived class.
In the inheritance relationship, the subclass inherits all the functions of the parent class, and
the parent class has all the attributes, methods, and subclasses. Subclasses contain
additional information in addition to the same information as the parent class.
For example: buses, taxis, and cars are cars, they all have names, and they can all be on the
road. Based on my understanding, the relationship between types of classes, system objects,
and inheritance its easily illustrated using a tree type diagram. The top of the structure is the
base, or superclass, and all branches downward are subclasses. In C# and the .NET
environment, System.Object is the default superclass. Classes can be definitions, record
layouts, report layouts, internal storage elements passed between functions in a program,
basically whatever the “thing” is that you are working on. I think of the class as the
definition of this “thing”. It is instantiated with the “new” command, and the elements
(variables, fields, etc.…) are accessible (maybe not changeable, but at least accessible) to
all modules which inherit the class. When a program is executing, the run time environment
generally provides a set of system tools, fields, commands, functions, etc. available for
programs that execute in the environment to access, these are system objects, and are be
accessed (inherited) into our programs by the superclass System.Object. Examples of
system tools are system time, date, environment variables such as .NET components, error
codes, and more. When specifying the classes, we can direct the inheritance of classes
specifically to system objects by using the “:object” parameter on the class statement. When
programs are executing, the classes that have been defined and invoked are virtual images
of those definitions and are accessible programmatically.
For example, I need a system to accept input from 4 different sources and merge the input
together and create one master set of data. The data is appointment schedule data from
various scheduling systems, and they all produce a downloadable text file with the
appointment data. I need this data merged into one master appointment scheduling system –
more flexible than what is available free through google or iOS. So, I will define a class
layout for each of the 4 input sources, and write modules that will open and read the text
files and update an MS Access database of appointments. a As an Application Developer for
a Construction Management Company, you create entire enterprise applications, and you'll
need to create software that caters to different departments like HR, Construction
Management, Payroll, and Adjusters. Types of classes, system objects, and inheritance are
crucial concepts to achieve this goal.
-For HR, custom classes can manage employee data and payroll information. System
objects like FileStream and Stream Reader classes can read data from CSV files for
managing employee data.
-Construction Management can use custom classes for building structures, equipment, and
tasks. Inheritance can create subclasses of existing classes to add new features specific to
construction management.
-Payroll can benefit from software to manage employee payroll data and calculate taxes.
Custom classes can manage employee payment information, and system objects like the
Math class can perform complex calculations.
-Adjusters can use custom classes to manage claims data and adjuster information.
Inheritance can create subclasses of existing classes to add new functionality, like managing
photos or documents related to a claim.
In conclusion, by applying the concepts of types of classes, system objects, and inheritance,
you can develop software that meets the unique needs of each department. This software
will be easy to maintain, provide a streamlined user experience, and improve the overall
efficiency of the company. As an Application Developer, it is crucial to utilize these
concepts to develop software that meets the specific requirements of the construction
management company since many applications will overlap. For example, within a
department, you'll often run across a scenario where different tables that share similar fields
share similar data sources, but are accessed by multiple applications, so maintaining clear
relationships is mission-critical in all enterprise-level applications. OOP has been available
in various languages and environments since the 1960s. I know it is hard to believe as most
books make it sound like OOP is new and the latest and greatest. My experience has been
in organizations where we have emphasized code reuse through OOP and others where
functional Programming (code and function libraries) have been used. I wish I could tell
that one side wins easily. We could argue that the development staff and management play
a huge role in the success or failure of any option. Many of you will bring up the concept
of code reuse as your argument for OO.
