Ícono de mensaje
Saltar al pie de página
  1. IronPDF
  2. Blog de IronPDF
  3. Guía de .NET
  4. Uso de C#
.NET AYUDA

Uso de "using" en C# (Cómo funciona para desarrolladores)

Jacob Mellor, Director de Tecnología @ Team Iron
Jacob Mellor
Actualizado:

Incluso si apenas estás familiarizándote con C#, probablemente ya te hayas encontrado con la directiva using. Y si eres un usuario de IronPDF, estarás muy familiarizado con comenzar tu código con el espacio de nombres using ironpdf.

Sin embargo, hay otro uso para la palabra clave using. En esta guía, vamos a ver la instrucción using: qué es, cómo funciona y cómo puede ayudarte a crear un código más eficiente. ¡Vamos a profundizar!

¿Qué es Using in C#?

La instrucción using en C# es una forma conveniente de trabajar con recursos que implementan la interfaz IDisposable. Los objetos IDisposable típicamente retienen recursos no administrados, como manejadores de archivos o conexiones de red, que necesitan ser liberados cuando terminas de usarlos. Aquí es donde entra en juego la instrucción using: te ayuda a garantizar que estos recursos se desechen adecuadamente después de usarlos.

Cómo funciona el enunciado de uso

Cuando usas la instrucción using, C# llamará automáticamente al método Dispose en el objeto cuando ya no sea necesario. Esto significa que no tienes que llamar manualmente al método Dispose ni preocuparte por olvidarlo. ¡La instrucción using se encarga de esto por ti!

Echemos un vistazo a un ejemplo simple para ver cómo funciona la instrucción using en acción: 

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
$vbLabelText   $csharpLabel

En este ejemplo, el objeto StreamReader llamado reader está envuelto en un bloque using. Cuando se sale del bloque using, el método Dispose se llama automáticamente en el reader, liberando cualquier recurso que estuviera reteniendo.

Bloque de uso frente a declaración de uso

A partir de C# 8.0, puedes usar la declaración using en lugar del bloque using. La declaración using es una forma más corta y concisa de definir un objeto desechable, de esta manera:

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
$vbLabelText   $csharpLabel

Con la declaración using, no necesitas las llaves ni la indentación, haciendo que tu código sea más legible. El método Dispose aún se llama automáticamente cuando la variable sale del alcance.

Bloque Try, bloque Finally y la sentencia Using

Puede que te estés preguntando cómo se relaciona la instrucción using con los bloques try y finally en C#. Bueno, la instrucción using es en realidad una abreviatura para un bloque try-finally.

Aquí está el mismo ejemplo que antes, pero escrito usando un bloque try-finally en lugar de una instrucción 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();
            }
        }
    }
}
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 Class
$vbLabelText   $csharpLabel

Como puedes ver, la instrucción using hace que el código sea más limpio y fácil de leer al eliminar la necesidad del bloque try-finally y la llamada explícita al método Dispose.

Gestión de múltiples recursos

Una de las grandes cosas de la instrucción using es que puede manejar múltiples recursos a la vez. Puedes apilar instrucciones using una tras otra, o usar una sola instrucción using para manejar múltiples recursos en una lista separada por comas. Aquí hay un ejemplo que demuestra ambos enfoques:

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
$vbLabelText   $csharpLabel

Nota: C# no soporta una sola instrucción using con múltiples recursos separados por comas. Cada recurso requiere su propia instrucción using.

Implementación de la interfaz IDisposable

A veces, puedes crear tus propias clases personalizadas que manejen uno o más recursos. Si tu clase es responsable de manejar objetos desechables o recursos no administrados, deberías implementar la interfaz IDisposable.

Aquí hay un ejemplo de una clase personalizada que implementa la interfaz 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
$vbLabelText   $csharpLabel

En este ejemplo, la clase CustomResource maneja un objeto StreamReader, que es un objeto desechable. Al implementar la interfaz IDisposable y un método Dispose, podemos usar la instrucción using con instancias de esta clase.

Aquí está cómo usarías la instrucción using con la clase 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
$vbLabelText   $csharpLabel

Cuando el bloque using termina, el método Dispose será llamado, desechando el objeto StreamReader que maneja.

Manejo de excepciones con la sentencia Using

Otro beneficio de la instrucción using es que ayuda a manejar excepciones de manera más elegante. Si ocurre una excepción dentro del bloque using, el método Dispose aún se llamará en el recurso, asegurando una limpieza adecuada.

Por ejemplo, considera el siguiente 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
$vbLabelText   $csharpLabel

En este caso, si el código lanza una FileNotFoundException, la excepción es capturada y manejada por el bloque catch. Aun cuando la excepción ocurrió dentro del bloque using, el método Dispose aún se llamará en el objeto StreamReader, asegurando que no se filtren recursos.

Trabajando con IronPDF y la declaración Using

IronPDF es una biblioteca popular para crear, editar y extraer archivos PDF en aplicaciones C# y .NET. Al igual que otras bibliotecas que trabajan con recursos, IronPDF también puede beneficiarse de la instrucción using para garantizar una adecuada gestión de recursos.

