Object-oriented
Programming in C#
Understanding Object-orientation in C#
Gill Cleeren
CTO Xpirit Belgium
@gillcleeren
Overview
Understanding OOP in C#
Working with classes and objects
The pillars of OO
A word of warning!
This will be a more theoretical module!
Demos will start in the next module!
Some C# knowledge
is required!
Basic C# syntax is assumed
Take a look at
“C# Fundamentals” if needed
Version Check
This version was created by using:
- C# 12
- Visual Studio 2022
Version Check
This course is 100% applicable to:
- C# 10, 11 & 12
- Visual Studio 2022 (any edition)
Most code will work fine with older
versions of C#
Understanding OOP in C#
A Short History of OOP
Object-oriented programming
Over 50 years old
Moved from C++ and then into Java
C# is Microsoft’s answer
Understanding OOP
Objects interact with each other
Code reuse and easier to maintain
Aimed at all types of problems, including complex and large systems
Helps with breaking down the problem into smaller parts
OOP Languages
C++ Java Python
Ruby JavaScript… C#
C# and OOP
Object-oriented
Type-safe
Reusable code
Frequent updates
Modern tools
… and lots of fellow C# developers!
C# Building Blocks for Object-oriented Programming
Classes Objects Methods
Properties Interfaces
Working with Classes and Objects
Understanding Classes
Concepts of the real world
Used to categorize “types”
Building block of OOP
Reference type (like interfaces and
delegates)
In C#, Everything is a Class…
Small programs Classes which will be instantiated
Main() or top-level Program.cs Create one or more objects
Classes and Objects
Hillary, “a” dog
Violet, “a” dog
Bob, “a” dog
The Dog Class
Classes in C#
Blueprint of an object
Defines data and functionality to work on its data
Created using class keyword
The Class Template
public class MyClass
{
private int counter;
public void MyMethod()
{
//Do something great here
}
}
Contents of a Class
Fields Methods
Properties Events
Exploring a Simple Class
public class Employee
{
public Employee()
{
//Initialization code goes here
}
private string firstName;
private int age;
public string FirstName
{
get { return firstName; }
set { firstName = value; }
}
public void PerformWork()
{
//method implementation goes here
}
}
Class Declaration and Naming
public class Employee
{
public Employee()
{
//Initialization code goes here
}
private string firstName;
private int age;
public string FirstName
{
get { return firstName; }
set { firstName = value; }
}
public void PerformWork()
{
//method implementation goes here
}
}
Fields Contain Data
public class Employee
{
public Employee()
{
//Initialization code goes here
}
private string firstName;
private int age;
public string FirstName
{
get { return firstName; }
set { firstName = value; }
}
public void PerformWork()
{
//method implementation goes here
}
}
Properties Control Access to Data
public class Employee
{
public Employee()
{
//Initialization code goes here
}
private string firstName;
private int age;
public string FirstName
{
get { return firstName; }
set { firstName = value; }
}
public void PerformWork()
{
//method implementation goes here
}
}
Methods Define Functionality
public class Employee
{
public Employee()
{
//Initialization code goes here
}
private string firstName;
private int age;
public string FirstName
{
get { return firstName; }
set { firstName = value; }
}
public void PerformWork()
{
//method implementation goes here
}
}
Access Modifiers Define Access to Members
public class Employee
{
public Employee()
{
//Initialization code goes here
}
private string firstName;
private int age;
public string FirstName
{
get { return firstName; }
set { firstName = value; }
}
public void PerformWork()
{
//method implementation goes here
}
}
What are members?
Classes contain members
Access modifiers
Constructors Are Used for Initialization
public class Employee
{
public Employee()
{
//Initialization code goes here
}
private string firstName;
private int age;
public string FirstName
{
get { return firstName; }
set { firstName = value; }
}
public void PerformWork()
{
//method implementation goes here
}
}
Classes and Objects
Object 1
FirstName: John
Age: 27
Object 2
FirstName: Mary
Age: 31
Object 3
Employee Class FirstName: George
Age: 22
Age is a field
Employee employee = new Employee();
Instantiating an Object
The new operator
employee.PerformWork();
employee.PerformWork(10);
employee.FirstName = "Gill";
Working with an Object
Invoke methods, properties…
Types in the CTS
Class Enumeration Struct
Interface Delegate Record
More on Classes and Objects
We will keep using classes and objects
and explore all we can do with them applying
OO in C#!
The Principles of Object-oriented Design
Introducing the 4 Pillars
Help with writing clean, object-
oriented code
Covered by C# language features
The Pillars of OOP
Abstraction Encapsulation
Inheritance Polymorphism
The Pillars of OOP
Abstraction Encapsulation
Inheritance Polymorphism
The concept of abstraction
- Think about the essential concepts, not the
background details
- Create layer of abstraction
- Expose simple handles to interact without
knowing about the details
- Focus on what it does, not how it does it
Abstraction applied on Car
- Steering wheel, brake pedal expose simple
interface to the user
• This is the abstraction
- No need to know how the engine, brakes
really work
• Only necessary aspects are exposed
Benefits of Applying Abstraction
Reduce complexity, only simple interfaces
Hide and secure important functionality
Better for maintenance
Updates don’t break existing interface mostly
Thinking in Abstraction
Name
Age
Weight
Address
Hair color
Perform work
Employee
The Pillars of OOP
Abstraction Encapsulation
Inheritance Polymorphism
The Pillars of OOP
Abstraction Encapsulation
Inheritance Polymorphism
Encapsulation
- All data and functionality on this data is
encapsulated inside object
- Only certain information is exposed
- Data is hidden inside object
- Use access modifiers
Encapsulation applied on a Car
- Defines speed, engine, drive(), speedUp()…
- Bound together in one unit
- Engine data must be hidden (private)
- speedUp() can be working on data but still
be publicly available
public class Car t Public part is useable from outside
{
t Private part is only useable from within the
private int id; class itself
private int temperature; t Important data can be hidden so it can’t be
changed (intentionally or by mistake)
public int Id
{
get { return id; }
t We can control how the data changes
set {
if(id > 0)
id = value;
}
}
}
The Pillars of OOP
Abstraction Encapsulation
Inheritance Polymorphism
The Pillars of OOP
Abstraction Encapsulation
Inheritance Polymorphism
Inheritance
- Inherit features from other classes
- Create hierarchy
• Is-A relation
- Improve reuse of code between parent and
child class
- Child class can extend functionality and
attributes
Inheritance Applied on a Car
public class Car
{
private int maxSpeed;
public int MaxSpeed { get => maxSpeed; set => maxSpeed = value; }
public void Drive()
{
}
}
The Parent Car Class
public class SportsCar : Car
{
private bool isRoofOpen;
}
The SportsCar Class
The Pillars of OOP
Abstraction Encapsulation
Inheritance Polymorphism
The Pillars of OOP
Abstraction Encapsulation
Inheritance Polymorphism
Polymorphism
- Allow methods to execute differently
- virtual and override keywords in C#
- On objects of different types, we can invoke
the same methods
Applying Method Overriding
public class Car
{
public virtual void Drive()
{ }
}
public class ElectricCar : Car
{
public override void Drive()
{
base.Drive();
}
}
Summary C# supports object-oriented programming
OOP design principles
- Abstraction
- Encapsulation
- Inheritance
- Polymorphism
Up Next:
Designing an Object-oriented Solution
from a Business Case
