Wie zu verwenden Repository-Schnittstelle, nutzt Generics mit Dependency Injection?

Ich bin versucht, verwenden Sie die folgende Generische Repository-Schnittstelle für DI-und constructor injection:

public interface IRepository<TEntity> : IDisposable where TEntity : class

Das problem ist, um zu definieren, die eine Instanz der Schnittstelle, ich muss die Klasse geben, wie diese:

private IRepository<Person> _personRepository;

Das Problem mit diesem ist, wenn ich mit DI (und ich bin mit der Einheit für IoC-framework), dann muss ich definieren, mehrere Instanzen in meinem Konstruktor, um alle repository-Schnittstellen, die ich brauche, um mit zu arbeiten, wie diese:

public MyClass(IRepository<Person> personRepository,
               IRepository<Orders> ordersRepository,
               IRepository<Items> itemsRepository,
               IRepository<Locations> locationsRepository)
{
  _personRepository = personRepository;
  _OrdersRepository = ordersRepository; 
  _itemsRepository = itemsRepository;
  _locationsRepository = locationsRepository;
}

Fragen:

  1. Ist das OK?
  2. Wenn nicht, wo bin ich verloren auf diesem Konzept?
  3. Auch wenn das ist die richtige, was ist der Punkt der Einheit zu registrieren, Schnittstelle zu den konkreten Typ? Ich habe es schon getan, da die generische repository mich gezwungen auf Erklärung.

Hilfe bitte deaktivieren Sie dieses, für mich, und ich Schätze Ihre Hilfe!

InformationsquelleAutor atconway | 2013-01-16
  1. 2

    Ist das OK?

    Sicher. Es ist persönliche Präferenz, ob constructor injection wie Sie haben oder property-injection. Constructor injection ist sauberer, da Sie nicht haben, um sehr viele Parameter an den Konstruktor, aber es ist sicherer als gut.

    was ist der Punkt der Einheit zu registrieren, Schnittstelle zu den konkreten Typ

    Ein Grund dafür ist, so dass Sie können unit-test MyClass ohne Ihre eigentliche repository schlägt in eine Datenbank. Sie können "fake", das repository zurück hartcodierte Werte zum testen gegen.

    • Was ich wünschte, ich könnte tun haben, ist IRepository<T> repository als parameter der Methode, aber ich weiß, dass wird nicht funktionieren. Können Sie erklären, warum es nicht? Es fühlt sich falsch an indem alle von denen, aber vielleicht ist es die richtige und ich bin über-denken.
    • Weil jedes repository ist ein anderer Typ und MeineKlasse (scheinbar) braucht 4 verschiedenen repositories. Sie haben, um die konkreten Klassen getrennt. Es ist nicht falsch (oder selten) haben mehrere Abhängigkeiten injiziert, wie Sie es tun.
    • Aber was ist mit der situation, als würde ich eine zusätzliche Methode?
    InformationsquelleAutor D Stanley
  2. 9

    Wie bereits von D Stanley, eine Abhängigkeit muss eine konkrete Schnittstelle. Ansonsten, wo sind Sie zu deklarieren, T? Ihre abhängig-Klasse können generisch sein, aber Sie haben noch zu sagen, dass "T ist eine Person, die" an einem gewissen Punkt.

    Sagte, dass, Einheit verarbeitet Registrierung von generischen Typen ziemlich gut.

    Lassen Sie uns sagen, Sie umzusetzen IRepository<T> mit einer generischen Klasse Repository<T> umschließt, die eine DbSet<T> (oder was auch immer).

    Folgende Anmeldung aus und löst dann die Arbeit (die Injektion in jeglicher Konstruktoren):

    container.RegisterType(typeof(IRepository<>), typeof(Repository<>));

