How To Implement The Decorator Pattern With Autofac

In the realm of software development, understanding theoretical concepts is only half the battle. Practical examples serve as a bridge, translating abstract ideas into tangible implementations that can be visualized, tested, and refined. They provide a hands-on approach, allowing developers to see how a concept works in a real-world setting, making the learning process more effective and relatable. So let’s see how to implement the decorator pattern with Autofac!

The Decorator Pattern is a design pattern that allows behavior to be added to individual objects, either statically or dynamically, without affecting the behavior of other objects from the same class. It promotes the Single Responsibility Principle, ensuring that each class has only one reason to change. While the pattern itself offers a structured approach to enhance object functionalities, its implementation can become cumbersome, especially when multiple decorators are involved.

This is where Autofac comes into play. Autofac is a popular Inversion of Control container for .NET, which simplifies the process of registering and resolving dependencies, including decorators. By leveraging Autofac, developers can seamlessly implement the Decorator Pattern, ensuring that dependencies are injected appropriately and that the overall code remains clean and maintainable. In this article, we’ll delve into practical examples of how to combine the power of the Decorator Pattern with the simplicity of Autofac in different application contexts.

Autofac Example 1: Implement The Decorator Pattern In A Simple Console Application

Setting Up Autofac in a Console Application

Before we see how to implement the Decorator Pattern with Autofac, it’s essential to set up Autofac in your console application. Here’s a step-by-step guide:

1. Start by creating a new Console Application in Visual Studio.
2. Use the NuGet Package Manager to install the Autofac package.
3. Once installed, you can initialize the Autofac container. This container will be responsible for registering your classes and resolving dependencies.

We’ll walk through that last step in more detail so we can see how we can use Autofac to implement the decorator pattern.

Defining Core Interfaces and Classes for the Console App

For our console application, let’s consider a scenario where we have a basic IMessageService that sends messages. We’ll then decorate this service to add additional functionalities.

public interface IMessageService
{
    void SendMessage(string message);
}

public class MessageService : IMessageService
{
    public void SendMessage(string message)
    {
        Console.WriteLine(message);
    }
}

In this basic setup, our MessageService simply outputs a message to the console.

Crafting Decorators for the Console App

Now, let’s create a decorator to enhance our MessageService. Suppose we want to add a timestamp to each message. We can achieve this with a decorator:

public class TimestampedMessageServiceDecorator : IMessageService
{
    private readonly IMessageService _innerService;

    public TimestampedMessageServiceDecorator(IMessageService innerService)
    {
        _innerService = innerService;
    }

    public void SendMessage(string message)
    {
        var timestampedMessage = $"{DateTime.Now}: {message}";
        _innerService.SendMessage(timestampedMessage);
    }
}

This decorator wraps around our original MessageService and adds a timestamp to the message before sending it.

Registering and Resolving Dependencies with Autofac in the Console App

With our core classes and decorators in place, we can now register them with Autofac and resolve dependencies:

var builder = new ContainerBuilder();

// Register core services
builder
    .RegisterType<MessageService>()
    .As<IMessageService>();

// Register decorators
builder.RegisterDecorator<TimestampedMessageServiceDecorator, IMessageService>();

var container = builder.Build();

// Resolve dependencies and use the service
using var scope = container.BeginLifetimeScope();
var messageService = scope.Resolve<IMessageService>();
messageService.SendMessage("Hello, Decorator Pattern!");

When you run the application, you’ll see the message printed with a timestamp, demonstrating the decorator in action.

Autofac Example 2: Implement The Decorator Pattern in an ASP.NET Web Application

In this section we’ll dive into how to set things up with ASP.NET core, which you can also watch in this video:

Setting Up Autofac in an ASP.NET Web Application

Integrating Autofac into an ASP.NET project is straightforward, but it requires a few additional steps compared to a console application:

1. Create a new ASP.NET Web Application in Visual Studio.
2. Use the NuGet Package Manager to install the Autofac and Autofac.Mvc5 packages.
3. In the Global.asax.cs file, set up the Autofac container during the application’s start event.

Defining Core Interfaces and Classes for the Web App

