c# - uso - tipos de variables en c++ y su significado

¿Qué hace una declaración de uso sin variable cuando se dispone?

Question

Siempre lo he usado usando con variable y asignación. Ahora tengo así una clase DbProviderConnection:

public class DbProviderConnection : IDisposable
{
    public DbConnection Connection { get; set; }
    public DbTransaction Transaction { get; set; }

    public DbTransaction BeginTransaction()
    {
        Transaction = Connection.BeginTransaction();
        return Transaction;
    } 

    //... and so on
}

Ahora estaba pensando en usarlo así:

using (DbProviderConnection cnctn = _planDb.CreateOpenConnection())
{
    using (cnctn.BeginTransaction())
    {
        //...
        cnctn.Transaction.Commit();
    }
}

Mi pregunta es: ¿ DbProviderConnection.Transaction.Dispose llama DbProviderConnection.Transaction.Dispose ?

Answer 1

De la especificación 8.13 de C # que usa la declaración definida como

using-statement:
   using (resource-acquisition) embedded-statement

Donde la adquisición de recursos es

resource-acquisition:
    local-variable-declaration
    expression

En el primer caso tiene que usar el recurso que adquiere a través de la declaración de variable local. En segundo caso el recurso se adquiere a través de la expresión. Por lo tanto, en segundo caso, el resultado será el resultado de la llamada cnctn.BeginTransaction() , que es DbTransaction de su clase DbProviderConnection . El uso de la declaración dispone su recurso después del uso. Entonces, sí, se DbProviderConnection.Transaction.Dispose() .

ACTUALIZACIÓN: De acuerdo con el mismo artículo, su segundo bloque de uso se traducirá a

DbTransaction resource = cnctn.BeginTransaction();
try
{
    //...
    cnctn.Transaction.Commit();
}
finally 
{
   if (resource != null) 
      ((IDisposable)resource).Dispose();
}

Answer 2

De la especificación:

8.13 La declaración de uso

Una declaración usando el formulario.

using (ResourceType resource = expression) statement

cuando ResourceType es un tipo de valor anulable o un tipo de referencia que no sea dinámico, la expansión es

{
    ResourceType resource = expression;
    try {
        statement;
    }
    finally {
        if (resource != null) ((IDisposable)resource).Dispose();
    }
}

Una declaración usando el formulario.

using (expression) statement

tiene las mismas tres posibles expansiones ... La variable de recurso es inaccesible e invisible para la declaración incrustada.

Por lo tanto, el objeto devuelto desde cnctn.BeginTransaction() se eliminará cuando el bloque salga, pero no será accesible dentro del bloque asociado.

Answer 3

El objeto que devuelve BeginTransaction es lo que se eliminará.

BeginTransaction devuelve un DbTransaction modo que es lo que se eliminará

Answer 4

Sí, la disposición se llamará. La declaración de using solo funciona con objetos desechables. Me gusta esto:

using (DbProviderConnection cnctn = _planDb.CreateOpenConnection())
{
    using (cnctn.BeginTransaction())
    {
        // ...
        cnctn.Transaction.Commit();
    } // Here BeginTransaction.Dispose() is called.
} // Here DbProviderConnection.Dispose() is called.