MediatR library: following the DRY principle

user_11285108 0
Viewed 240

I use library MediatR in my ASP.NET Core application.
I have the following entity Ad:

public class Ad
{
    public Guid AdId { get; set; }
    public AdType AdType { get; set; }
    public double Cost { get; set; }
    public string Content { get; set; }

    // ...
}
public enum AdType
{
    TextAd,
    HtmlAd,
    BannerAd,
    VideoAd
}

I want to introduce the ability to create a new ad. To do so, I've created the following command:

public class CreateAdCommand : IRequest<Guid>
{
    public AdType AdType { get; set; }
    public double Cost { get; set; }
    public string Content { get; set; }

    public class Handler : IRequestHandler<CreateAdCommand, Guid>
    {
        private readonly MyDbContext _context;

        public Handler(MyDbContext context)
        {
            _context = context;
        }

        public async Task<Guid> Handle(CreateAdCommand request, CancellationToken cancellationToken)
        {
            var ad = new Ad {AdType = request.AdType, Cost = request.Cost, Content = request.Content};
            
            _context.Ads.Add(ad);
            _context.SaveChangesAsync();

            return ad.AdId;
        }
    }
}

This code works great. But here is a huge problem: each ad-type has some additional logic to the ad creation process (e.g., when creating the ad of type TextAd we need to find the keywords in the content of the ad). The simplest solution is:

public async Task<Guid> Handle(CreateAdCommand request, CancellationToken cancellationToken)
{
    var ad = new Ad {AdType = request.AdType, Cost = request.Cost, Content = request.Content};

    _context.Ads.Add(ad);
    _context.SaveChangesAsync();

    switch (request.AdType)
    {
        case AdType.TextAd:
            // Some additional logic here...
            break;
        case AdType.HtmlAd:
            // Some additional logic here...
            break;
        case AdType.BannerAd:
            // Some additional logic here...
            break;
        case AdType.VideoAd:
            // Some additional logic here...
            break;
    }

    return ad.AdId;
}

This solution violates the Open Closed Principle (when I create a new ad-type, I need to create a new case inside of CreateAdCommand).

I have another idea. I can create a separate command for each ad-type (e.g., CreateTextAdCommand, CreateHtmlAdCommand, CreateBannerAdCommand, CreateVideoAdCommand). This solution follows the Open Closed Principle (when I create a new ad-type, I need to create a new command for this ad-type - I don't need to change the existing code).

public class CreateTextAdCommand : IRequest<Guid>
{
    public double Cost { get; set; }
    public string Content { get; set; }

    public class Handler : IRequestHandler<CreateTextAdCommand, Guid>
    {
        private readonly MyDbContext _context;

        public Handler(MyDbContext context)
        {
            _context = context;
        }

        public async Task<Guid> Handle(CreateTextAdCommand request, CancellationToken cancellationToken)
        {
            var ad = new Ad {AdType = AdType.TextAd, Cost = request.Cost, Content = request.Content};

            _context.Ads.Add(ad);
            await _context.SaveChangesAsync();
            
            // Some additional logic here ...

            return ad.AdId;
        }
    }
}

public class CreateHtmlAdCommand : IRequest<Guid>
{
    public double Cost { get; set; }
    public string Content { get; set; }

    public class Handler : IRequestHandler<CreateHtmlAdCommand, Guid>
    {
        private readonly MyDbContext _context;

        public Handler(MyDbContext context)
        {
            _context = context;
        }

        public async Task<Guid> Handle(CreateHtmlAdCommand request, CancellationToken cancellationToken)
        {
            var ad = new Ad {AdType = AdType.HtmlAd, Cost = request.Cost, Content = request.Content};

            _context.Ads.Add(ad);
            await _context.SaveChangesAsync();
            
            // Some additional logic here ...

            return ad.AdId;
        }
    }
}

// The same for CreateBannerAdCommand and CreateVideoAdCommand.

This solution follows the Open Closed Principle, but violates the DRY principle. How can I solve this problem?

mediatr cqrs dry .net c#
1 Answers

If you stick to your second approach, you can levarage MediatR 'Behaviors' (https://github.com/jbogard/MediatR/wiki/Behaviors). They act like pipelines, where you can offload common behavior into a commonly used handler.

To do this, create a marker interface

interface ICreateAdCommand {}

Now let each concreate command inherit from it

public class CreateTextAdCommand : ICreateAdCommand 
{
   public readonly string AdType {get;} = AdType.Text
}
public class CreateHtmltAdCommand : ICreateAdCommand 
{
   public readonly string AdType {get;} = AdType.Html
}
/*...*/

You could combine this or replace this with a common abstract base class, to avoid repetition of common properties. This is up to you.

Now we create the handler for our behavior:

public class CreateAdBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
where TReq : ICreateAdCommand
{
    public CreateAdBehavior()
    {
       //wire up dependencies.
    }

    public async Task<TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate<TResponse> next)
    {
        var ad = new Ad {AdType = request.AdType, Cost = request.Cost, Content = request.Content};

        _context.Ads.Add(ad);
        await _context.SaveChangesAsync();
        //go on with the next step in the pipeline
        var response = await next();

        return response;
    }
}

Now wire up this behavior. In asp.net core this would be in your startup.cs

 services.AddTransient(typeof(IPipelineBehavior<,>), typeof(CreateAdBehavior<,>));

At this stage, everytime any of your IRequests implement ICreateAdCommand, it would automatically call the handler above and after this is done it would call the next behavior in line, or if there is none, the actual handler.

Your specific handler for, let's say a HtmlAd would now roughly look like this:

public class CreateHtmlAdCommand : IRequest<Guid>
{
    public class Handler : IRequestHandler<CreateHtmlAdCommand, Guid>
    {
        private readonly MyDbContext _context;

        public Handler(MyDbContext context)
        {
            _context = context;
        }

        public async Task<Guid> Handle(CreateHtmlAdCommand request, CancellationToken cancellationToken)
        {
            // Some additional logic here ...
        }
    }
}

** Update **

If you want to drag data across the pipeline, you can leverage the actual request object.

public abstract class IRequestWithItems
{
    public IDictionary<string, object> Items {get;} = new Dictionary<string,object>();
}

Now in your CreateAdBehavior, you can create your ad and store it in the dictionary, to retrieve it in the next handler:

var ad = { ... }
await _context.SaveChangesAsync();
items["newlyCreatedAd"] = ad;

And in the actual Task<Guid> Handle() method, you have now the ad at your disposal, without looping back to your database to retrieve it again.

Details from the author: https://jimmybogard.com/sharing-context-in-mediatr-pipelines/

user_12496410
Related