调用存储过程时需要Connection.Open（）吗？

Question

Normaly I would use either "Using" or just connection.open() and connection.close(). But when I'm calling stored procedure, this is not needed. How come? (Yes the codesnippit below works without using or open).

try {
    SqlCommand cmd = new SqlCommand("***", connectionSiteDb);
    DataTable dt = new DataTable();
    cmd.CommandType = CommandType.StoredProcedure;
    cmd.Parameters.Add(new SqlParameter("@ProcessSegmentID", ProcessSSegmentID));
    cmd.Parameters.Add(new SqlParameter("@PO_RecipeID", PO_RecipeID));
    cmd.Parameters.Add(new SqlParameter("@ProductSegmentVersion", ProductSegmentVersion));


    SqlDataAdapter da = new SqlDataAdapter();
    da.SelectCommand = cmd;
    da.Fill(dt);
    return dt;
}
catch (Exception e) {
     Console.WriteLine(e);
     return null;
}

Answer 1

Using using statement or not doesn't depends on your CommandType is Text or StoredProcedure .

SqlDataAdapter.Fill opens connection itself.

From Populating a DataSet from a DataAdapter

The Fill method implicitly opens the Connection that the DataAdapter is using if it finds that the connection is not already open. If Fill opened the connection, it will also close the connection when Fill is finished. This can simplify your code when dealing with a single operation such as a Fill or an Update.

Also DbDataAdapter.Fill(DataTable)

The connection object associated with the SELECT statement must be valid, but it does not need to be open . If the connection is closed before Fill is called, it is opened to retrieve data, then closed. If the connection is open before Fill is called, it remains open.

Since SqlDataAdapter doesn't implement IDisposable , you don't need to use using statement with it.

If you want to look under the hood, you can check QuietClose method and QuietOpen method implementations;

static private void QuietClose(IDbConnection connection, ConnectionState originalState)
{
      // close the connection if:
      // * it was closed on first use and adapter has opened it, AND
      // * provider's implementation did not ask to keep this connection open
      if ((null != connection) && (ConnectionState.Closed == originalState)) {
          // we don't have to check the current connection state because
          // it is supposed to be safe to call Close multiple times
          connection.Close();
      }
}

// QuietOpen needs to appear in the try {} finally { QuietClose } block
// otherwise a possibility exists that an exception may be thrown, i.e. ThreadAbortException
// where we would Open the connection and not close it
static private void QuietOpen(IDbConnection connection, out ConnectionState originalState)
{
     originalState = connection.State;
     if (ConnectionState.Closed == originalState) {
         connection.Open();
     }
}