Using Decorator Pattern in C#: Basics and Applications

The decorator design pattern is a structural pattern used to add new behaviors to an object without changing its functionality. In software development, it is highly important as a method that increases flexibility and allows new features to be added easily. In C#, the use of the decorator pattern is often preferred in situations where objects need to be wrapped or extended. In this article, we will examine how to implement the decorator pattern using C#, step by step.

What is the Decorator Pattern?

The decorator pattern meets the need to change or extend the functionality of a single object in the object-oriented programming paradigm. This pattern allows you to add new functionality by combining and configuring objects. Thus, it is possible to add new features without making changes to the existing code. For example, if you want to offer additional services for a product in a visual application, you can define each service as a separate decorator using this pattern and combine them.

Decorator Pattern Step-by-Step with C#

If we examine the decorator pattern with a simple example; let’s consider a beverage system. In this beverage system, we will have basic beverages and we will want to enrich these beverages with different ingredients (milk, sugar, etc.). Below you can find the C# code for this structure:

public interface IBeverage
{
    string GetDescription();
    double Cost();
}

public class Coffee : IBeverage
{
    public string GetDescription()
    {
        return "Coffee";
    }

    public double Cost()
    {
        return 2.0;
    }
}

public abstract class BeverageDecorator : IBeverage
{
    protected IBeverage _beverage;

    public BeverageDecorator(IBeverage beverage)
    {
        _beverage = beverage;
    }

    public abstract string GetDescription();
    public abstract double Cost();
}

public class MilkDecorator : BeverageDecorator
{
    public MilkDecorator(IBeverage beverage) : base(beverage) { }

    public override string GetDescription()
    {
        return _beverage.GetDescription() + ", Milk";
    }

    public override double Cost()
    {
        return _beverage.Cost() + 0.5;
    }
}

// Usage
IBeverage beverage = new Coffee();
beverage = new MilkDecorator(beverage);
Console.WriteLine(beverage.GetDescription() + " costs: " + beverage.Cost());

In the code above, the IBeverage interface defines the methods that all beverages should have. The Coffee class is used as the basic beverage. The BeverageDecorator abstract class forms the basis of all decorators. The MilkDecorator class adds milk to the beverage. In the usage example, we create a coffee object and add the cost of milk.

Conclusion

The use of the decorator pattern with C# holds an important place by providing flexibility and modularity in software development. Avoiding changes to the existing system while adding new features will reduce errors and increase sustainability. You can easily use this approach in large-scale projects or situations where business requirements change frequently. Seeing this pattern more in C# and similar languages in the coming years shows that it will become widespread in software development practices.