Vérifiez si la connexion SQL est ouverte ou fermée

Comment vérifier s'il est ouvert ou fermé que j'utilisais

 if (SQLOperator.SQLCONNECTION.State.Equals("Open"))

cependant, même l'état est «ouvert», il échoue à cette vérification.

Vous devriez utiliser SqlConnection.State

par exemple,

using System.Data;

if (myConnection != null && myConnection.State == ConnectionState.Closed)
{
   // do something
   // ...
}

Voici ce que j'utilise:

if (mySQLConnection.State != ConnectionState.Open)
{
    mySQLConnection.Close();
    mySQLConnection.Open();
}

La raison pour laquelle je n'utilise pas simplement:

if (mySQLConnection.State == ConnectionState.Closed)
{
    mySQLConnection.Open();
}

C'est parce que le ConnectionState peut également être:

Broken, Connnecting, Executing, Fetching

En plus de

Open, Closed

En outre, Microsoft déclare que la fermeture et la réouverture de la connexion «actualiseront la valeur de State». Voir ici http://msdn.microsoft.com/en-us/library/system.data.sqlclient.sqlconnection.state(v=vs.110).aspx

La documentation .NET dit: State Property: Une combinaison au niveau du bit des valeurs ConnectionState

Alors je pense que tu devrais vérifier

!myConnection.State.HasFlag(ConnectionState.Open)

au lieu de

myConnection.State != ConnectionState.Open

car State peut avoir plusieurs indicateurs.

Vérifiez si une connexion MySQL est ouverte

ConnectionState state = connection.State;
if (state == ConnectionState.Open)
{
    return true;
}
else
{
    connection.Open();
    return true;
}

vous pouvez également utiliser ceci

if (SQLCON.State == ConnectionState.Closed)
{
     SQLCON.Open();
}

Ce code est un peu plus défensif, avant d'ouvrir une connexion, vérifiez l'état. Si l'état de la connexion est Broken, nous devons essayer de le fermer. Rupture signifie que la connexion a été précédemment ouverte et ne fonctionne pas correctement. La deuxième condition détermine que l'état de connexion doit être fermé avant de tenter de l'ouvrir à nouveau afin que le code puisse être appelé à plusieurs reprises.

// Defensive database opening logic.

if (_databaseConnection.State == ConnectionState.Broken) {
    _databaseConnection.Close();
}

if (_databaseConnection.State == ConnectionState.Closed) {
    _databaseConnection.Open();
}

Pour vérifier l'état de la connexion à la base de données, vous pouvez simplement faire ce qui suit

if(con.State == ConnectionState.Open){}

Pour vérifier l'état OleDbConnection, utilisez ceci:

if (oconn.State == ConnectionState.Open)
{
    oconn.Close();
}

State retourner le ConnectionState

public override ConnectionState State { get; }

Voici les autres ConnectionStateénumérations

public enum ConnectionState
    {
        //
        // Summary:
        //     The connection is closed.
        Closed = 0,
        //
        // Summary:
        //     The connection is open.
        Open = 1,
        //
        // Summary:
        //     The connection object is connecting to the data source. (This value is reserved
        //     for future versions of the product.)
        Connecting = 2,
        //
        // Summary:
        //     The connection object is executing a command. (This value is reserved for future
        //     versions of the product.)
        Executing = 4,
        //
        // Summary:
        //     The connection object is retrieving data. (This value is reserved for future
        //     versions of the product.)
        Fetching = 8,
        //
        // Summary:
        //     The connection to the data source is broken. This can occur only after the connection
        //     has been opened. A connection in this state may be closed and then re-opened.
        //     (This value is reserved for future versions of the product.)
        Broken = 16
    }

J'utilise la manière suivante sqlconnection.state

if(conexion.state != connectionState.open())
   conexion.open();