Injeção de dependência no serviço Apache Ignite.NET

Ao desenvolver vários aplicativos que usam a popular biblioteca Castle Windsor para injetar dependências e o Apache Ignite.NET como a “chave” que abre as portas para a computação em nuvem, encontrei um pequeno inconveniente: não havia como injetar a dependência no serviço lançado através da chamada Service Grid.

A razão pela qual isso acontece é bastante comum. O Apache Ignite.NET serializa o serviço, envia-o para um dos servidores disponíveis, onde é desserializado e iniciado. Como esse processo não tem nenhuma pista sobre o Castelo de Windsor, obtemos o que conseguimos.

Para resolver esse problema, precisamos criar um plug-in para o Apache Ignite.NET, que receberá um contêiner responsável pela implementação de dependências e fornecerá ao serviço a oportunidade de acessá-lo para receber um objeto.

Primeiro, apresentaremos um nível adicional de abstração para o contêiner, que fornece injeção de dependência, para que no futuro possamos alterar facilmente sua implementação para outra:

public interface IContainer { T Resolve<T>(); } 

 public class DependencyInjectionContainer : IContainer { protected IKernel Kernel { get; set; } public DependencyInjectionContainer(IKernel kernel) { Kernel = kernel; } public T Resolve<T>() { return Kernel.Resolve<T>(); } } 

 public class DependencyInjectionInstaller : IWindsorInstaller { public void Install(IWindsorContainer container, IConfigurationStore store) { container.Register( Component .For<IContainer>() .ImplementedBy<DependencyInjectionContainer>() ); } } 

Para criar um plug-in, precisamos criar 3 classes: a classe responsável pela configuração do plug-in, o provedor do plug-in e, diretamente, o próprio plug-in.

 public class DependencyInjectionPlugin { public IContainer Container { get; set; } public T Resolve<T>() { return Container.Resolve<T>(); } } 

 [PluginProviderType(typeof(DependencyInjectionPluginProvider))] public class DependencyInjectionPluginConfiguration : IPluginConfiguration { public void WriteBinary(IBinaryRawWriter writer) { // No-op } public int? PluginConfigurationClosureFactoryId { get; } = null; // No Java part } 

 public class DependencyInjectionPluginProvider : IPluginProvider<DependencyInjectionPluginConfiguration> { public string Name { get; } = "DependencyInjection"; public string Copyright { get; } = "MIT"; protected DependencyInjectionPlugin DependencyInjectionPlugin { get; set; } public T GetPlugin<T>() where T : class { return DependencyInjectionPlugin as T; } public void Start(IPluginContext<DependencyInjectionPluginConfiguration> context) { DependencyInjectionPlugin = new DependencyInjectionPlugin(); } public void Stop(bool cancel) { } public void OnIgniteStart() { } public void OnIgniteStop(bool cancel) { } } 

Ótimo, resta carregar o plug-in no Apache Ignite.NET.

 public class IgniteInstaller : IWindsorInstaller { public void Install(IWindsorContainer container, IConfigurationStore store) { container.Register( Component .For<IIgnite>() .UsingFactoryMethod(() => Ignition.Start(new IgniteConfiguration { PluginConfigurations = new[] {new DependencyInjectionPluginConfiguration()} })) ); } } 

Quando o aplicativo inicia, como de costume, inicializamos o contêiner de injeção de dependência, mas agora estamos prontos para transmiti-lo ao plug-in que acabamos de escrever:

 var Done = new ManualResetEventSlim(false); // Build Windsor container using (var container = new WindsorContainer()) { // Install DI abstraction layer container.Install(new DependencyInjectionInstaller()); // Install cluster abstraction layer container.Install(new IgniteInstaller()); // Attach DI container to cluster plugin container .Resolve<IIgnite>() .GetPlugin<DependencyInjectionPlugin>("DependencyInjection") .Container = container.Resolve<IContainer>(); // Wait Done.Wait(); } 

Parabéns, se você ler até o final, poderá obter qualquer dependência do seu contêiner dentro do serviço. É assim:

 public class ClientConnectionService : IClientConnectionService, IService { private static readonly NLog.Logger Logger = NLog.LogManager.GetCurrentClassLogger(); [InstanceResource] private IIgnite Ignite { get; set; } public void Init(IServiceContext context) { Logger.Debug("Initialized"); } public void Execute(IServiceContext context) { var plugin = Ignite.GetPlugin<DependencyInjectionPlugin>("DependencyInjection"); var whatever = plugin.Resolve<IWhatever>(); whatever.DoSomething(); } public void Cancel(IServiceContext context) { Logger.Debug("Canceled"); } }