.net-core Dependency Injection

Question

Ich habe ein generisches Repository, das ich für DI registrieren möchte, es implementiert ein Interface IRepository.

Normalerweise würde ich eine Instanz davon wie folgt erstellen:

IRepository repo = new Repository<Order>(); 

aber ich Geschwindigkeit aufstehen versuchen in .net 5 vor Release und will diesen mit DI arbeiten zu bekommen, habe ich Zuflucht auf die folgenden:

services.AddTransient<DAL.IRepository<Models.Order>, DAL.Repository<Models.Order>>(); 

Aber das fühlt sich falsch, ich will nicht über 50 Linien in es eine für jede der Klassen in meinem Modell ...

ich nicht alles online über t finden Ich weiß, dass es mit anderen IOC-Containern möglich ist. Aber da es sich um ein Lernprojekt handelt, möchte ich keinen anderen Container verwenden, sondern alles mit .net5s nativen Containern.

Answer 1

Nach einigem Hin und her die Kommentare zu anderen Antworten Ich habe eine funktionierende Lösung, es ist vielleicht nicht der beste Weg, aber es funktioniert. Ich werde das Update erneut durchführen, wenn ich eine bessere Möglichkeit finde, dies zu implementieren.

Die beiden Fragen, die ich hatte waren: Wir brauchten eine generische Schnittstelle zu registrieren, das Problem hier war eine Unaufmerksamkeit von mir .. ich falsch die Syntax hatte eine generische Art für die Registrierung, die natürlich ist:

services.AddTransient(typeof(IRepository<>), typeof(Repository<>)); 

Das zweite Problem war, dass ich eine Assembly habe, die 50+ verschiedene Modelle enthält, die ich registriert haben wollte. Die Art, wie ich dies ansprach, war eine Methode zu schreiben, die ich zusammen mit dem Namespace eine Liste von Assemblies übergeben kann zu registrieren und es iteriert über alle Typen, die den Kriterien entsprechen, und registriert sie im DI-Container.

public void RegisterModels(IServiceCollection services, string[] Assemblies, string @NameSpace) 
    { 
     foreach (var a in Assemblies) 
     { 
      Assembly loadedAss = Assembly.Load(a); 

      var q = from t in loadedAss.GetTypes() 
        where t.IsClass && !t.Name.Contains("<") && t.Namespace.EndsWith(@NameSpace) 
        select t; 

      foreach (var t in q.ToList()) 
      { 
       Type.GetType(t.Name); 
       services.AddTransient(Type.GetType(t.FullName), Type.GetType(t.FullName)); 
      } 
     } 
    } 

Dies ist dann von der startup.cs Methode ConfigureServices aufgerufen:

public void ConfigureServices(IServiceCollection services) 
    { 
     // Add framework services. 
     services.AddEntityFramework() 
      .AddSqlServer() 
      .AddDbContext<TestContext>(options => 
       options.UseSqlServer(@"Server=LOCALHOST\SQLEXPRESS;Database=Test;Trusted_Connection=True;")); 

     services.AddMvc(); 

     RegisterModels(services, new string[] { "UI" }, "UI.Models"); 

     services.AddTransient(typeof(IRepository<>), typeof(Repository<>)); 
    } 

Es gibt einen besseren Weg, dies zu tun sein mag, es ist auf jeden Fall anders DI-Container verwenden, wenn jemand Verbesserungen zu bieten hat lass es mich wissen, bitte.

Answer 2

Sie können eine Erweiterungsmethode erstellen, um alle einzelnen Elemente einzukapseln, die registriert werden müssen.

, dass die gleiche Technik Microsoft ist, unter Verwendung, zum Beispiel Sie dies nur in Start setzen:

services.AddMvc(); 

aber das ist eine Erweiterung Methode und hinter den Kulissen können Sie darauf wetten, es wird ein paar Sachen Registrierung es braucht.

so können Sie Ihre eigene Erweiterungsmethode wie folgt erstellen:

using Microsoft.Extensions.DependencyInjection; 
public static IServiceCollection AddMyFoo(this IServiceCollection services) 
{ 
    services.AddTransient<DAL.IRepository<Models.Order>, DAL.Repository<Models.Order>>(); 
    //.... 

    return services; 
} 

und indem die Methode die IServiceCollection zurückkehren Sie machen es fließend, so dass Sie Kommentar Aktualisiert tun können

services.AddMyFoo().AddSomeOtherFoo(); 

basierend auf

Die andere Technik zur Reduzierung von Registrierungen ist, wenn Ihre Abhängigkeit selbst keine Abhängigkeiten hat, können Sie den Konstruktor dazu bringen, einen Standardwert von null zu haben Sie haben immer noch eine Entkopplung und könnten später eine andere übergeben, aber die DI wird keinen Fehler auslösen und Sie können nur instanziieren, was Sie brauchen, wenn sie nicht übergeben wird.

public class MyFoo(IFooItemDependency myItem = null) 
{ 
    private IFooItemDependency internalItem; 

    public MyFoo(IFooItemDependency myItem = null) 
    { 
     internalItem = myItem ?? new FooItemItem(); 
    } 
} 

Answer 3

Ich bin nicht 100% sicher, was Ihre Frage ist, ich nehme an, Sie nicht

services.AddTransient<DAL.IRepository<Models.Order>, DAL.Repository<Models.Order>>(); 
services.AddTransient<DAL.IRepository<Models.Person>, DAL.Repository<Models.Person>>(); 
services.AddTransient<DAL.IRepository<Models.Invoice>, DAL.Repository<Models.Invoice>>(); 

etc

Ich habe dies getan, vor (mit ninject) haben wollen

Bind(typeof(IRepository<>)).To(typeof(Repository<>)).InRequestScope(); 

ich für die Einheit vorstellen, dass Sie etwas ähnliches wie

tun können

services.AddTransient<DAL.IRepository<>, typeof(Repository<>)(); 

und dann in einem

Service zu nutzen

public OrderService(IRepository<Models.Order> orderRepository) 
{ 
    this.orderRepository = orderRepository; 
} 

EDIT

Wie OP ist die korrekte Syntax darauf hingewiesen:

services.AddTransient(typeof(IRepository<>), typeof(Repository<>)); 

Answer 4

sollten Sie in der Lage sein, die offen generic registrieren

services.AddTransient(typeof(IRepository<>), typeof(Repository<>)); 

Answer 5

Sie eine Konvention basierte Registrierung Bibliothek wie Scrutor nutzen könnten.

Scrutor ist eine kleine Open-Source-Bibliothek, die eine fließende API zur Registrierung von Diensten in Ihrem Microsoft.Extensions.DependencyInjection-Container basierend auf Konventionen bietet (ähnlich der AutoFac-Methode RegisterAssemblyTypes, StructureMaps Scan-Methode und Ninjects Conventions).

Dies ermöglicht es Ihnen, so etwas zu tun:

services.Scan(scan => scan 
      .FromAssemblies(<<TYPE>>.GetTypeInfo().Assembly) 
       .AddClasses(classes => classes.Where(x => { 
        var allInterfaces = x.GetInterfaces(); 
        return 
         allInterfaces.Any(y => y.GetTypeInfo().IsGenericType && y.GetTypeInfo().GetGenericTypeDefinition() == typeof(IRepository<>))); 
       })) 
       .AsSelf() 
       .WithTransientLifetime() 
     );