//no specific registration needed for the specific type resolves
container.Resolve(<IRepository<Person>);
container.Resolve(<IRepository<Order>);

    Wenn Sie benötigt eine spezifische überschreibung der eine Typ (sagt der Elemente repository ist speziell für welchem Grund auch immer, so hat es eine voll umgesetzt ItemRepository Klasse), nur registrieren, dass die konkrete Umsetzung nach dem generischen:

    container.RegisterType<IRepository<Item>, ItemRepository>();

    Lösung IRespository<Item> erhalten nun Ihre konkrete Umsetzung.

    Für das Protokoll, ich denke, das kann nur sein getan in den code und nicht die Konfigurationsdateien. Jemand korrigiere diese Annahme.

    • Können Sie die Registrierung der generischen Klassen in der Einheit Konfiguration-Dateien. Ich habe es getan. <register type="IRepository[[Item]]" mapTo="ItemRepository" /> ist ein Beispiel. Liebe mich einige Einheit.
    InformationsquelleAutor Nick
  3. 2

    Könnten Sie erwägen, einen Aggregate-Service, dass bundles verschiedenen anderen Diensten zusammen, aber man sollte auch genau hinschauen, um zu sehen, ob Ihr MyClass ist versuchen, zu viel zu tun; eine große Anzahl von Abhängigkeiten kann ein Indiz.

    • Das Aggregat Dienst in diesem speziellen Fall ist, rufen Sie eine Unit of Work.
    InformationsquelleAutor Ian Mercer
  4. 2

    Scheint dies ok außer einem fehlenden Punkt; Sie müssen UnitOfWork-pattern zu aktivieren Transaktionen.
    Ohne UnitOfWork-pattern angewendet wird, werden alle repositories versuchen, commit db-Operationen auf verschiedene Kontexte.

    • Nichts in seiner Frage weist in die Richtung, die ihn erfordern UoW. Als jemand anderes darauf hingewiesen, vielleicht seine Klasse ist zu viel zu tun, aber er hat nie angegeben, alles zu versuchen, um änderungen auf alle repository auf einmal. Auch technisch unterschiedliche repositories nicht notwendigerweise anderen Kontext.
    InformationsquelleAutor daryal
  5. 0

    Ich musste das tun, über die Konfigurationsdatei. Es ist eigentlich ziemlich einfach, aber ich brauchte eine Weile, um es herauszufinden.

    In diesem Beispiel haben wir eine Schnittstelle IRepository<T> und es hat 2 Implementierungen:

    1. OneRepository
    2. TwoRepository

    Wir haben dann eine Klasse mit dem Namen Worker abhängig IRepository<One> und IRepository<Two>. Wir bitten die Einheit zum erstellen einer Instanz des Worker für uns und herauszufinden, die Abhängigkeiten aus der config-Datei.

    Schnittstelle und Implementierung

    Alle diese sind im namespace ConsoleApplication1 in diesem Beispiel.

    public class Worker
{
    private readonly IRepository<One> one;
    private readonly IRepository<Two> two;

    public Worker(IRepository<One> one, IRepository<Two> two)
    {
        this.one = one;
        this.two = two;
    }

    public string DoOne()
    {
        return this.one.Add(new One());
    }

    public string DoTwo()
    {
        return this.two.Add(new Two());
    }
}

public interface IRepository<T>
{
    string Add(T t);
}

public class OneRepository : IRepository<One>
{
    public string Add(One t)
    {
        return "One";
    }
}

public class TwoRepository : IRepository<Two>
{
    public string Add(Two t)
    {
        return "Two";
    }
}

public class One { }
public class Two { }

    Einheit Konfiguration

    Bitte beachten: wir weisen der Einheit und sagen Sie den Namen der assembly. Dann registrieren wir die 2 Implementierungen.

    <?xml version="1.0" encoding="utf-8"?>
<configuration>
  <configSections>
    <section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection, Microsoft.Practices.Unity.Configuration" />
  </configSections>
  <unity xmlns="http://schemas.microsoft.com/practices/2010/unity">
    <assembly name="ConsoleApplication1" />
    <container>
      <register type="ConsoleApplication1.IRepository[[ConsoleApplication1.One]]" mapTo="ConsoleApplication1.OneRepository" />
      <register type="ConsoleApplication1.IRepository[[ConsoleApplication1.Two]]" mapTo="ConsoleApplication1.TwoRepository" />
    </container>
  </unity>
</configuration>

    Anwendung

    Dies ist die Zusammensetzung Root.

    public class Program
{
    static void Main()
    {
        UnityContainer container = new UnityContainer();
        var res = container.LoadConfiguration();
        Worker worker = res.Resolve<Worker>();
        Console.WriteLine(worker.DoOne());
        Console.WriteLine(worker.DoTwo());
        Console.Read();
    }
}

    Als Ausgabe zu erwarten ist:

    One
Two
    InformationsquelleAutor CodingYoshi
Schreibe einen Kommentar