Quero encontrar mais elegante e apreciar a maneira de injetar processadores em CommandProcessorDispatcher
sala de aula. Ou pode ser outra solução (o objetivo é separar cada lógica de processamento de comando para uma classe independente). Talvez algum padrão de design possa ser útil aqui.
public interface ICommand { }
public class StartCommand : ICommand { }
public class StopCommand : ICommand { }
public interface ICommandProcessor<in T> where T : ICommand
{
void Process(T command);
}
public class StartCommandProcessor : ICommandProcessor<StartCommand>
{
public void Process(StartCommand command) { }
}
public class StopCommandProcessor : ICommandProcessor<StopCommand>
{
public void Process(StopCommand command) { }
}
public interface ICommandProcessorDispatcher
{
void Process(ICommand command);
}
public class CommandProcessorDispatcher : ICommandProcessorDispatcher
{
public CommandProcessorDispatcher(Dictionary<Type, Action<ICommand>> processors)
{
_processors = processors;
}
private readonly Dictionary<Type, Action<ICommand>> _processors;
public void Process(ICommand command)
{
_processors[command.GetType()](command);
}
}
internal class Program
{
private static void Main(string[] args)
{
var dict = new Dictionary<Type, Action<ICommand>>
{
{ typeof(StartCommand), x => new StartCommandProcessor().Process((StartCommand)x) },
{ typeof(StopCommand), x => new StopCommandProcessor().Process((StopCommand)x) },
};
var dispatcher= new CommandProcessorDispatcher(dict);
}
}
ICommand
é definido com essas tecnologias e usado extensivamente, por isso é difícil separar isso da minha mente. Qual é o objetivo final? Talvez o conceito subjacente possa usar algum refinamento.Respostas:
Eu acredito que você pode simplificar um pouco as coisas, sem muito clichê, enquanto ainda desfruta de algum tipo de segurança.
Um exemplo artificial:
Isso faz menos suposições sobre como os processadores de comando são armazenados e não requer delegados Action, que eu perdi para ver o objetivo em seu exemplo - finalmente, acho que é preferível fazer o downcast (de ICommand a uma de suas implementações) ) ocorrem apenas em um local.
fonte