Generische Interface-Vererbung und Implementierung Klasse für die Repository-Muster

Ich habe ein wenig gelesen über Zwänge und versuche es zu implementieren, in meinem repository-pattern.

Ich möchte etwas wie die unten, kann aber nicht Recht bekommen es zu kompilieren.

 public interface IRepository<T>
 {
    void GetAllData<T>();
 }

 //This needs to inherit from IRepository
 //T has to be a model class
 //V has to be a class that implements IEmployeeRepo
 public interface IEmployeeRepo<T, V> where V : EmployeeRepo where T : class : IRepository<T>
 {
    void DoSomethingEmployeeRelated();
 }

 //Dont think this inheritance is correct
 public class EmployeeRepo<Employee, this> : IEmployeeRepo
 {


 }

 //My example model class
 public class Employee
 {
     public string Name {get;set;}
 }
Es gibt viel zu viele Fehler in deinem code (ich kann den spot 3 zumindest), um zu verstehen, was Sie wollen.
Lesen Sie die Hinweise oben IEmployeeRepo und auch erwähnte ich das es nicht kompilieren

InformationsquelleAutor Jon | 2011-01-24

  1. 18

    Nicht sicher, warum Sie zwei Typ-Parameter für das Repository - was ist der Punkt?

    *Hier ist das klassische Beispiel für eine .NET Repository mit Generics: *

    *Erste, der Repository-Schnittstelle: *

    public interface IRepository<T> where T : class
{
   T FindSingle(Expression<Func<T,bool>> predicate);
   IQueryable<T> FindAll(); //optional - matter of preference
   void Add(T entity);
   void Remove(T entity);
}

    *Zweite, die Generische Repository-Implementierung (EF als Beispiel): *

    public abstract class GenericRepository<T> : IRepository<T>
{
   private IObjectSet<T> _ObjectSet; //get this in via DI (for example)

   public T FindSingle(Expression<T,bool>> predicate)
   {
      return _ObjectSet.SingleOrDefault(predicate);
   }

   //you can figure out how to do the other implementation methods
}

    *Dann, das Spezifische Repository (Sie sollten eine pro Aggregat root, und auch eine Schnittstelle für jede spezifische repository-Details-spezifische Methoden): *

    public EmployeeRepository : GenericRepository<Employee>, IRepository<Employee>
{
   //all regular methods (Find, Add, Remove) inherited - make use of them
   public Employee FindEmployeeByName(string name)
   {
      return FindAll().SingleOrDefault(x => x.Name == name);
      //or you could do: return FindSingle(x => x.Name == name);    
   }
}

    Verwendung:

    IRepository<Employee> repository = new EmployeeRepository<Employee>();

    Gehen nicht auf die Suche gehen zu verrückt mit Generika - das einzige, das Sie brauchen, ist zum begrenzen der Repository für die Verwendung durch eine Person, die ist gekapselt hinter dem Repository.

    Ich einfach verwenden where T : class.

    Anderen verwenden where T : IDomainAggregate oder ähnliches, um die Einschränkungen, die auf den tatsächlichen Typ der Entität, was erlaubt ist.

    Darf ich Fragen, hast du die Dokumentation von irgendwo oder hast du es geschrieben?
    es schrieb mich. Der code ist ähnlich, was ich verwenden.
    +1 für domain-Aggregate.

    InformationsquelleAutor RPM1984

  2. 5

    In dieser situation normalerweise habe ich eine base-repo-Klasse, die IRepository<> und eingegeben wird, um eine Basis-Model-Klasse.

    public interface IRepository<T> where T : IModel
 {
    void GetAll<T>();
    void GetById<T>(int id);
 }    

 public interface IEmployeeRepo<T> : IRepository<T> where T : IModel
 {
    void DoSomethingEmployeeRelated();
 }

 public class BaseRepo : IRepository<T> where T : IModel
 {

    public void GetAll<T>()
    {

    }

    public void GetById<T>(int id)
    {

    }
 }


 public class EmployeeRepo : BaseRepo<Employee>,  IEmployeeRepo<Employee>
 {
    public void DoSomethingEmployeeRelated()
    {

    }

 }

 //My example model class
 public class Employee : IModel
 {
     public int Id {get;set;}
     public string Name {get;set;}
 }

    InformationsquelleAutor TimC

  3. 1

    Versuchen Sie dieses;

    public interface IRepository<T>
 {
    void GetAllData<T>();
 }

 //This needs to inherit from IRepository
 //T has to be a model class
 //V has to be a class that implements IEmployeeRepo
 public interface IEmployeeRepo<T, V> : IRepository<T> where V : EmployeeRepo where T : class
 {
    void DoSomethingEmployeeRelated();
 }

 //Dont think this inheritance is correct
 public class EmployeeRepo : IEmployeeRepo<Employee, EmployeeRepo>
 {
    public void DoSomethingEmployeeRelated()
    {

    }

    public void GetAllData<Employee>()
    {

    }
 }

 //My example model class
 public class Employee
 {
     public string Name {get;set;}
 }

    InformationsquelleAutor Rob

Schreibe einen Kommentar