Korzystanie z ogólnej Repository wzór z Fluent NHibernate

Question

Jestem obecnie rozwijających się średniej wielkości aplikacji, która będzie dostępu 2 lub więcej baz danych SQL, w różnych miejscach itd ...

Zastanawiam użyciu coś podobnego do tego: http://mikehadlow.blogspot.com/2008/03/using-irepository-pattern-with-linq-to.html

jednak chcę użyć fluent NHibernate, zamiast LINQ-SQL (i oczywiście nHibernate.Linq)

Czy to opłacalne?

Jak skonfigurować konfigurację? Gdzie moje definicje mapowania pójdą itp ...?

Ta aplikacja docelowo będzie miała wiele aspektów - od WebUI, biblioteki WCF i aplikacji/usług Windows.

także, na przykład na stole "produkt", by utworzyć klasę "ProductManager", który ma metod takich jak:

GetProduct, GetAllProducts etc ...

Wszelkie wskaźniki są znacznie odbierane.

Answer 1

Moim zdaniem (i według niektórych opinii innych osób) repozytorium powinno być interfejsem, który ukrywa dostęp do danych w interfejsie, który naśladuje interfejs kolekcji. Dlatego repozytorium powinno być IQueryable i IEnumerable.

public interface IRepository<T> : IQueryable<T> 
{ 
    void Add(T entity); 
    T Get(Guid id); 
    void Remove(T entity); 
} 

public class Repository<T> : IQueryable<T> 
{ 
    private readonly ISession session; 

    public Repository(ISession session) 
    { 
    session = session; 
    } 

    public Type ElementType 
    { 
    get { return session.Query<T>().ElementType; } 
    } 

    public Expression Expression 
    { 
    get { return session.Query<T>().Expression; } 
    } 

    public IQueryProvider Provider 
    { 
    get { return session.Query<T>().Provider; } 
    } 

    public void Add(T entity) 
    { 
    session.Save(entity); 
    } 

    public T Get(Guid id) 
    { 
    return session.Get<T>(id); 
    } 

    IEnumerator IEnumerable.GetEnumerator() 
    { 
    return this.GetEnumerator(); 
    } 

    public IEnumerator<T> GetEnumerator() 
    { 
    return session.Query<T>().GetEnumerator(); 
    } 

    public void Remove(T entity) 
    { 
    session.Delete(entity); 
    } 
} 

Nie wdrożyć do SubmitChanges metody jak w samym repozytorium, ponieważ chcę, aby przedstawić zmiany kilku repozytoriów używanych przez jednego działania użytkownika na raz. I ukryć zarządzanie transakcjami w jednostce interfejsu pracy:

public interface IUnitOfWork : IDisposable 
{ 
    void Commit(); 
    void RollBack(); 
} 

używam sesji w określonej jednostce NHibernate realizacji prac jako sesji dla repozytoriów:

public interface INHiberanteUnitOfWork : IUnitOfWork 
{ 
    ISession Session { get; } 
} 

w rzeczywistej aplikacji, I użyj bardziej skomplikowanego interfejsu repozytorium z metodami takimi jak paginacja, szybkie ładowanie, wzorzec specyfikacji, dostęp do innych sposobów kwerend używanych przez NHiberante zamiast tylko linq. Implementacja linq w bagażniku NHibernate działa wystarczająco dobrze dla większości zapytań, które muszę wykonać.

Answer 2

Oto moje przemyślenia na temat repozytoriów generycznych:

Advantage of creating a generic repository vs. specific repository for each object?

mam z powodzeniem stosowane, że wzór z NHibernate i nie znalazłem żadnych realnych braków.

Istotą jest to, że prawdziwie ogólne repozytoria są nieco czerwonym śledziem, ale te same korzyści można osiągnąć, myśląc o problemie nieco inaczej.

Nadzieję, że pomaga.