Designing for Extensibility in C#

A Deep Dive into .NET Framework Practices

3 min read · August 31, 2023 — #csharp-interview #middle-specialist #design #extensibility #dotnet

When it comes to crafting frameworks, especially in the intricate world of .NET, extensibility is paramount. Just as architectural designs in the physical world require adaptability, so too do our digital frameworks require the capability to evolve and adapt.

A significant aspect of designing a robust framework is ensuring its extensibility. In the .NET ecosystem, multiple extensibility mechanisms ensure future adaptability and robustness. Here's a closer look:

1. Unsealed Classes

Unsealed classes are pivotal in fostering inheritance, allowing developers to expand existing functionalities.

public class UnsealedClass
{
    public void DisplayMessage()
    {
        Console.WriteLine("Hello from UnsealedClass!");
    }
}

public class DerivedClass : UnsealedClass { }

DerivedClass derivedObj = new DerivedClass();
derivedObj.DisplayMessage();  // Outputs: Hello from UnsealedClass!

2. Protected Members

Protected members, by being accessible within their declaring class and by derived instances, serve as foundational pillars for controlled data access and encapsulation.

public class BaseClass
{
    protected int ProtectedValue = 42;
}

public class ChildClass : BaseClass
{
    public int GetProtectedValue()
    {
        return ProtectedValue;
    }
}

ChildClass child = new ChildClass();
Console.WriteLine(child.GetProtectedValue());  // Outputs: 42

3. Events and Callbacks

Events are a linchpin in event-driven programming. They empower classes to notify other classes about specific occurrences without tight coupling.

public class Publisher
{
    public delegate void Notify();
    public event Notify ProcessCompleted;

    public void StartProcess()
    {
        Console.WriteLine("Process Started!");
        ProcessCompleted?.Invoke();
    }
}

public class Subscriber
{
    public void OnProcessCompleted()
    {
        Console.WriteLine("Process Completed!");
    }
}

var publisher = new Publisher();
var subscriber = new Subscriber();

publisher.ProcessCompleted += subscriber.OnProcessCompleted;
publisher.StartProcess();

4. Virtual Members

With virtual members, the flexibility of object-oriented programming shines. Derived classes can override base class methods for specialized implementations.

public class Animal
{
    public virtual void Speak()
    {
        Console.WriteLine("Some sound");
    }
}

public class Dog : Animal
{
    public override void Speak()
    {
        Console.WriteLine("Woof");
    }
}

Animal myDog = new Dog();
myDog.Speak();  // Outputs: Woof

5. Abstractions (Abstract Types and Interfaces)

Abstractions, whether abstract types or interfaces, facilitate crafting blueprints for classes and enhance adaptability.

public abstract class AbstractProduct
{
    public abstract void DisplayInfo();
}

public interface IProduct
{
    void GetPrice();
}

public class Phone : AbstractProduct, IProduct
{
    public override void DisplayInfo()
    {
        Console.WriteLine("This is a Phone.");
    }

    public void GetPrice()
    {
        Console.WriteLine("$999");
    }
}

6. Base Classes for Implementing Abstractions

Such classes provide a skeletal implementation, ensuring consistency and reducing redundancy.

public abstract class AbstractDatabase
{
    public void Connect()
    {
        Console.WriteLine("Default Connection established.");
    }

    public abstract void GetDatabaseType();
}

public class SQLDatabase : AbstractDatabase
{
    public override void GetDatabaseType()
    {
        Console.WriteLine("SQL Database");
    }
}

7. Sealing

Sealing restricts inheritance, ensuring a class's behavior remains consistent and unchanged.

public sealed class SealedClass
{
    public void ShowMessage()
    {
        Console.WriteLine("You can't inherit from me!");
    }
}

// public class ExtendedClass : SealedClass {}
// This will cause a compile-time error

Conclusion

In the ever-evolving landscape of software design, adaptability remains a cornerstone of sustainability. By embracing extensibility in design, developers pave the way for solutions that cater to present needs while also gracefully evolving to meet future challenges. With .NET's rich palette of extensibility mechanisms, architects can create resilient and adaptable software components that truly stand the test of time.