Exploremos cómo usar la instrucción using con IronPDF para crear un documento PDF a partir de una cadena HTML, demostrando el poder de la instrucción using en un escenario de la vida real.

Primero, asegúrate de haber instalado el paquete NuGet de IronPDF en tu proyecto:

Install-Package IronPdf

Ahora, extraigamos todos los datos del archivo 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
$vbLabelText   $csharpLabel

En este código, abrimos un archivo PDF llamado "PDFData.pdf" usando el método PdfDocument.FromFile. Este método devuelve una instancia de PdfDocument, que envolvemos en una instrucción using.

Dentro del bloque using, llamamos a ExtractAllText en la instancia PdfDocument para extraer todo el texto del PDF. Cuando se sale del bloque using, el método Dispose se llama automáticamente en el PdfDocument, liberando cualquier recurso que estuviera reteniendo.

Al usar la instrucción using con PdfDocument, nos aseguramos de que el archivo PDF esté adecuadamente cerrado después de terminar de extraer texto de él, incluso si ocurre una excepción durante el proceso. Este es un buen ejemplo de cómo la instrucción using puede ayudar a gestionar recursos efectivamente en C#.

Declaración de Usar en C#

Resumen

¡Y ese es un recorrido rápido sobre la instrucción using! Hemos visto cómo asegura un manejo eficiente de objetos desechables, gestionando uno o varios recursos sin problemas. La instrucción using no solo ayuda a mantener un código más limpio, sino que también mejora la legibilidad de tu proyecto C#.

También presentamos IronPDF, una robusta biblioteca para manejo de PDF en C#. Emplear la instrucción using en conjunción con IronPDF demuestra la aplicación práctica de esta función de código, reforzando el concepto y su importancia.

¿Listo para poner tus manos en IronPDF? Puedes comenzar con nuestra prueba gratuita de 30 días de IronPDF y el conjunto de Iron Software. También es completamente gratis para usar con fines de desarrollo, para que realmente puedas ver de qué está hecho. Y si te gusta lo que ves, IronPDF empieza desde tan solo $799 para opciones de licencias. Para ahorrar aún más, consulta el paquete de software completo de Iron Suite donde puedes obtener las nueve herramientas de Iron Software por el precio de dos. ¡Feliz programación!

Declaración de Usar de IronPDF

Preguntas Frecuentes

¿Cuál es el propósito de la declaración using en C#?

La declaración using en C# se utiliza para gestionar recursos que implementan la interfaz IDisposable, como manejadores de archivos o conexiones de red, asegurando que se eliminen adecuadamente después de su uso.

¿Cómo puede la declaración using en C# ayudar a prevenir fugas de recursos?

La declaración using llama automáticamente al método Dispose en los objetos cuando ya no se necesitan, lo que ayuda a prevenir fugas de recursos asegurando que los recursos se liberen, incluso si ocurren excepciones.

¿Cuáles son las diferencias entre el bloque using y la declaración using en C#?

El bloque using encierra el código entre llaves y asegura la eliminación al final del bloque, mientras que la declaración using, introducida en C# 8.0, es más concisa y elimina automáticamente los recursos cuando salen de alcance.

¿Cómo puedo implementar IDisposable en mis clases personalizadas de C#?

Para implementar IDisposable en clases personalizadas, define un método Dispose para liberar recursos no administrados, permitiendo el uso de la declaración using para una gestión automática de recursos.

¿Puede la declaración using manejar múltiples recursos en C#?

Sí, puedes gestionar múltiples recursos apilando varias declaraciones using, aunque no se admite una sola declaración using con múltiples recursos separados por comas.

¿Por qué se prefiere la declaración using sobre los bloques try-finally en C#?

La declaración using se prefiere por su sintaxis más limpia y gestión automática de recursos, lo que simplifica el código en comparación con la implementación manual de bloques try-finally para asegurar la eliminación de recursos.

¿Cómo puedo gestionar de manera efectiva documentos PDF en C#?

Puedes gestionar documentos PDF de manera efectiva usando IronPDF, que se integra con la declaración using para asegurar que recursos como instancias de documentos se cierren adecuadamente después de operaciones como la extracción de texto.

¿Hay una prueba disponible para las bibliotecas de PDF para el desarrollo en C#?

Sí, ciertas bibliotecas de PDF ofrecen una prueba gratuita de 30 días y son gratuitas para fines de desarrollo, lo que te permite explorar sus capacidades antes de comprar.

Jacob Mellor, Director de Tecnología @ Team Iron
Jacob Mellor
  Chatea con el equipo de ingeniería ahora
Director de Tecnología

Jacob Mellor es Director de Tecnología en Iron Software y un ingeniero visionario que lidera la tecnología PDF en C#. Como el desarrollador original detrás de la base de código central de Iron Software, ha moldeado la arquitectura de productos de la compañía desde ...

Leer más

Artículos Relacionados

Prueba de 30 días → Producto completo. Sin límites. Sin tarjeta. Comenzar prueba gratuita