Object-Oriented Programming (OOP) in C#

What is Object-Oriented Programming?

Object-oriented programming organizes code into modular units called objects. These objects contain related data and functions to operate on that data.

For example, a Bicycle object could have properties like gear, speed, and color. And methods like pedal() and brake().

OOP models real-world entities using these code objects. Programs are designed by creating interacting objects and calling their methods.

This approach provides key advantages:

Modularity

Each object encapsulates related features and behaviors. This modular design makes code more organized.

Reusability

Common objects can be reused throughout the code, instead of rewriting duplicate logic.

Extensibility

Objects can be extended with new behaviors by inheriting from them. This builds on existing code easily.

The core OOP concepts that enable this are:

• Objects and Classes
• Encapsulation
• Inheritance
• Polymorphism

Let’s explore each of these pillars of OOP in C#.

Objects and Classes in C#

The central unit of OOP is an object. An object encapsulates related data and behaviors.

A class serves as a blueprint for creating objects. You define a class once and can then instantiate objects of that type.

Here is an example Bicycle class and corresponding Bicycle object in C#:

// Bicycle class
public class Bicycle 
{
  public int gear = 1;

  public void ChangeGear(int newGear)
  {        
    gear = newGear;
  }

  public void SpeedUp(int increment) 
  {
    speed += increment; 
  }
} 

// Create Bicycle object
Bicycle myBike = new Bicycle();

myBike.ChangeGear(2);
myBike.SpeedUp(10);

• Bicycle class defines data and methods.
• myBike is an instance of the Bicycle class.
• We can access its properties and call methods.

This models a conceptual bicycle by defining a blueprint that creates bike objects.

Classes enable abstraction – wrapping complexity into reusable logical units. Good class design is key to OOP.

Next let’s see how encapsulation builds on classes.

Encapsulation

Encapsulation means bundling data and behaviors into a single unit. In OOP, this is done by creating class objects.

For example, the details of how a bike changes gear and speed up are encapsulated in the Bicycle class.

This provides two major advantages:

Data Hiding

Class internals are hidden from the outside. Users of the class only interact with its interface.

For example, how a bike speeds up is hidden in the SpeedUp() method.

Abstraction

Complex logic is abstracted into class methods. Users simply call these methods instead of reimplementing the logic.

Together data hiding and abstraction enable encapsulation. This is a key tenet of OOP.

Another way C# provides encapsulation is via access modifiers:

public class Bicycle
{
  // Private variable only accessible within class
  private int cadence; 

  // Public method serves as interface
  public void SpeedUp(int increment)
  {
    cadence += increment;
  }
}

The private keyword hides internal data like cadence from external code. This is data encapsulation.

Public methods like SpeedUp() serve as the class interface. This abstraction enables encapsulation in C#.

Proper encapsulation is vital for modular and resilient object-oriented code.

Inheritance in C#

Inheritance enables new classes to be defined that inherit properties and methods from existing classes.

The existing class is called the base class. The new class is called the derived class.

This allows derived classes to:

• Reuse code from base classes
• Extend base class functionality

For example:

public class Vehicle 
{
  public void Drive()
  {
    // Driving logic
  }
}

public class Car : Vehicle
{
  public void OpenTrunk()
  {
    // Open trunk logic
  }  
}

Car inherits from the Vehicle base class:

• It can call the Drive() method
• It extends with new OpenTrunk() logic

This models intuitive parent-child relationships like a Car is a Vehicle.

Inheritance promotes code reuse and extensibility. Derived classes build on parent classes without duplicating code.

C# supports single inheritance – each class can only inherit from one base class. But a base class can have multiple derived classes.

Polymorphism in C#

Polymorphism means “many forms”. It enables a single interface to be used for multiple derived types.

For example, imagine many types of vehicles:

Cars, Trucks, Motorcycles

We want them to share a common Drive() method:

car.Drive();
truck.Drive();
motorcycle.Drive();

But Drive() might work slightly differently for each vehicle type. With polymorphism, we can implement Drive() once in a base Vehicle class, then override it uniquely for each child class.

C# enables this overriding through virtual methods. Here is an example:

public class Vehicle
{
  public virtual void Drive()
  {
    // Base driving logic
  }
}

public class Car : Vehicle
{
  public override void Drive() 
  {
    // Custom car driving code
  }
}

virtual on the base method allows it to be override in derived classes. This polymorphic approach enables subclasses to customize base class behavior.

We can generalize a common interface across types using a base class, while also specializing implementations. This combination of generalization and specialization is the essence of polymorphism.

Next let’s explore implementing interfaces in C#.

Interfaces in C#

An interface defines a “contract” specifying methods and properties a class must implement. This enables abstraction by separating interface from implementation.

