Specification Pattern in C# - A Practical Example

Introduction

The Specification Pattern is a powerful design pattern that helps you encapsulate business rules for selecting objects in a clean and reusable way. Instead of scattering these rules throughout your codebase, you define them as separate “Specification” objects. This leads to more maintainable, testable, and flexible code.

Why use the Specification Pattern?

Code Reusability: Specifications can be reused across different parts of your application, avoiding code duplication.
Maintainability: Business rule changes are isolated within the specification classes, making updates easier and less error-prone.
Testability: Specifications are simple objects that can be easily unit tested in isolation.
Separation of Concerns: Keeps business rules separate from data access logic, promoting a cleaner architecture.

A Practical Example: Filtering Shipping Methods

Let’s imagine you’re building an e-commerce application and need to filter available shipping methods based on various criteria. This is a perfect scenario for the Specification Pattern.

Core Components

The ISpecification Interface: This interface defines the basic contract for all specifications. It typically includes a method to check if an object satisfies the specification.
```
public interface ISpecification<T>
{
    bool IsSatisfiedBy(T item);
}
```

Concrete Specifications: These classes implement the ISpecification interface and encapsulate specific business rules. For example:

ShippingMethodIsActive: Checks if a shipping method is currently active.

public class ShippingMethodIsActive : ISpecification<ShippingMethod>
{
    public bool IsSatisfiedBy(ShippingMethod item)
    {
        return item.IsActive;
    }
}

ShippingMethodIsEligible: Checks if a shipping method is eligible for a given address.

public class ShippingMethodIsEligible : ISpecification<ShippingMethod>
{
    private readonly string _countryCode;

    public ShippingMethodIsEligible(string countryCode)
    {
        _countryCode = countryCode;
    }

    public bool IsSatisfiedBy(ShippingMethod item)
    {
        // Complex logic to determine eligibility based on country, weight, etc.
        return item.ShippingRules.Any(r => r.CountryCode == _countryCode);
    }
}

The Repository (or Service): This component uses the specifications to filter data.

public class ShippingService
{
    private readonly IReadOnlyList<ShippingMethod> _shippingMethods;

    public ShippingService(IReadOnlyList<ShippingMethod> shippingMethods)
    {
        _shippingMethods = shippingMethods;
    }

    public IEnumerable<ShippingMethod> GetShippingMethods(ISpecification<ShippingMethod> specification)
    {
        return _shippingMethods.Where(specification.IsSatisfiedBy);
    }
}

Combining Specifications

One of the most powerful aspects of the Specification Pattern is the ability to combine specifications using logical operators like AND, OR, and NOT. You can create helper methods or extension methods to achieve this.

public static class SpecificationExtensions
{
    public static ISpecification<T> And<T>(this ISpecification<T> first, ISpecification<T> second)
    {
        return new AndSpecification<T>(first, second);
    }
}

public class AndSpecification<T> : ISpecification<T>
{
    private readonly ISpecification<T> _first;
    private readonly ISpecification<T> _second;

    public AndSpecification(ISpecification<T> first, ISpecification<T> second)
    {
        _first = first;
        _second = second;
    }

    public bool IsSatisfiedBy(T item)
    {
        return _first.IsSatisfiedBy(item) && _second.IsSatisfiedBy(item);
    }
}

Example Usage

// Get all active shipping methods that are eligible for a specific country
ISpecification<ShippingMethod> specification = new ShippingMethodIsActive()
    .And(new ShippingMethodIsEligible("US"));

IEnumerable<ShippingMethod> shippingMethods = _shippingService.GetShippingMethods(specification);

Benefits of using the Specification Pattern

Increased Flexibility: Easily add new filtering rules by creating new specification classes.
Improved Maintainabilit: Changes to existing rules are isolated to their respective specification classes.
Enhanced Testability: Each specification can be tested independently.
Code Clarity: The intent of the filtering logic is clearly expressed through the specification classes.

Conclusion

The Specification Pattern is a valuable tool for managing complex filtering logic in your C# applications. By encapsulating business rules into reusable specification objects, you can create more maintainable, testable, and flexible code. This pattern is particularly well-suited for scenarios where you need to filter data based on a variety of criteria, such as in e-commerce applications, reporting systems, and data validation frameworks.

Introduction

A Practical Example: Filtering Shipping Methods

Example Usage

Benefits of using the Specification Pattern

Conclusion

See also