Ich frage mich, wie viel sollte mein Service Layer über mein Repository wissen? In vergangenen Projekten habe ich immer Listen zurückgegeben und hatte eine Methode für jede Sache, die ich brauchte.
Wenn ich also alle Zeilen zurückgeben müsste, die eine Id von 5 haben, wäre das eine Methode. Ich habe ein allgemeines Repository für das Erstellen, Aktualisieren, Löschen und andere NHibernate-Optionen, aber für die Abfrage nicht.
Jetzt fange ich an, mehr IQueryable zu verwenden, da ich anfing, Probleme mit so vielen Methoden für jeden Fall zu haben.
Wenn ich z. B. alle Daten mit einer bestimmten Kennung zurückgeben müsste und 3 Tabellen bräuchte, die eifrig geladen wurden, wäre dies eine neue Methode. Wenn ich eine bestimmte Id und kein Eager Loading benötigte, wäre das eine eigene Methode.
So jetzt ich denke, wenn ich Methode, die die Where-Klausel Teil tut und IQueryable zurückgeben, dann kann ich auf das Ergebnis hinzufügen (d.h. wenn ich eager Laden tun müssen).
Gleichzeitig wird dadurch aber auch die Service-Schicht stärker auf die Repository-Schicht aufmerksam und ich kann das Repository nicht mehr so einfach auswechseln, da ich jetzt spezifisches NHibernate in der Service-Schicht habe.
Ich bin mir auch nicht sicher, wie sich das auf den Spott auswirken würde.
Daher frage ich mich jetzt, ob das Repository benötigt wird, wenn ich diesen Weg einschlage, da es jetzt so aussieht, als ob sie miteinander vermischt worden sind.
bearbeiten
Wenn ich mein Repository loswerde und nur die Sitzung in meiner Serviceschicht habe, gibt es dann einen Sinn, eine Unit of Work-Klasse zu haben?
public class UnitOfWork : IUnitOfWork, IDisposable
{
private ITransaction transaction;
private readonly ISession session;
public UnitOfWork(ISession session)
{
this.session = session;
session.FlushMode = FlushMode.Auto;
}
/// <summary>
/// Starts a transaction with the database. Uses IsolationLevel.ReadCommitted
/// </summary>
public void BeginTransaction()
{
transaction = session.BeginTransaction(IsolationLevel.ReadCommitted);
}
/// <summary>
/// starts a transaction with the database.
/// </summary>
/// <param name="level">IsolationLevel the transaction should run in.</param>
public void BeginTransaction(IsolationLevel level)
{
transaction = session.BeginTransaction(level);
}
private bool IsTransactionActive()
{
return transaction.IsActive;
}
/// <summary>
/// Commits the transaction and writes to the database.
/// </summary>
public void Commit()
{
// make sure a transaction was started before we try to commit.
if (!IsTransactionActive())
{
throw new InvalidOperationException("Oops! We don't have an active transaction. Did a rollback occur before this commit was triggered: "
+ transaction.WasRolledBack + " did a commit happen before this commit: " + transaction.WasCommitted);
}
transaction.Commit();
}
/// <summary>
/// Rollback any writes to the databases.
/// </summary>
public void Rollback()
{
if (IsTransactionActive())
{
transaction.Rollback();
}
}
public void Dispose() // don't know where to call this to see if it will solve my problem
{
if (session.IsOpen)
{
session.Close();
}
}
