usando vários tipos em uma instrução using (C #)

Question

Uma vez que o C # usando instrução é apenas um açúcar sintático para try / finally {} dispor por que aceitar vários objetos se forem DO MESMO TIPO?

Eu não entendo uma vez que todos eles precisam ser é IDisposable. Se todos eles implementar IDisposable ele deve estar bem, mas não é.

Especificamente estou habituado a escrita

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

que eu compactar em:

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

e eu gostaria de compactar ainda em:

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

mas não posso. Eu poderia provavelmente, alguns diriam, escreve:

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

desde tudo o que precisa descartar é a conexão e não o comando, mas isso é além do ponto.

Answer 1

Você pode fazer isso, porém:

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

Talvez que seria satisfatório para você.

Answer 2

Não há nenhuma razão particularmente boa técnica; que poderia ter vindo acima com uma sintaxe que permitiu várias declarações de tipos não homogéneas. Dado que nós não o fez, e já existe um perfeitamente boa, clara, compreensível e bastante concisa mecanismo para declarar usando blocos aninhados de diferentes tipos, que é improvável que adicionar um novo açúcar sintático apenas para salvar algumas teclas.

Answer 3

Outras declarações de variáveis ??em C # só permitem que você declarar múltiplas variáveis ??do mesmo tipo na mesma declaração; Eu não vejo por que cabeçalhos using deve ser diferente.

Answer 4

A minha maneira pessoal de usar este pode caber a conta:

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.
  }
}

Não, isso não é duas instâncias da cláusula using em uma linha, mas é tão compacto quanto você está tentando entrar em seu exemplo.

O que é mais, você pode fazer isso ainda mais compacto e programador amigável, transformando sua cadeia de conexão em uma propriedade privada:

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

Agora, esse primeiro pedaço de código acima em Test() poderia ser reduzido para o seguinte:

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

que faz a codificação muito agradável.