en passant DB objet de Connexion à des méthodes

Personnellement, j'aime ranger une pile de ma connexion ouverte et les transactions sur le dessus de la Thread Local Storage à l'aide de SetData et GetData. Je définir une classe qui gère mes connexions à la base de données et de l'autoriser à utiliser le modèle dispose. Ce qui me sauve la nécessité de transmettre les connexions et les transactions autour de, ce qui est quelque chose que je pense encombre et complique le code.

Je vous recommande fortement de contre en laissant à l'méthodes pour ouvrir les connexions à chaque fois qu'ils ont besoin de données. Il conduit à une très mauvaise situation où il est difficile de gérer les transactions tout au long de l'application et de trop nombreuses connexions sont fermées et ouvertes (je sais que sur le regroupement de connexions, il est encore plus coûteux pour rechercher une connexion à partir de la piscine que c'est de réutiliser un objet)

Donc je finis par avoir quelque chose le long de ces lignes (totalement non testé):

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
}

Personnellement, je travaille pour centraliser mes données d'accès autant que possible, cependant, si pas possible, j'ai TOUJOURS ouvrir une nouvelle connexion dans les autres classes, car je trouve qu'il y a trop d'autres choses qui peuvent obtenir de la manière lors du passage de la connexion réelle de l'objet.

Vous pouvez passer des objets de connexion sans problème (par exemple, Microsoft Enterprise Library permet de statique des appels de méthode en lui passant une connexion) ou vous pourrait-il gérer en externe à votre design, il y a pas de technique directe de compromis.

Attention pour des raisons de portabilité, de ne pas passer d'une connexion spécifique si votre solution va être porté à d'autres bases de données (ce qui signifie ne pas passer une occurrence de SqlConnection il vous prévoyez de travailler avec d'autres bases de données)

Je voudrais vous suggérer de distinguer entre la connexion de l'objet et de son état (ouvert, fermé).

Vous pouvez avoir une seule méthode (ou des biens) qui lit la chaîne de connexion à partir du web.config. En utilisant la même version de la chaîne de connexion à chaque fois, vous garantit des prestations à partir d'une connexion de mise en commun.

Appeler cette méthode lorsque vous en avez besoin pour ouvrir une connexion. Au dernier moment, après la mise en place de tous les SqlCommand propriétés, ouvrez la connexion, l'utiliser, et puis fermez-le. En C#, vous pouvez utiliser l'instruction à l'aide à s'assurer que la connexion est fermée. Sinon, assurez-vous de fermer la connexion dans un bloc finally.