Usando C# (Como funciona para desenvolvedores)

O que é using em C#?

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.

Como funciona a instrução using

Ao 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);
        }
    }
}

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 Class

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

Usando Blocos vs. Usando Declarações

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);
    }
}

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 Class

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

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
        {
            if (reader != null)
            {
                reader.Dispose();
            }
        }
    }
}

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
        {
            if (reader != null)
            {
                reader.Dispose();
            }
        }
    }
}

Imports System
Imports System.IO

Module Program
    Sub Main()
        Dim reader As StreamReader = Nothing
        Try
            reader = New StreamReader("example.txt")
            Dim content As String = reader.ReadToEnd()
            Console.WriteLine(content)
        Finally
            If reader IsNot Nothing Then
                reader.Dispose()
            End If
        End Try
    End Sub
End Module

Gerenciando múltiplos recursos

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

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 Class

Observaçã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.

Implementando a interface IDisposable

À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;
        }
    }
}

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 Class

Neste 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();
        }
    }
}

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 Class

Quando o bloco using terminar, o método Dispose será chamado, descartando o objeto StreamReader que ele gerencia.

Tratamento de exceções com a instrução using

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}");
        }
    }
}

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 Class

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

Trabalhando com o IronPDF e a declaração using

IronPDF é 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:

Install-Package IronPdf

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);
        }
    }
}

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 Class

Neste 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#.

Concluindo

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 a partir de $799 para opções de licenciamento . Para economizar ainda mais, confira o pacote completo de software Iron Suite , onde você obtém todas as nove ferramentas da Iron Software pelo preço de duas. Boa programação!