Início / coding / Perguntas / 78942598
Accepted
lonix
Asked: 2024-09-03 11:42:23 +0800 CST

Tipos de registro da varredura de assembly em relação à interface e implementação no ASP.NET Core DI

  • 772

Para registrar algum serviço em relação à interface e à implementação:

services.AddSingleton<IFoo, Foo>();
services.AddSingleton<Foo>(x => x.GetRequiredService<IFoo>());

Isso garante que seja possível resolver ambos IFooe Foo, e que o contêiner forneceria a mesma instância .

Estou tentando estender esse conceito ao meu caso de uso:

Eu escrevi uma biblioteca que executa uma varredura de assembly na inicialização e registra automaticamente tipos que implementam IAnalyser. No código do cliente, quero resolver ambos IEnumerable<IAnalyser>e FooAnalyser.

Não tenho certeza de como realizar os registros. Isto é o que tenho até agora:

IEnumerable<Type> implementationTypes = ScanClientAssembliesForImplementationsOfIAnalyser();

foreach (var implementationType in implementationTypes)
{
  services.AddSingleton(typeof(IAnalyser), implementationType);  // (1) works
  //services.AddSingleton(implementationType);                   // (2) incorrect
  services.AddSingleton(x => /* ...?... */);                     // (3)
}

O registro em (1) corretamente me permite resolver IEnumerable<IAnalyser>.

O registro em (2) me permite resolver FooAnalyser, mas seria uma instância diferente e, portanto, está incorreto.

Acho que a abordagem correta é registrar a mesma instância por meio de uma fábrica. Como faço isso em (3)?

(Observe que minha abordagem acima pode estar errada. Tudo o que quero é resolver ambos IEnumerable<IAnalyser>e FooAnalyser, no código do cliente. Talvez haja uma maneira completamente diferente de fazer isso?)

c#

2 respostas

  1. Best Answer

    Encontrei uma solução mais fácil.

    Há uma coisa boa: quando você registra a implementação para a interface, você sempre pode (imediatamente) resolver IEnumerable<interface>obter todas as implementações registradas.

    Dito isso, poderíamos simplesmente percorrer todos os tipos, registrando-os como singleton para o tipo e registrá-los como implementação de interface usando o método de fábrica, como abaixo:

    // Registartion code
IEnumerable<Type> implementationTypes = ScanClientAssembliesForImplementationsOfIAnalyser();

foreach (var type in implementationTypes)
{
    builder.Services.AddSingleton(type);
    builder.Services.AddSingleton(typeof(IAnalyser), sp => sp.GetRequiredService(type));
}

    Tenho uma configuração de exemplo:

    public interface IAnalyser { }
public class Analyzer1 : IAnalyser { }
public class Analyzer2 : IAnalyser { }

    E então resolução (com APIs mínimas, mas isso também funciona com controladores):

    app.MapGet("/weatherforecast", (IEnumerable<IAnalyser> analyzers, Analyzer1 a1, Analyzer2 a2) =>
{
    var result = analyzers.ElementAt(0) == a1; // true
    result = analyzers.ElementAt(1) == a2; // true
});
    • 2

  2. Encontrei uma solução alternativa, mas não gostei:

    // allow resolution of `IEnumerable<IAnalyser>`                // as before
services.AddSingleton(typeof(IAnalyser), implementationType);

// allow resolution of `FooAnalyser`                           // <-----
services.AddSingleton(implementationType, x => x
  .GetRequiredService<IEnumerable<IAnalyser>>()
  .Single(y => y.GetType().Equals(implementationType)));

    Parece muito caro fazer isso para cada resolução. (Mas admito que, se houvesse alguma maneira integrada de fazer o que eu quero, provavelmente faria algo parecido.)

    Se você encontrar um erro na minha abordagem, por favor, me avise. Se houver uma maneira melhor, por favor, adicione sua resposta e eu a aceitarei.

    • 1

relate perguntas