Persönlich mag ich einen Stapel meiner aktuellen offenen Verbindung und Transaktionen auf der Thread Local Storage mit SetData und GetData speichern.Ich definiere eine Klasse, die meine Verbindungen zur Datenbank verwaltet und es erlaubt, das Verfügungsmuster zu verwenden. Dies erspart mir die Notwendigkeit, Verbindungen und Transaktionen zu übergeben, was den Code verschleiert und verkompliziert.
Ich würde dringend empfehlen, gegen es den Methoden zu offen zu lassen Verbindungen jedes Mal, wenn sie Daten benötigen. Es wird zu einer wirklich schlechten Situation führen, in der es schwierig ist, Transaktionen in der gesamten Anwendung zu verwalten und zu viele Verbindungen zu öffnen und zu schließen (ich weiß über Verbindungs-Pooling, es ist immer noch teurer, eine Verbindung aus dem Pool nachzuschlagen, als sie ist) wiederzuverwenden ein Objekt)
ich am Ende also mit etwas in diese Richtung (total ungetestet):
class DatabaseContext : IDisposable {
List<DatabaseContext> currentContexts;
SqlConnection connection;
bool first = false;
DatabaseContext (List<DatabaseContext> contexts)
{
currentContexts = contexts;
if (contexts.Count == 0)
{
connection = new SqlConnection(); // fill in info
connection.Open();
first = true;
}
else
{
connection = contexts.First().connection;
}
contexts.Add(this);
}
static List<DatabaseContext> DatabaseContexts {
get
{
var contexts = CallContext.GetData("contexts") as List<DatabaseContext>;
if (contexts == null)
{
contexts = new List<DatabaseContext>();
CallContext.SetData("contexts", contexts);
}
return contexts;
}
}
public static DatabaseContext GetOpenConnection()
{
return new DatabaseContext(DatabaseContexts);
}
public SqlCommand CreateCommand(string sql)
{
var cmd = new SqlCommand(sql);
cmd.Connection = connection;
return cmd;
}
public void Dispose()
{
if (first)
{
connection.Close();
}
currentContexts.Remove(this);
}
}
void Test()
{
// connection is opened here
using (var ctx = DatabaseContext.GetOpenConnection())
{
using (var cmd = ctx.CreateCommand("select 1"))
{
cmd.ExecuteNonQuery();
}
Test2();
}
// closed after dispose
}
void Test2()
{
// reuse existing connection
using (var ctx = DatabaseContext.GetOpenConnection())
{
using (var cmd = ctx.CreateCommand("select 2"))
{
cmd.ExecuteNonQuery();
}
}
// leaves connection open
}
Wenn Sie Transaction verwenden, um eine Transaktion zwischen Methoden zu teilen, die unterschiedlichen Verbindungen verwenden, wird die Transaktion eine verteilte Transaktion mit der damit verbundene Overhead. Es ist also oft besser, eine Verbindung (und ihre Transaktion) zwischen Methoden zu übergeben, während der Umfang eng bleibt. – Joe
Das ist ein weiterer Grund, warum ich TLS für dieses Zeug verwende –
Dies ist die Art, wie wir es normalerweise tun, und die Art, wie ich es bevorzuge. – CSharpAtl