SqlConnection.Close () à l'intérieur de l'instruction

Je suis en utilisant ce code:

    public void InsertMember(Member member)
    {
        string INSERT = "INSERT INTO Members (Name, Surname, EntryDate) VALUES (@Name, @Surname, @EntryDate)";

        using (sqlConnection = new SqlConnection(sqlConnectionString_WORK))
        {
            sqlConnection.Open();

            using (SqlCommand sqlCommand = new SqlCommand(INSERT, sqlConnection))
            {
                sqlCommand.Parameters.Add("@Name", SqlDbType.VarChar).Value = member.Name;
                sqlCommand.Parameters.Add("@Surname", SqlDbType.VarChar).Value = member.Surname;
                sqlCommand.Parameters.Add("@EntryDate", SqlDbType.Date).Value = member.EntryDate;

                sqlCommand.ExecuteNonQuery();
            }
        }
    }

Est-ce un problème si je ne suis pas d'ajouter sqlConnection.Close(); avant de les jeter? Je veux dire. Ce n'est pas en montrant des erreurs, pas de problèmes à tous. Est-il mieux de la Fermer en premier? Si oui, pourquoi?

source d'informationauteur Etrit

.net c#database sql using

Pas besoin de Close or Dispose la using bloc de prendre soin de cela pour vous.

Comme indiqué à partir de MSDN:

L'exemple suivant crée une occurrence de SqlConnection, l'ouvre, affiche
de ses propriétés. La connexion est automatiquement fermée à la fin
de l'utilisation de bloc.

private static void OpenSqlConnection(string connectionString) 
{
    using (SqlConnection connection = new SqlConnection(connectionString))
    {
        connection.Open();
        Console.WriteLine("ServerVersion: {0}", connection.ServerVersion);
        Console.WriteLine("State: {0}", connection.State);
    } 
}

4

La using statement ensures that Dispose is called même si une exception se produit lors de l'appel de méthodes sur l'objet. You can achieve the same result by putting the object inside a try block and then calling Dispose in a finally block; en fait, c'est la façon dont l'instruction à l'aide est traduit par le compilateur. MSDN

Si, finalement, votre ligne de code
```
  using (sqlConnection = new SqlConnection(sqlConnectionString_WORK))
```
sera converti en un normal try finally block par le compilateur appel IDisposable object in the finally
3

L'instruction à l'aide est d'essayer enfin de bloc et dans votre cas, le bloc final aurait un connection.Dispose() appel. Si vous n'avez pas vraiment besoin d'un indépendant connection.Close() déclaration.

L'avantage est que cela garantit l'élimination, même dans le cas d'une exception, puisque le bloc finally est toujours exécuté.
```
try
{
sqlConnection.Open();
//....
}
finally
{
if(sqlConnection != null)
      sqlConnection.Dispose();
}
```
2

Est-ce un problème si je ne suis pas d'ajouter sqlConnection.Close(); avant de le disposer

Non, il n'est pas aussi longtemps que vous êtes à l'aide de votre liaison au sein de Using. Lorsque vous quitterez l'aide de portée, Dispose sera appelé pour la connexion sql. qui fermer la connexion existanteet libérer toutes les ressources.
2

Non, il n'est pas faux. L'occurrence de sqlConnection va fermer la connexion après il va passer à l'aide de bloc et d'appeler la méthode dispose. SqlConnection.Dispose() égal à SqlConnection.La méthode Close ().

À partir de MSDN: Si SqlConnection est hors de portée, il ne sera pas fermé. Par conséquent, vous devez fermer explicitement la connexion en appelant à Proximité ou en Disposer. Fermer et d'en Disposer sont fonctionnellement équivalents.
2

Selon La documentation MSDN pour le Fermer méthode:

vous devez fermer explicitement la connexion en appelant Près ou Disposer. Près et Disposer sont fonctionnellement équivalents.

Par conséquent, l'appel Dispose (implicitement donc, même, à l'aide de using) permettra de couvrir vos bases, comme elle l'avait fait.

Il est intéressant de noter, aussi, je pense,bien que non spécifiques à votre cas, que Close sera toujours effectivement être appelé lorsque la chose est enveloppé dans un using déclaration - qui pourrait pas être le cas, devrait-il être omise, et une exception se produire sans la bonne try/catch/finally de manutention.
1

Vous utilisez un Using qui Dispose() l'objet pour vous.

Si vous prenez la connexion à l'extérieur de la Using déclaration, alors oui - vous devez fermer la connexion lorsque vous avez terminé.
0

C'est la question très intéressante et pas si évident que beaucoup peuvent penser. À l'aide de la déclaration de travailler correctement pour la connexion que si tous les objets qui utilise la connexion sera éliminé. Il y a quelques temps nous avons eu un problème avec les connexions ouvertes dans notre sql server. Tout semblait bien parce que les connexions étaient à l'intérieur à l'aide de relevés, mais l'un des développeurs ont créé quelques méthodes avec SqlDataReader et n'a pas fermé correctement. En raison du fait que les connexions n'ont pas été publiés.

La raison de cela est la façon dont les ordures collecton œuvres. Longue histoire courte, il crée une carte des objets de disposer et de réellement se débarrasser d'eux quand il n'y a pas d'actif de références à ces objets.

Vous devez vous connecter pour publier un commentaire.