Generische Einheit der Arbeit

Question

Ich habe EntityFramework Muster zusammen mit Repository und Unit Of Work implementiert. Die Implementierung ähnelt Code Project Repository Example, jedoch brauche ich eine Erweiterung für die Unit Of Work.

Die Arbeitseinheit

public class GenericUnitOfWork : IDisposable 
{ 
    // Initialization code 

    public Dictionary<Type, object> repositories = new Dictionary<Type, object>(); 

    public IRepository<T> Repository<T>() where T : class 
    { 
     if (repositories.Keys.Contains(typeof(T)) == true) 
     { 
      return repositories[typeof(T)] as IRepository<T> 
     } 
     IRepository<T> repo = new Repository<T>(entities); 
     repositories.Add(typeof(T), repo); 
     return repo; 
    } 

    // other methods 
} 

Die obige UOW ist ruhig verallgemeinert und es richtet sich an die Eltern immer Repository-Klasse. Ich habe eine andere Entität, zum Beispiel Student, die ein eigenes Repository hat, das die Repository-Klasse erweitert. Das studentenspezifische Repository hat eine Methode "GetStudentMarks()". Jetzt kann ich die allgemeine Unit Of Work-Klasse nicht verwenden, da sie immer auf das übergeordnete Repository verweist.

Wie implementiert man eine allgemeine Einheit der Arbeit, um solche Situationen zu behandeln? Danke im Voraus.

Answer 1

können Sie die Klasse machen GenericUnitOfWork Generika, die Einheit und Repository-Typ festgelegt wird:

public class GenericUnitOfWork<TRepo, TEntity> : IDisposable 
    where TRepo : Repository<TEntity> 
{ 
    // Initialization code 

    public Dictionary<Type, TRepo> repositories = new Dictionary<Type, TRepo>(); 

    public TRepo Repository() 
    { 
     if (repositories.Keys.Contains(typeof(TEntity)) == true) 
     { 
      return repositories[typeof(TEntity)]; 
     } 
     TRepo repo = (TRepo)Activator.CreateInstance(
      typeof(TRepo), 
      new object[] { /*put there parameters to pass*/ }); 
     repositories.Add(typeof(TEntity), repo); 
     return repo; 
    } 

    // other methods 
} 

So etwas sollte funktioniert.

Answer 2

Ich nehme an, dass Sie einige Operationen über StudentMarks in GetStudentMarks Methode ausführen möchten. Andernfalls, wenn Ihre Modelle korrekt zugeordnet sind, können Sie sie einfach mit einer der relationalen Lademethoden laden. Andernfalls, wenn allgemeine Repository ist für die meisten Ihrer Einheiten, aber Sie müssen einige zusätzliche Methoden für eine kleine Anzahl Ihrer Einheiten, dann empfehle ich die Schaffung Erweiterungsmethoden dieser Repositories:

public static class StudentReposityExtensions 
{ 
    public List<Mark> GetStudentMarks(
     this IRepository<Student> studentRepostitory) 
    { 
     ..... 
    } 
} 

Answer 3

Generisches UnitOfWork !!! Sie haben Implementierung der falschen Arbeitseinheit

Dieser Code Siehe:

using System.Data.Entity; 
using System; 


namespace EF_Sample07.DataLayer.Context 
{ 
public interface IUnitOfWork 
{ 
    IDbSet<TEntity> Set<TEntity>() where TEntity : class; 
    int SaveChanges(); 
    } 
} 

Warum verwenden UnitOfWork?

Denn:

• Bessere Leistung
• Concurrency gibt
• die korrekte Verwendung von Transaktionen

Siehe Beispiel:

Kategorie

public class Category 
{ 
    public int Id { get; set; } 
    public virtual string Name { get; set; } 
    public virtual string Title { get; set; } 


    public virtual ICollection<Product> Products { get; set; } 
} 

Produkt

public class Product 
{ 
    public int Id { get; set; } 
    public string Name { get; set; } 
    public decimal Price { get; set; } 


    [ForeignKey("CategoryId")] 
    public virtual Category Category { get; set; } 
    public int CategoryId { get; set; } 
} 

UnitOfWork

public interface IUnitOfWork 
{ 
    IDbSet<TEntity> Set<TEntity>() where TEntity : class; 
    int SaveChanges(); 
} 

DbContext

public class Sample07Context : DbContext, IUnitOfWork 
{ 
    public DbSet<Category> Categories { set; get; } 
    public DbSet<Product> Products { set; get; } 


    #region IUnitOfWork Members 
    public new IDbSet<TEntity> Set<TEntity>() where TEntity : class 
    { 
     return base.Set<TEntity>(); 
    } 
    public int SaveAllChanges() 
    { 
     return base.SaveChanges(); 
    } 
    #endregion 
}