Usando a instrução using em C # [duplicado]

Question

Duplicate possíveis:
Qual é o C # Usando bloco e por quê devo usá-lo?

Eu vi a instrução usando usado no meio de um bloco de código que é a razão para isso?

Answer 1

O usando sintaxe pode (deve) ser usado como uma maneira de definir um escopo para qualquer coisa que implementa IDisposable . A instrução using garante que Dispose é chamado, se ocorrer uma exceção.

    //the compiler will create a local variable 
    //which will go out of scope outside this context 
    using (FileStream fs = new FileStream(file, FileMode.Open))
    {
         //do stuff
    }

Como alternativa, você pode simplesmente usar:

    FileStream fs;
    try{
       fs = new FileStream();
       //do Stuff
    }
    finally{
        if(fs!=null)
           fs.Dispose();
    }

leitura extra do MSDN

C #, através do Common Language Runtime .NET Framework (CLR), automaticamente libera a memória usada para armazenar objetos que não são mais necessários. A liberação de memória é não-determinístico; memória é liberada sempre que o CLR decide realizar a coleta de lixo. No entanto, geralmente é melhor para liberar recursos limitados, tais como identificadores de arquivo e conexões de rede o mais rápido possível.

A instrução using permite que o programador para especificar quando objetos que usam recursos devem liberá-los. O objeto fornecido para a instrução using deve implementar a interface IDisposable. Essa interface fornece o método Dispose, que deve liberar recursos do objeto.

Answer 2

É frequentemente utilizado ao abrir uma conexão com um riacho ou um banco de dados.

Ele se comporta como um try {...} finally {...} bloco. Depois que o usando bloco, o objeto IDisposable que foi instanciado no parêntese será fechado corretamente.

using (Stream stream = new Stream(...))
{


}

Com este exemplo, o fluxo está devidamente fechada após o bloco.

Answer 3

usando é tentar suger finalmente sintático para qualquer coisa que tenha um IDisposable .. como um sqlconnection. Seu uso que certificar-se de algo que é descartado após o seu fora do escopo using(){}.

using(SqlConnection conn = new SqlConnection(connString))
{
  //use connection
}

//shorter than

SqlConnection conn = new SqlConnection(connString)
try
{
  //use connection 
}
finally
{
    conn.Dispose();
}

Answer 4

A instrução using garante um objeto é descartado corretamente uma vez que é nolonger necessário. Basicamente, você economiza escrever obj.Dispose (); e dá um guia visual sobre o alcance e uso de uma variável.

página MSDN para mais informações

Answer 5

Esta forma de usar tem a ver com recursos libertando. Ela só pode ser usado em combinação com classe que implementa a interface IDisposable.

exemplo:

using(SqlConnection conn = new SqlConnection(someConnectionString))
{
     //Do some database stuff here
}

no final do usando conn.Dispose bloco é chamado, mesmo se uma exceção foi jogado dentro do bloco. No caso de um meio SwqlConnection objeto que a conexão está sempre fechada.

A desvantagem desta construção é que agora há maneira de saber o que aconteceu.

Espero que isso ajude responder a sua pergunta?

Answer 6

Sempre que o código cria um objeto que implementa IDisposable, seu código deve fazer a criação dentro de um bloco usando, como visto acima.

Há uma exceção a esta regra. Um erro na concepção do WCF classes de proxy impede que utilizam declarações de ser útil para classes de proxy. Resumidamente, o método Dispose em uma classe de proxy pode lançar uma exceção. A equipe WCF não viu nenhuma razão para não permitir isso.

Infelizmente, não ver uma razão não significa que há é nenhum motivo:

try
{
    using (var svc = new ServiceReference.ServiceName())
    {
        throw new Exception("Testing");
    }
}
catch (Exception ex)
{
    // What exception is caught here?
}

Se a chamada Descarte implícita lança uma exceção, então o bloco catch vai pegar que exceção ao invés do jogado dentro do usando bloco.