For example:

interface IVehicle 
{
  void Drive();
  void Stop();
}

class Car : IVehicle
{
  public void Drive()
  {
    // Driving logic
  }
    
  public void Stop()
  {
    // Stopping logic
  }
}

Any class implementing IVehicle must define the methods Drive() and Stop(). This establishes a clear contract for functionality.

Interfaces help formalize class abstraction and enable polymorphism. A single interface can be implemented by multiple diverse classes.

Some key properties of C# interfaces:

• Interface methods are implicitly public and abstract
• Interfaces cannot contain implementation logic
• Classes can implement multiple interfaces
• Interfaces can inherit from other interfaces

Proper interface design is key to abstraction and loose coupling in OOP applications.

Now let’s look at some examples of core OOP principles in C#.

Object-Oriented Programming Examples

Here are some examples demonstrating the pillars of OOP: encapsulation, inheritance, and polymorphism.

Encapsulation

class Vehicle
{
  private int speed;
  
  // Only SpeedUp() can directly access speed
  public void SpeedUp(int increment)
  {
    speed += increment; 
  }
}

Vehicle v = new Vehicle();
v.SpeedUp(10); // Encapsulation hides implementation

Hiding speed and abstracting access with SpeedUp() provides encapsulation.

Inheritance

class Animal
{
  public void Eat()
  {
    // Eating logic
  }
}

class Dog : Animal
{
  public void Bark()
  {
    // Barking logic
  }
}

Dog d = new Dog();
d.Eat(); // Inherited from Animal
d.Bark(); // Defined in Dog

Dog inherits Eat() from Animal and extends with Bark(). This models specialization.

Polymorphism

class Shape 
{
  public virtual void Draw() 
  {
    // Default shape drawing
  }
}

class Circle : Shape
{
  public override void Draw()
  {
    // Code to draw a circle
  }
}

class Square : Shape
{
  public override void Draw()
  {
    // Code to draw a square
  }
}

Custom Draw() implementations enable polymorphism. A single Shape interface can be specialized uniquely for each shape type.

These examples demonstrate core OOP principles like inheritance, encapsulation, and polymorphism in C#.

Next let’s go over some design best practices.

Object-Oriented Design Best Practices

Here are some best practices to follow when modeling C# programs using OOP:

Logically Group Code into Classes

Class representations should model real-world entities or logical abstractions. Group related data and behaviors together.

Favor Composition Over Inheritance

Prefer object composition by passing instances to methods rather than relying on inheritance. This decouples code.

Encapsulate Internal Details

Make data members private. Expose functionality through public methods. Avoid public fields.

Prefer Interfaces Over Concrete Classes

Code to interfaces like IEnumerable instead of concrete types like List for greater flexibility.

Inherit from Abstract Classes

Inherit from abstract classes that provide partial implementations over regular classes. This avoids duplication.

Utilize Polymorphism

Leverage virtual methods and overriding to generalize common interfaces across class types.

Follow SOLID Principles

Adhere to practices like single responsibility and open/closed principle. This creates resilient OOP code.

Properly applying these design principles results in code that is reusable, maintainable, and extensible.

Now let’s discuss the pros and cons of OOP.

Advantages and Disadvantages of OOP

Object-oriented programming has key advantages:

Pros:

• Modular and organized code
• Encapsulation hides implementation details
• Reusability through inheritance and polymorphism
• Models real-world entities and relationships
• Enable abstraction via classes and interfaces

Cons:

• Steep learning curve
• Code navigation can be difficult in large projects
• Overly complex architectures if principles applied poorly
• Inheritance hierarchies can become brittle and unwieldy
• OOP may be overkill for simpler programs

The benefits of modularity, extensibility, and reusability generally outweigh the downsides for large projects. But OOP is a “tool” – it may not be suitable for all domains.

Understanding the tradeoffs helps apply OOP effectively. When done right, OOP promotes code quality and maintainability.

Conclusion

Object-oriented programming encapsulates data and behaviors into modular class units. This enables:

• Abstraction via classes and interfaces
• Encapsulation through access modifiers
• Inheritance for specialization and code reuse
• Polymorphism for generalizing behavior across types

Mastering OOP is critical for crafting maintainable and scalable C# software. Properly leveraging OOP principles like inheritance and polymorphism results in higher code quality.

In this comprehensive guide you learned:

• OOP concepts like objects, classes, and inheritance
• Pillars of OOP: encapsulation, inheritance, polymorphism
• How to implement interfaces in C#
• Examples and best practices for OOP C# code
• Tradeoffs and pros/cons of object-oriented design

You now have a solid grounding in applying OOP principles to build robust and flexible C# applications.