Decorator Pattern in C#

Hello, fellow C# developers! In this post, I’m going to talk about one of my favorite design patterns: the Decorator Pattern. This pattern is very useful when you want to add some extra features or services to an existing object without changing its structure or creating a lot of subclasses. Sounds cool, right? šŸ˜Ž

What is the Decorator Pattern?

The Decorator Pattern is a structural design pattern that allows us to dynamically attach additional responsibilities or behaviors to an object at runtime. This is done by creating a decorator class that implements the same interface as the original object and wraps it inside. The decorator class can then delegate the original behavior to the wrapped object and add some new behavior on top of it.

The main benefit of this pattern is that it provides a flexible alternative to inheritance for extending functionality. Instead of creating a lot of subclasses that inherit from the original class and modify its behavior, we can simply use different decorators to compose the desired functionality at runtime. This way, we avoid the problems of subclassing, such as code duplication, tight coupling and increased complexity.

How to implement the Decorator Pattern in C#?

Let’s see how we can implement the Decorator Pattern in C# with a simple example. Suppose we have an interface called ILoan that defines the behavior of a loan:


// The 'Component' interface
public interface ILoan
{
  // Returns the description of the loan
  string GetDescription();

  // Returns the interest rate of the loan
  double GetInterestRate();
}


We can then create a concrete class that implements this interface, such as PersonalLoan:


// The 'ConcreteComponent' class
public class PersonalLoan : ILoan
{
  public string GetDescription()
  {
    return "Personal loan";
  }

  public double GetInterestRate()
  {
    return 0.12; // 12% annual interest rate
  }

}


Now, suppose we want to add some extra features or services to our loan, such as insurance, prepayment, or cashback. We could create subclasses for each combination of features, but that would be tedious and impractical. Instead, we can use decorators to add these features dynamically:


// The 'Decorator' abstract class
public abstract class LoanDecorator : ILoan
{
  // The wrapped loan object
  protected readonly ILoan loan;

  // Constructor that takes an ILoan object as a parameter
  public LoanDecorator(ILoan loanToDecorate)
  {
    this.loan = loanToDecorate;
  }

  // Delegates the GetDescription method to the wrapped loan object
  public virtual string GetDescription()
  {
    return loan.GetDescription();
  }

  // Delegates the GetInterestRate method to the wrapped loan object
  public virtual double GetInterestRate()
  {
    return loan.GetInterestRate();
  }
}

// The 'ConcreteDecorator' class for adding insurance
public class InsuranceDecorator : LoanDecorator
{
  // Constructor that calls the base constructor
  public InsuranceDecorator(ILoan loan) : base(loan)
  {
  }

  // Overrides the GetDescription method and adds insurance
  public override string GetDescription()
  {
    return base.GetDescription() + " with insurance";
  }

  // Overrides the GetInterestRate method and adds 0.01 to the interest rate
  public override double GetInterestRate()
  {
    return base.GetInterestRate() + 0.01; // 1% extra interest rate for insurance
  }
}

// The 'ConcreteDecorator' class for adding prepayment option
public class PrepaymentDecorator : LoanDecorator
{
  // Constructor that calls the base constructor
  public PrepaymentDecorator(ILoan loan) : base(loan)
  {
  }

  // Overrides the GetDescription method and adds prepayment option
  public override string GetDescription()
  {
    return base.GetDescription() + " with prepayment option";
  }

  // Overrides the GetInterestRate method and subtracts 0.02 from the interest rate
  public override double GetInterestRate()
  {
    return base.GetInterestRate() - 0.02; // 2% lower interest rate for prepayment option
  }
}

// The 'ConcreteDecorator' class for adding cashback offer
public class CashbackDecorator : LoanDecorator
{
  // Constructor that calls the base constructor
  public CashbackDecorator(ILoan loan) : base(loan)
  {
  }

  // Overrides the GetDescription method and adds cashback offer
  public override string GetDescription()
  {
    return base.GetDescription() + " with cashback offer";
  }

  // Overrides the GetInterestRate method and adds 0.03 to the interest rate
  public override double GetInterestRate()
  {
    return base.GetInterestRate() + 0.03; // 3% extra interest rate for cashback offer
  }
}


