我如何结合这两个通用接口-ICommand和ICommand的命令处理程序<TResult>

Question

In my project I have 2 types of commands:

• Command without result (ICommand)
• Command with result (ICommand)

Now I have this command handlers:

public interface ICommandHandler<in TCommand> where TCommand : class, ICommand {
    Task Handle(TCommand command, CancellationToken cancellationToken = default(CancellationToken));
}

public interface ICommandHandler<in TCommand, TResult> where TCommand : class, ICommand<TResult> {
    Task<TResult> Handle(TCommand command, CancellationToken cancellationToken = default(CancellationToken));
}

Question: is it possible to create single ICommandHandler interface for both types of commands?

Answer 1

Before answering - here's a question: Why do you need one interface to include both? They are two different interfaces. If you keep them separate then a class can implement one, the other, or both. If you already have that flexibility without combining the two interfaces into one, then there may be no benefit from combining them.

Think of it this way: A class is more likely to depend on just one interface or the other. It's either going to call the method that returns no result or the method that returns a result. (I can't say that for certain, only that it's more likely.) Keeping the interfaces separate allows a class to depend on just the interface it needs and nothing more, which follows the Interface Segregation Principle. This is true even if the class implements both interfaces.

Combining also gets a little bit messier because if you want all of the generic type arguments declared at the class level then you really have three generic arguments: TCommand , TResult , and yet another to represent ICommand<TResult> .

You could use inheritance so that at least your handler without a TResult stays separate:

public interface ICommandHandler<in TCommand>
    where TCommand : class, ICommand
{
    Task Execute(TCommand command, CancellationToken cancellationToken = default(CancellationToken));
}

public interface ICommandHandler<in TCommand, TResult, in TCommandWithResult> : ICommandHandler<TCommand>
    where TCommand : class, ICommand
    where TCommandWithResult : ICommand<TResult>
{
    Task<TResult> GetResult(TCommandWithResult command, CancellationToken cancellationToken = default(CancellationToken));
}

Or, if you really wanted to have them in one interface you could do that:

public interface ICombinedCommandHandler<in TCommand, TResult, in TCommandWithResult>
    where TCommand : class, ICommand
    where TCommandWithResult : ICommand<TResult>
{
    Task Execute(TCommand command, CancellationToken cancellationToken = default(CancellationToken));
    Task<TResult> GetResult(TCommandWithResult command, CancellationToken cancellationToken = default(CancellationToken));
}

You can eliminate the 3rd generic argument if ICommand<TResult> inherits from ICommand . Perhaps I have a simpler mind than some people, but this approaches the edge of what I call the Generic Rabbit Hole of Madness. At some point I start to wonder, seriously, why am I doing this, and there often isn't a good reason or I can't remember it.

public interface ICommand { }
public interface ICommand<TResult> : ICommand { }

public interface ICommandHandler<in TCommand>
    where TCommand : class, ICommand
{
    Task Execute(TCommand command, CancellationToken cancellationToken = default(CancellationToken));
}

public interface ICommandHandler<in TCommand, TResult> : ICommandHandler<TCommand>
    where TCommand : class, ICommand<TResult>
{
    Task<TResult> GetResult(TCommand command, CancellationToken cancellationToken = default(CancellationToken));
}