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. 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.
