c# - reglas - uso de la c

usando varios tipos en una declaración de uso(C#)

Question

Ya que la declaración de C # es solo un azúcar sintáctico para try / finally {dispose} ¿por qué acepta múltiples objetos SOLO SI SON DEL MISMO TIPO?

No lo entiendo ya que todo lo que necesitan ser es IDisposable. Si todos ellos implementan IDisposable debería estar bien, pero no lo está.

Específicamente estoy acostumbrado a escribir

using (var cmd = new SqlCommand())
{
    using (cmd.Connection)
    {
        // code
    }
}

que compacto en:

using (var cmd = new SqlCommand())
using (cmd.Connection)
{
    // code
}

y me gustaría compactar además en:

using(var cmd = new SqlCommand(), var con = cmd.Connection)
{
    // code
}

pero no puedo Probablemente podría, algunos dirían, escribir:

using((var cmd = new SqlCommand()).Connection)
{
    // code
}

ya que todo lo que necesito para disponer es la conexión y no el comando, pero eso no es el punto.

Answer 1

Mi forma personal de usar esto podría encajar en la cuenta:

private const string SQL_CONNECTION = "Your Connection String Here";

private void Test(string sqlCmd)
{
  using (var cmd = new SqlCommand(sqlCmd, new SqlConnection(SQL_CONNECTION)))
  {
    cmd.Connection.Open();
    cmd.ExecuteNonQuery();
    cmd.Connection.Close();
    // Close() is not really necessary.
    // Dispose will Close the connection.
  }
}

No, no se trata de dos instancias de la cláusula de using en una línea, pero es tan compacta como está tratando de obtener en su ejemplo.

Además, puede hacer que esto sea aún más compacto y amigable para el programador al convertir su cadena de conexión en una propiedad privada:

private SqlConnection OpenConnection
{
  get {
    var con = new SqlConnection(SQL_CONNECTION);
    con.Open();
    return con;
  }
}

Ahora, ese primer bit de código anterior en Test() podría reducirse a lo siguiente:

private void Test2(string sqlCmd)
{
  using (var cmd = new SqlCommand(sqlCmd, OpenConnection))
  {
    cmd.ExecuteNonQuery();
  }
}

Eso hace que la codificación sea muy agradable.

Answer 2

No hay una razón técnica particularmente buena; podríamos haber creado una sintaxis que permitiera múltiples declaraciones de tipos no homogéneos. Dado que no lo hicimos, y ya existe un mecanismo perfectamente bueno, claro, comprensible y bastante conciso para declarar anidados mediante el uso de bloques de diferentes tipos, es poco probable que agreguemos un nuevo azúcar sintáctico solo para ahorrar algunas pulsaciones de teclas.

Answer 3

Otras declaraciones de variables en C # solo le permiten declarar múltiples variables del mismo tipo en la misma declaración; No veo por qué using encabezados debería ser diferente.

Answer 4

Puedes hacer esto sin embargo:

using (IDisposable cmd = new SqlCommand(), con = (cmd as SqlCommand).Connection)
{
   var command = (cmd as SqlCommand);
   var connection = (con as SqlConnection);
   //code
}

Tal vez eso sería satisfactorio para usted.