Mesmo que você esteja apenas começando a se familiarizar com C#, provavelmente já se deparou com a diretiva using. E se você é um usuário do IronPDF, estará muito familiarizado em iniciar seu código com o namespace using ironpdf.
No entanto, existe outro uso para a palavra-chave "using". Neste guia, vamos analisar a instrução using: o que é, como funciona e como pode ajudar você a criar um código mais eficiente. Vamos começar!
A instrução using em C# é uma maneira conveniente de trabalhar com recursos que implementam a interface IDisposable. Os objetos IDisposable normalmente retêm recursos não gerenciados, como identificadores de arquivos ou conexões de rede, que precisam ser liberados quando você terminar de usá-los. É aqui que entra em ação a declaração using - ela ajuda a garantir que esses recursos sejam descartados adequadamente após o uso.
usingAo usar a instrução using, o C# chamará automaticamente o método Dispose do objeto quando ele não for mais necessário. Isso significa que você não precisa chamar o método Dispose manualmente nem se preocupar em esquecer de fazê-lo. A instrução using cuida disso para você!
Vejamos um exemplo simples para entender como a instrução using funciona na prática:
using System;
using System.IO;
class Program
{
static void Main()
{
// Using a using statement to ensure StreamReader is disposed of
using (StreamReader reader = new StreamReader("example.txt"))
{
string content = reader.ReadToEnd();
Console.WriteLine(content);
}
}
}Imports System
Imports System.IO
Friend Class Program
Shared Sub Main()
' Using a using statement to ensure StreamReader is disposed of
Using reader As New StreamReader("example.txt")
Dim content As String = reader.ReadToEnd()
Console.WriteLine(content)
End Using
End Sub
End ClassNeste exemplo, o objeto StreamReader chamado reader está envolvido em um bloco using. Ao sair do bloco using, o método Dispose é chamado automaticamente no leitor, liberando quaisquer recursos que ele estivesse utilizando.
A partir do C# 8.0, você pode usar a declaração using em vez do bloco using. A declaração using é uma maneira mais curta e concisa de definir um objeto descartável, como segue:
using System;
using System.IO;
class Program
{
static void Main()
{
// Using the using declaration simplifies the code
using var reader = new StreamReader("example.txt");
string content = reader.ReadToEnd();
Console.WriteLine(content);
}
}Imports System
Imports System.IO
Friend Class Program
Shared Sub Main()
' Using the using declaration simplifies the code
Dim reader = New StreamReader("example.txt")
Dim content As String = reader.ReadToEnd()
Console.WriteLine(content)
End Sub
End ClassCom a declaração using, você não precisa de chaves nem de recuo, tornando seu código mais legível. O método Dispose ainda é chamado automaticamente quando a variável sai do escopo.
try, finally e using.Você pode estar se perguntando como a instrução using se relaciona com os blocos try e finally em C#. Bem, a instrução using é, na verdade, uma abreviação para um bloco try-finally!
Aqui está o mesmo exemplo de antes, mas escrito usando um bloco try-finally em vez de uma instrução using:
using System;
using System.IO;
class Program
{
static void Main()
{
StreamReader reader = null;
try
{
reader = new StreamReader("example.txt");
string content = reader.ReadToEnd();
Console.WriteLine(content);
}
finally\static-assets\pdf\blog\csharp-using\csharp-using-2.webp
{
if (reader != null)
{
reader.Dispose();
}
}
}
}Imports System
Imports System.IO
Friend Class Program
Shared Sub Main()
Dim reader As StreamReader = Nothing
Try
reader = New StreamReader("example.txt")
Dim content As String = reader.ReadToEnd()
Console.WriteLine(content)
Finally
\static-assets\pdf\blog\csharp-using\csharp-using-2.webp
If reader IsNot Nothing Then
reader.Dispose()
End If
End Try
End Sub
End ClassComo você pode ver, a instrução using torna o código mais limpo e fácil de ler, eliminando a necessidade do bloco try-finally e a chamada explícita ao método Dispose.
Uma das grandes vantagens da instrução using é que ela pode lidar com vários recursos ao mesmo tempo. Você pode empilhar instruções using uma após a outra ou usar uma única instrução using para lidar com vários recursos em uma lista separada por vírgulas. Aqui está um exemplo que demonstra ambas as abordagens:
using System;
using System.IO;
class Program
{
static void Main()
{
// Stacking using statements for multiple disposable resources
using (StreamReader reader1 = new StreamReader("example1.txt"))
using (StreamReader reader2 = new StreamReader("example2.txt"))
{
string content1 = reader1.ReadToEnd();
string content2 = reader2.ReadToEnd();
Console.WriteLine($"Content from example1.txt:\n{content1}\nContent from example2.txt:\n{content2}");
}
// Attempting to use a single using statement with multiple resources (not valid)
// Note: This method using comma-separated resources is not supported in C#
}
}Imports Microsoft.VisualBasic
Imports System
Imports System.IO
Friend Class Program
Shared Sub Main()
' Stacking using statements for multiple disposable resources
Using reader1 As New StreamReader("example1.txt")
Using reader2 As New StreamReader("example2.txt")
Dim content1 As String = reader1.ReadToEnd()
Dim content2 As String = reader2.ReadToEnd()
Console.WriteLine($"Content from example1.txt:" & vbLf & "{content1}" & vbLf & "Content from example2.txt:" & vbLf & "{content2}")
End Using
End Using
' Attempting to use a single using statement with multiple resources (not valid)
' Note: This method using comma-separated resources is not supported in C#
End Sub
End ClassObservação: C# não suporta uma única instrução using com vários recursos separados por vírgulas. Cada recurso requer sua própria declaração using.
Às vezes, você pode criar suas próprias classes personalizadas para gerenciar um ou mais recursos. Se a sua classe for responsável por lidar com objetos descartáveis ou recursos não gerenciados, você deve implementar a interface IDisposable.
Aqui está um exemplo de uma classe personalizada que implementa a interface IDisposable:
using System;
using System.IO;
public class CustomResource : IDisposable
{
private StreamReader _reader;
public CustomResource(string filePath)
{
_reader = new StreamReader(filePath);
}
public void ReadContent()
{
string content = _reader.ReadToEnd();
Console.WriteLine(content);
}
public void Dispose()
{
if (_reader != null)
{
_reader.Dispose();
_reader = null;
}
}
}Imports System
Imports System.IO
Public Class CustomResource
Implements IDisposable
Private _reader As StreamReader
Public Sub New(ByVal filePath As String)
_reader = New StreamReader(filePath)
End Sub
Public Sub ReadContent()
Dim content As String = _reader.ReadToEnd()
Console.WriteLine(content)
End Sub
Public Sub Dispose() Implements IDisposable.Dispose
If _reader IsNot Nothing Then
_reader.Dispose()
_reader = Nothing
End If
End Sub
End ClassNeste exemplo, a classe CustomResource gerencia um objeto StreamReader, que é um objeto descartável. Ao implementar a interface IDisposable e um método Dispose, podemos usar a instrução using com instâncias dessa classe.
Eis como você usaria a instrução using com a classe CustomResource:
class Program
{
static void Main()
{
using (CustomResource resource = new CustomResource("example.txt"))
{
resource.ReadContent();
}
}
}Friend Class Program
Shared Sub Main()
Using resource As New CustomResource("example.txt")
resource.ReadContent()
End Using
End Sub
End ClassQuando o bloco using terminar, o método Dispose será chamado, descartando o objeto StreamReader que ele gerencia.
Outro benefício da instrução using é que ela ajuda a lidar com exceções de forma mais elegante. Se ocorrer uma exceção dentro do bloco using, o método Dispose ainda será chamado no recurso, garantindo a limpeza adequada.
Por exemplo, considere o seguinte código:
using System;
using System.IO;
class Program
{
static void Main()
{
try
{
using (StreamReader reader = new StreamReader("nonexistentfile.txt"))
{
string content = reader.ReadToEnd();
Console.WriteLine(content);
}
}
catch (FileNotFoundException ex)
{
Console.WriteLine($"Error: {ex.Message}");
}
}
}Imports System
Imports System.IO
Friend Class Program
Shared Sub Main()
Try
Using reader As New StreamReader("nonexistentfile.txt")
Dim content As String = reader.ReadToEnd()
Console.WriteLine(content)
End Using
Catch ex As FileNotFoundException
Console.WriteLine($"Error: {ex.Message}")
End Try
End Sub
End ClassNesse caso, se o código lançar uma exceção FileNotFoundException, a exceção será capturada e tratada pelo bloco catch. Embora a exceção tenha ocorrido dentro do bloco using, o método Dispose ainda é chamado no objeto StreamReader, garantindo que nenhum recurso seja desperdiçado.
usingIronPDF é uma biblioteca popular para criar, editar e extrair arquivos PDF em aplicações C# e .NET . Assim como outras bibliotecas que trabalham com recursos, o IronPDF também pode se beneficiar da declaração using para garantir o gerenciamento adequado de recursos.
Vamos explorar como usar a instrução using com o IronPDF para criar um documento PDF a partir de uma string HTML, demonstrando o poder da instrução using em um cenário real.
Primeiro, certifique-se de ter instalado o pacote NuGet IronPDF em seu projeto:
Agora, vamos extrair todos os dados do arquivo PDF:
using IronPdf;
class Program
{
static void Main()
{
// Using a using statement with IronPDF to ensure resources are managed
using (PdfDocument pdfDocument = PdfDocument.FromFile("PDFData.pdf"))
{
string extractedText = pdfDocument.ExtractAllText();
Console.WriteLine(extractedText);
}
}
}Imports IronPdf
Friend Class Program
Shared Sub Main()
' Using a using statement with IronPDF to ensure resources are managed
Using pdfDocument As PdfDocument = PdfDocument.FromFile("PDFData.pdf")
Dim extractedText As String = pdfDocument.ExtractAllText()
Console.WriteLine(extractedText)
End Using
End Sub
End ClassNeste código, abrimos um arquivo PDF chamado "PDFData.pdf" usando o método PdfDocument.FromFile. Este método retorna uma instância de PdfDocument, que envolvemos em uma instrução using.
Dentro do bloco using, chamamos ExtractAllText na instância PdfDocument para extrair todo o texto do PDF. Ao sair do bloco using, o método Dispose é chamado automaticamente no PdfDocument, liberando quaisquer recursos que ele estivesse utilizando.
Ao utilizar a instrução using com PdfDocument, garantimos que o arquivo PDF seja fechado corretamente após a extração do texto, mesmo que ocorra uma exceção durante o processo. Este é um bom exemplo de como a instrução using pode ajudar a gerenciar recursos de forma eficaz em C#.
E essa foi uma breve apresentação da declaração "using"! Observamos como isso garante o manuseio eficiente de objetos descartáveis, gerenciando um ou vários recursos de forma integrada. A declaração using não só ajuda a manter um código mais limpo, como também melhora a legibilidade do seu projeto C#.
Também apresentamos o IronPDF, uma biblioteca robusta para manipulação de PDFs em C#. O uso da instrução using em conjunto com o IronPDF demonstra a aplicação prática desse recurso de código, reforçando o conceito e sua importância.
Pronto para colocar as mãos no IronPDF? Você pode começar com nosso teste gratuito de 30 dias do IronPDF e do pacote Iron Software . Além disso, é totalmente gratuito para uso em desenvolvimento, permitindo que você realmente veja do que ele é capaz. E se você gostar do que vê, o IronPDF começa com preços a partir de $999 para opções de licenciamento. Para economizar ainda mais, confira o pacote completo de Iron Software Suite , onde você obtém todas as nove ferramentas da Iron Software pelo preço de duas. Boa programação!
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronPDF faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
Quando você precisa que seu PDF tenha a aparência de HTML, rapidamente.
