J'essaie de déterminer si j'ai besoin d'une instruction using dans chacune de mes fonctions de référentiel pour m'assurer que la connexion se ferme après chaque lot d'appels de base de données . Par exemple: Je souhaite appeler connection.query ou connection.execute plusieurs fois à l'intérieur de certaines fonctions du référentiel. Si je n'utilise pas une instruction using, à quel moment ma connexion sera-t-elle fermée? L'objectif est de le rendre aussi efficace que possible pour le développement web.S'assurer qu'une connexion db SQL est toujours fermée après l'appel de chaque fonction repo
BaseRepository
public static string ConnectionString => @"Server=.;Database=applicationDb;User ID=sa;Password=Password12!";
protected SqlConnection _connection;
protected SqlConnection connection => _connection ?? (_connection = GetOpenConnection());
public static SqlConnection GetOpenConnection(bool mars = false)
{
var cs = ConnectionString;
if (mars)
{
var scsb = new SqlConnectionStringBuilder(cs)
{
MultipleActiveResultSets = true
};
cs = scsb.ConnectionString;
}
var connection = new SqlConnection(cs);
connection.Open();
return connection;
}
public SqlConnection GetClosedConnection()
{
var conn = new SqlConnection(ConnectionString);
if (conn.State != ConnectionState.Closed) throw new InvalidOperationException("should be closed!");
return conn;
}
public void Dispose()
{
_connection?.Dispose();
}
CustomerRepository: Avec la configuration BaseRepository BaseRepository
la façon dont il est. Est-il une différence entre ce qui suit:
public IEnumerable<Customer> GetCustomers()
{
using (connection)
{
StringBuilder sql = new StringBuilder();
sql.AppendLine("SELECT Id, Name, Email ");
sql.AppendLine("FROM Customer;");
StringBuilder deleteSql = new StringBuilder();
deleteSql = new StringBuilder();
deleteSql.AppendLine("DELETE FROM Xyz ");
deleteSql.AppendLine("FROM CustomerId = @CustomerId;");
connection.Execute(deleteSql.ToString(), new { CustomerId = 5 });
return connection.Query<Customer>(sql.ToString()).ToList();
}
}
ou sans l'aide de:
public IEnumerable<Customer> GetCustomers()
{
StringBuilder sql = new StringBuilder();
sql.AppendLine("SELECT Id, Name, Email ");
sql.AppendLine("FROM Customer;");
StringBuilder deleteSql = new StringBuilder();
deleteSql = new StringBuilder();
deleteSql.AppendLine("DELETE FROM Xyz ");
deleteSql.AppendLine("FROM CustomerId = @CustomerId;");
connection.Execute(deleteSql.ToString(), new { CustomerId = 5 });
return connection.Query<Customer>(sql.ToString()).ToList();
}
C'est exactement ce que j'essayais de comprendre. Donc, avec la configuration de BaseRepository comme si je n'avais pas d'instruction using par fonction, la connexion ne se fermerait jamais correctement? Je pensais que ce n'est peut-être pas une mauvaise chose, pourquoi ne pas garder la même connexion pendant longtemps si le BaseRepository vérifie toujours si une connexion existe déjà l'utilise, sinon en ouvrir un autre. –
Vous n'avez pas besoin de vous soucier d'ouvrir et de fermer la connexion aussi souvent que vous le souhaitez. Vous êtes en fait encouragé à fermer la connexion immédiatement après avoir terminé. Cela ne va pas vraiment fermer la connexion. Il va juste le retourner au pool de connexions, et la prochaine fois que vous essayerez d'ouvrir une nouvelle connexion (dans un court laps de temps), vous recevrez une connexion du pool. –