Object-Oriented Programming (OOP) in C#

Introduction to OOP Principles

Object-Oriented Programming (OOP) is a programming paradigm based on the concept of “objects”, which contain data in the form of fields (attributes) and code in the form of methods (procedures). C# is an object-oriented language that supports the four core principles of OOP:

• Encapsulation: Bundling data (attributes) and methods that operate on the data into a single unit (class). It hides the internal state of the object and protects it from outside access, exposing only necessary information through a public interface.
• Inheritance: Creating new classes (derived classes) from existing classes (base classes). Derived classes inherit the attributes and methods of the base class, promoting code reuse and establishing “is-a” relationships.
• Polymorphism: The ability of an object to take on many forms. It allows objects of different classes to be treated as objects of a common type, enabling code flexibility and extensibility. Polymorphism is achieved through inheritance and interfaces.
• Abstraction: Simplifying complex reality by modeling classes based on essential attributes and behaviors, hiding unnecessary implementation details from the user. Abstract classes and interfaces are used to achieve abstraction in C#.

Tricky Interview Question

Question: Explain the difference between an abstract class and an interface in C#. When would you use one over the other?

Code Example

// Interface
public interface IShape
{
    double GetArea();
}

// Abstract class
public abstract class Shape
{
    public string Name { get; set; }

    public abstract double GetArea();

    public virtual string GetDescription()
    {
        return "This is a shape.";
    }
}

// Concrete class inheriting from abstract class and implementing interface
public class Circle : Shape, IShape
{
    public double Radius { get; set; }

    public override double GetArea()
    {
        return Math.PI * Radius * Radius;
    }

    public override string GetDescription()
    {
        return "This is a circle.";
    }
}

public class Rectangle : Shape
{
    public double Width { get; set; }
    public double Height { get; set; }

    public override double GetArea()
    {
        return Width * Height;
    }
}

Detailed Answer

Abstract Class:

• Can have both abstract and non-abstract methods (concrete methods with implementation).
• Can have fields (member variables).
• Can have constructors.
• A class can inherit from only one abstract class.
• Provides a base implementation that derived classes can inherit and extend.

Interface:

• Can only have method declarations (no implementation). From C# 8.0, interfaces can have default implementations for members.
• Cannot have fields (member variables).
• Cannot have constructors.
• A class can implement multiple interfaces.
• Defines a contract that implementing classes must adhere to.

When to use which:

• Abstract Class: Use when you want to provide a common base implementation for a family of classes, and you expect derived classes to share some common functionality. Also, use when you need to maintain a state (fields).
• Interface: Use when you want to define a contract that multiple unrelated classes can implement. Use when you want to achieve polymorphism and allow objects of different types to be treated as objects of a common type. Also, use when you want to define a set of methods that a class must implement.

Potential Pitfalls:

• Abstract Class: Tight coupling between base class and derived classes. Changes to the base class can affect derived classes.
• Interface: Interface pollution (adding methods to an interface that not all implementing classes need).

Code Debugging Task

Task: Find and fix the bug in the following code that violates the Liskov Substitution Principle.

public class Bird
{
    public virtual void Fly()
    {
        Console.WriteLine("Bird is flying");
    }
}

public class Ostrich : Bird
{
    public override void Fly()
    {
        throw new Exception("Ostrich cannot fly");
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        Bird bird = new Ostrich();
        bird.Fly(); // This throws an exception
    }
}

Detailed Explanation of the Bug and Corrected Code

Bug:

The Ostrich class inherits from the Bird class, but it overrides the Fly() method to throw an exception. This violates the Liskov Substitution Principle (LSP), which states that derived classes should be substitutable for their base classes without altering the correctness of the program. In this case, substituting a Bird object with an Ostrich object causes the program to throw an exception, violating the LSP.

Corrected Code:

public class Bird
{
    public virtual void Fly()
    {
        Console.WriteLine("Bird is flying");
    }
}

public class FlyingBird : Bird
{
    public override void Fly()
    {
        Console.WriteLine("FlyingBird is flying");
    }
}

public class Ostrich : Bird
{
    // Ostrich doesn't fly
}

public class Program
{
    public static void Main(string[] args)
    {
        Bird bird = new FlyingBird();
        bird.Fly(); // This works fine

        Bird ostrich = new Ostrich();
        //ostrich.Fly(); // Ostrich doesn't fly, so no need to call Fly()
    }
}

Explanation of the corrected code:

1. Created a new class FlyingBird that inherits from Bird and overrides the Fly() method to provide the flying behavior.
2. The Ostrich class now inherits from Bird but does not override the Fly() method. This indicates that ostriches do not fly.
3. In the Main() method, we create a FlyingBird object and assign it to a Bird variable. Calling Fly() on this object will execute the FlyingBird’s Fly() method, which prints “FlyingBird is flying”.
4. We also create an Ostrich object and assign it to a Bird variable. Since Ostrich does not override the Fly() method, calling Fly() on this object would execute the Bird’s Fly() method, which prints “Bird is flying”. However, since ostriches don’t fly, we don’t call the Fly() method on the Ostrich object.

This corrected code adheres to the Liskov Substitution Principle because substituting a Bird object with a FlyingBird or Ostrich object does not alter the correctness of the program.

Additional Questions and Answers

public void optionalParamFunc(int p1, int p2 = 2, int p3 = 3);
optionalParamFunc(1, p3:10); // Equivalent to optionalParamFunc(1,2,10);

string s1 = "123";
string s2 = s1.Substring(0, 2) + "3";

// Value comparisons (all will work)
if (s1 == s2) { }
if (s1.CompareTo(s2) == 0) { }
if (s1.Equals(s2)) { }
if (string.Equals(s1, s2)) { }

// Reference comparisons (shouldn't be used)
if ((object)s1 == (object)s2) { }
if (object.ReferenceEquals(s1, s2)) { }