Sintaxe:
A instrução C# “using” é usada para gerenciar os recursos que precisam ser explicitamente descartados de maneira conveniente e segura. Segue uma sintaxe específica como segue:
usando ( Recurso ResourceType = novo tipo de recurso ( ) ) { // Código }- A palavra-chave “using” é usada para declarar a instrução “using”.
- Após a palavra-chave “using”, você especifica o tipo de recurso com o qual deseja trabalhar, seguido por um nome de variável que representa o recurso dentro do bloco. Qualquer objeto que execute a interface IDisposable se qualifica. Você pode operar no recurso dentro do bloco conforme necessário.
- A seguir, um sinal de igual (=) é usado para atribuir uma nova instância do tipo de recurso à variável.
- Aqui, a palavra-chave “new” é utilizada para gerar um novo objeto do tipo de recurso.
- Qualquer inicialização ou configuração adicional pode ser executada entre parênteses após a nova palavra-chave.
- Por fim, coloque o código que usa o recurso entre chaves {}.
Exemplo 1:
Vamos começar com os exemplos de código C# para demonstrar a utilização da instrução “using” do C# neste artigo. O código fornecido cobre um programa C# que lê o conteúdo de um arquivo de texto usando a classe “StreamReader” dentro de uma instrução “using”.
O programa começa importando os namespaces necessários, System e System.IO, que fornecem classes para operações de entrada/saída e manipulação de arquivos. O programa define uma classe chamada “Dummy”. Dentro da classe “Dummy”, existe um método Main() que sempre deve ser tratado como a entrada para qualquer programa C# para executar o programa geral do início ao fim.
O método Main() começa declarando a variável string “fp” e atribuindo a ela o valor “test.txt”. Isso representa o caminho do arquivo de texto a ser lido. Para lidar com todos os possíveis erros que possam surgir durante a leitura de arquivos, um bloco try-catch é utilizado.
Dentro do bloco try, uma instrução “using” é usada para criar uma instância da classe “StreamReader”. A tarefa de compreender o conteúdo de um arquivo cabe ao “StreamReader”. O caminho do arquivo que está armazenado na variável “fp” é passado para o construtor “StreamReader” indica o arquivo a ser lido.
Dentro do bloco “using”, o conteúdo do arquivo é examinado linha por linha usando um loop “while”, a menos que a linha final do documento apareça. O loop lê uma linha usando o método ReadLine() do “StreamReader” e a atribui à variável string “l”. Se a linha não for nula, ela será impressa no console usando Console.WriteLine(l).
Quando o final do arquivo é atingido e não há mais linhas para ler, o bloco “using” é encerrado e o objeto “StreamReader” é automaticamente descartado devido à instrução “using”. O bloco catch é ativado sempre que surge uma IOException durante a leitura de um documento. A mensagem de exceção é obtida usando e.Message, e uma mensagem de erro é exibida no console usando Console.WriteLine().
A execução do programa é concluída e a saída do console é exibida. Supondo que o arquivo “test.txt” exista e contenha várias linhas de texto, a saída deste código é o conteúdo do arquivo que é impresso no console conforme exibido na imagem anexada a seguir. Cada linha é mostrada separadamente na saída:
usando o sistema ;usando Sistema. OI ;
manequim de classe {
estático vazio Principal ( ) {
string fp = 'teste.txt' ;
tentar {
usando ( Leitor StreamReader = novo StreamReader ( FP ) )
{
corda eu ;
enquanto ( ( eu = leitor. Leia a linha ( ) ) != nulo )
{
Console. WriteLine ( eu ) ;
}
}
}
pegar ( IOException e ) {
Console. WriteLine ( 'Ocorreu um erro:' + e. Mensagem ) ;
}
}
}
Observação: Se o arquivo “test.txt” não existir ou houver um problema de acesso ou leitura do arquivo, o bloco catch será executado e uma mensagem de erro será exibida no console indicando a exceção específica que ocorreu.
Exemplo 2:
Aqui está outro exemplo simples que demonstra o uso da instrução C# “using” com um StreamWriter para gravar os dados em um arquivo. Aqui está uma explicação do código junto com sua saída esperada. O código começa com a declaração da classe “Dummy” e do método “Main” que eventualmente iniciará e encerrará o programa.
Dentro do método “Main”, a variável string “fp” é declarada e inicializada com o caminho do arquivo “test.txt”. O documento no qual as informações estão escritas é representado por este. Para lidar com qualquer possível IOException que possa surgir durante o processo de escrita do documento, o programa é incluído em um bloco try-catch.
Dentro do bloco try, um objeto StreamWriter chamado “writer” é criado e inicializado usando a instrução “using”. O StreamWriter é responsável por escrever caracteres em um arquivo. Duas linhas separadas de conteúdo são adicionadas a um documento dentro da seção “usando” por meio da função WriteLine do objeto escritor. Assim que o bloco é encerrado, o método Dispose() do StreamWriter é chamado automaticamente, o que garante que todos os dados pendentes sejam gravados no arquivo e os recursos necessários sejam liberados.
Finalmente, fora do bloco “using”, o “Dados gravados com sucesso”. uma mensagem é mostrada no console, demonstrando que a operação de gravação do documento foi bem-sucedida e sem erros. O bloco catch é ativado se alguma IOException acontecer durante o processo de gravação do documento. Nesse caso, uma mensagem de erro junto com a mensagem de exceção específica será exibida no console.
usando o sistema ;usando Sistema. OI ;
manequim de classe {
estático vazio Principal ( ) {
string fp = 'teste.txt' ;
tentar {
usando ( Escritor StreamWriter = novo StreamWriter ( FP ) )
{
escritor. WriteLine ( 'Olá, Dó sustenido!' ) ;
escritor. WriteLine ( 'Este é um texto de teste.' ) ;
}
Console. WriteLine ( 'Dados gravados com sucesso.' ) ;
}
pegar ( IOException e ) {
Console. WriteLine ( 'Ocorreu um erro: ' + e. Mensagem ) ;
}
}
}
Em resumo, o código cria um objeto StreamWriter usando a instrução “using”, grava duas linhas de texto em um arquivo e, em seguida, descarta automaticamente o StreamWriter. Se a operação de gravação for bem-sucedida, o software gera uma mensagem de sucesso. Caso contrário, ele emitirá uma mensagem de falha se ocorrer alguma IOException.
Conclusão
A instrução “using” do C# oferece um método prático e seguro de gerenciar os recursos que requerem um descarte explícito. Você pode garantir que os procedimentos de limpeza necessários sejam executados automaticamente e reduzir a probabilidade de vazamentos de recursos, colocando o consumo de recursos dentro de um bloco “usando”. Isso aumenta a confiabilidade do seu código.