For our web application, let’s consider a scenario where we have a basic IUserService that retrieves user data.

public interface IUserService
{
    User GetUser(int userId);
}

public class UserService : IUserService
{
    public User GetUser(int userId)
    {
        // Fetch user from the database or any other source
        return new User { UserId = userId, UserName = "JohnDoe" };
    }
}

This service fetches user data, which, in a real-world scenario, might come from a database or an external API. The IUserService type was omitted for brevity, but it could be implemented simply with a class or record type.

Creating Decorators for the Web App

Let’s create a decorator that caches user data to reduce unnecessary database calls:

public class CachingUserServiceDecorator : IUserService
{
    private readonly IUserService _innerService;
    private readonly Dictionary<int, User> _cache = new Dictionary<int, User>();

    public CachingUserServiceDecorator(IUserService innerService)
    {
        _innerService = innerService;
    }

    public User GetUser(int userId)
    {
        if (!_cache.TryGetValue(userId, out var user))
        {
            user = _innerService.GetUser(userId);
            _cache[userId] = user;
        }
        return user;
    }
}

This decorator checks if the user data is already in the cache. If not, it fetches the data using the original service and then caches it.

Registering and Resolving Dependencies with Autofac in the Web App

With the core classes and decorators ready, we can register them with Autofac. If you’re using the traditional MVC approach with ASP.NET, you would need to ensure you grab some extra nuget packages. These include:

• Autofac.Extensions.DependencyInjection
• Autofac.Mvc.Core

You would then use code like the following (typically in the Startup.cs file):

public IServiceProvider ConfigureServices(IServiceCollection services)
{
    services.AddMvc();

    var builder = new ContainerBuilder();

    // Register core services
    builder.RegisterType<UserService>().As<IUserService>();

    // Register decorators
    builder.RegisterDecorator<CachingUserServiceDecorator, IUserService>();

    // Populate the services from the collection
    builder.Populate(services);

    var container = builder.Build();

    // Return the IServiceProvider implementation
    return new AutofacServiceProvider(container);
}

Now, when you request the IUserService in your controllers, Autofac will provide the decorated version, ensuring that user data is cached efficiently.

If you’re set to use the new minimal API approach, your setup will vary slightly:

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

var containerBuilder = new ContainerBuilder();

// Register core services
containerBuilder
    .RegisterType<UserService>()
    .As<IUserService>();

// Register decorators
containerBuilder.RegisterDecorator<CachingUserServiceDecorator, IUserService>();

// Populate the services from the collection
containerBuilder.Populate(builder.Services);

var container = containerBuilder.Build();

app.Services.AddAutofac(container);

This is, yet again, an example where the minimal API setup simplifies many aspects of setting up a web application. It’s essential to understand the underlying concepts, especially when integrating third-party libraries like Autofac!

Wrapping Up How To Implement The Decorator Pattern

The Decorator Pattern stands out as a powerful tool in a developer’s toolkit, offering a structured approach to augmenting functionality in a modular and maintainable manner. As we’ve seen through the examples, whether it’s a straightforward console application or a more complex ASP.NET web application, the pattern seamlessly integrates, allowing for dynamic extensions without altering existing code.

When we implement the Decorator Pattern, we can simplify our lives greatly by leveraging a framework like Autofac. The flexibility it offers, especially in the context of ASP.NET Core, is a testament to the evolving landscape of software development, where patterns and tools converge to create efficient and scalable solutions.

For those new to the Decorator Pattern or Autofac, the examples provided serve as a simple initial guide. However, the true power of these concepts is realized when they are adapted to unique challenges and specific project requirements. Every application and every scenario has its nuances, and as developers, the ability to tailor solutions to these nuances is invaluable.

While the examples here offer a starting point, the journey to implement the Decorator Pattern and effectively leveraging Autofac is one of continuous learning and experimentation. Embrace the pattern, understand its strengths and limitations, and most importantly, adapt and innovate. Your software solutions will be all the better for it.

Nick Cosentino Principal Software Engineering Manager

Principal Software Engineering Manager at Microsoft. Views are my own.

See Full Bio

ASP.NET C# DotNet .NET Software Engineering