With these decorators, we can now create any combination of features for our loan at runtime. For example, we can create a personal loan with insurance and prepayment option like this:


// Create a personal loan object
ILoan loan = new PersonalLoan();

// Wrap it with an insurance decorator
loan = new InsuranceDecorator(loan);

// Wrap it with a prepayment decorator
loan = new PrepaymentDecorator(loan);

// Print the description and the interest rate of the loan
Console.WriteLine(loan.GetDescription()); 
// Personal loan with insurance with prepayment option
Console.WriteLine(loan.GetInterestRate()); 
// 0.11 (11% annual interest rate)


Or we can create a personal loan with a cashback offer like this:


// Create a personal loan object
ILoan loan = new PersonalLoan();
// Wrap it with a cashback decorator
loan = new CashbackDecorator(loan);

// Print the description and the interest rate of the loan
Console.WriteLine(loan.GetDescription()); 
// Personal loan with cashback offer
Console.WriteLine(loan.GetInterestRate()); 
// 0.15 (15% annual interest rate)

As you can see, we can easily add or remove features from our loan without changing the original class or creating subclasses. This makes our code more flexible and maintainable. šŸ™Œ

Where to learn more about the Decorator Pattern?

If you want to learn more about the Decorator Pattern in C#, I recommend you to check out these resources:

I hope you enjoyed this post and learned something new about the Decorator Pattern in C#. This pattern is very powerful and can help you create elegant and extensible code in C#. Feel free to share your thoughts or questions in the comments below. 


You can find the code examples here: source code


Happy coding! šŸ˜Š

Comments

Post a Comment

Popular posts from this blog

Which GOF patterns are good for C#?

Hello, C# fans! šŸ˜Š In this article, I will answer a common question that many C# developers have: which GOF patterns are good for C#? šŸ¤” GOF patterns are the 23 design patterns that were described in the book “ Design Patterns: Elements of Reusable Object-Oriented Software ” by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides. They are also known as the Gang of Four (GoF) patterns. They are divided into three categories: creational, structural, and behavioral. šŸ“š These patterns provide solutions to common software design problems that you may encounter in your projects. They help you write code that is more reusable, flexible, maintainable, and elegant. šŸ˜ But not all GOF patterns are equally useful or applicable in C#. Some of them are more relevant and popular than others. Some are already supported by the language features or the .NET framework. Some of them may be outdated or replaced by newer patterns. šŸ˜® So, which GOF patterns are good for C#?  Creational patterns...
Read more

Angular on a regular SharePoint page (part 2)

Image
In my  previous article , we have added an empty angular element to the SharePoint page.  And now we are ready to move forward and add some functionality to our elements. Before we begin      First of all, let's create in SharePoint Announcements list with the name "Announcements" and add a couple of items with some text. We will access data in our list via the SharePoint REST API, calling "/_api/web/lists/getbytitle('Announcements')/Items" endpoint. Angular project      Now, open the angular elements project which we have created in the previous article in VS Code.      For convenience let's create an interface to work with our data model. Create the "data" folder wonder the "src/app" and create a new file named Announcement.ts.      Add this code to it: export interface Announcement { ID : number ; Title : string ; Body : string ; }      We will use the service to get the data from our list. ...
Read more

Chain of Responsibility pattern in C#

Hello, C# lovers! šŸ˜ Today I want to talk about a very useful design pattern called Chain of Responsibility. This pattern allows you to pass a request along a chain of handlers until one of them can handle it. This way, you can avoid coupling the sender of the request with the receiver, and you can dynamically compose the chain at runtime. Sounds cool, right? šŸ˜Ž Let’s see an example of how to implement this pattern in C#. Suppose you have a simple ATM machine that can dispense bills of 10, 20, and 50 dollars. You want to write a program that can handle any amount of money requested by the user, using the least number of bills possible. To do this, you can create an abstract class called Handler that defines an interface for handling the requests. It also has a reference to the next handler in the chain, and a method to set it. // The 'Handler' abstract class public abstract class Handler { protected Handler successor; public void SetSuccessor ( Handler successo...
Read more