AYUDA .NET

Uso de C# (Cómo funciona para desarrolladores)

Publicado en 15 de agosto, 2024

Incluso si está empezando a familiarizarse con C#, es probable que ya se haya topado con la directiva using. Y si es usuario de IronPDF, le resultará muy familiar iniciar su código con el espacio de nombres using ironpdf.

Sin embargo, hay otro uso para la palabra clave using. En esta guía veremos la sentencia using: qué es, cómo funciona y cómo puede ayudarte a crear código más eficiente. Sumerjámonos!

¿Qué es Using en C#?

La sentencia using en C# es una forma práctica de trabajar con recursos que implementan la interfaz IDisposable. Los objetos IDisposable suelen retener recursos no gestionados, como manejadores de archivos o conexiones de red, que deben liberarse cuando termines de utilizarlos. Aquí es donde entra en juego la declaración de uso: te ayuda a garantizar que estos recursos se eliminan correctamente después de su uso.

Cómo funciona la declaración de uso

Cuando utilice la sentencia using, C# llamará automáticamente al método Dispose del objeto cuando ya no lo necesite. Esto significa que no tienes que llamar manualmente al método Dispose o preocuparte de olvidarte de hacerlo. La declaración de uso se encarga de ello!

Veamos un ejemplo sencillo para ver cómo funciona la sentencia using en acción:

using System.IO;

class Program
{
    static void Main()
    {
        using (StreamReader reader = new StreamReader("example.txt"))
        {
            string content = reader.ReadToEnd();
            Console.WriteLine(content);
        }
    }
}

using System.IO;

class Program
{
    static void Main()
    {
        using (StreamReader reader = new StreamReader("example.txt"))
        {
            string content = reader.ReadToEnd();
            Console.WriteLine(content);
        }
    }
}

Imports System.IO

Friend Class Program
	Shared Sub Main()
		Using reader As New StreamReader("example.txt")
			Dim content As String = reader.ReadToEnd()
			Console.WriteLine(content)
		End Using
	End Sub
End Class

VB C#

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

Uso del bloque frente al uso de la declaración

A partir de C# 8.0, puede utilizar la declaración using en lugar del bloque using. La declaración using es una forma más breve y concisa de definir un objeto desechable, como por ejemplo

using System.IO;

class Program
{
    static void Main()
    {
        using var reader = new StreamReader("example.txt");
        string content = reader.ReadToEnd();
        Console.WriteLine(content);
    }
}

using System.IO;

class Program
{
    static void Main()
    {
        using var reader = new StreamReader("example.txt");
        string content = reader.ReadToEnd();
        Console.WriteLine(content);
    }
}

Imports System.IO

Friend Class Program
	Shared Sub Main()
		Dim reader = New StreamReader("example.txt")
		Dim content As String = reader.ReadToEnd()
		Console.WriteLine(content)
	End Sub
End Class

VB C#

Con la declaración using, no se necesitan las llaves ni la sangría, lo que hace que el código sea más legible. El método Dispose sigue siendo llamado automáticamente cuando la variable sale del ámbito.

Bloque Try, bloque Finally y sentencia Using

Puede que te preguntes cómo se relaciona la sentencia using con los bloques try y finally en C#. Bueno, la sentencia using es en realidad una abreviatura de un bloque try-finally!

Aquí está el mismo ejemplo que antes, pero escrito usando un bloque try-finally en lugar de una sentencia using:

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.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.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
			If reader IsNot Nothing Then
				reader.Dispose()
			End If
		End Try
	End Sub
End Class

VB C#

Como puede ver, la sentencia 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 ventajas de la sentencia using es que puede manejar varios recursos a la vez. Puede apilar sentencias using una tras otra, o utilizar una única sentencia using para manejar múltiples recursos en una lista separada por comas. He aquí un ejemplo que demuestra ambos enfoques:

using System.IO;

class Program
{
    static void Main()
    {
        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}");
        }

        // Alternatively, you can use a single using statement with multiple resources:

        using (StreamReader reader1 = new StreamReader("example1.txt"), 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}");
        }
    }
}

using System.IO;

class Program
{
    static void Main()
    {
        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}");
        }

        // Alternatively, you can use a single using statement with multiple resources:

        using (StreamReader reader1 = new StreamReader("example1.txt"), 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}");
        }
    }
}

Imports Microsoft.VisualBasic
Imports System.IO

Friend Class Program
	Shared Sub Main()
		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

		' Alternatively, you can use a single using statement with multiple resources:

		Using reader1 As New StreamReader("example1.txt"), 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 Sub
End Class

VB C#

Ambos enfoques garantizarán que se llame al método Dispose en cada objeto StreamReader cuando se salga del bloque de uso, liberando así cualquier recurso al que se estuvieran aferrando.

Implementación de la interfaz IDisposable

A veces, puede crear sus propias clases personalizadas que gestionan uno o más recursos. Si tu clase es responsable de manejar objetos desechables o recursos no gestionados, debes implementar la interfaz IDisposable.

He aquí un ejemplo de 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

VB C#

En este ejemplo, la clase CustomResource gestiona un objeto StreamReader, que es un objeto desechable. Implementando la interfaz IDisposable e implementando un método Dispose, podemos utilizar la sentencia using con instancias de esta clase.

A continuación se muestra cómo utilizar la sentencia 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

VB C#

Cuando el bloque using finalice, se llamará al método Dispose, que se deshará del objeto StreamReader que gestiona.

Manejo de excepciones con la sentencia Using

Otra ventaja de la sentencia using es que ayuda a manejar las excepciones con más elegancia. Si se produce una excepción dentro del bloque using, el método Dispose seguirá siendo llamado en el recurso, asegurando una limpieza adecuada.

Por ejemplo, considere 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

VB C#

En este caso, si el código lanza una FileNotFoundException, la excepción es capturada y manejada por el bloque catch. A pesar de que la excepción se produjo dentro del bloque using, el método Dispose sigue siendo llamado en el objeto StreamReader, asegurando que no se filtren recursos.

Trabajar con IronPDF y la declaración Using

IronPDF es una conocida biblioteca 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 sentencia using para garantizar una gestión adecuada de los recursos.

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

En primer lugar, asegúrese de haber instalado el paquete IronPDF NuGet en su proyecto:

Instalar el paquete IronPDF

Ahora, vamos a extraer todos los datos del archivo PDF:

using IronPdf;

class Program
{
    static void Main()
    {
        using (PdfDocument pdfDocument = PdfDocument.FromFile("PDFData.pdf"))
        {
            string extractedText = pdfDocument.ExtractAllText();
            Console.WriteLine(extractedText);
        }
    }
}

using IronPdf;

class Program
{
    static void Main()
    {
        using (PdfDocument pdfDocument = PdfDocument.FromFile("PDFData.pdf"))
        {
            string extractedText = pdfDocument.ExtractAllText();
            Console.WriteLine(extractedText);
        }
    }
}

Imports IronPdf

Friend Class Program
	Shared Sub Main()
		Using pdfDocument As PdfDocument = PdfDocument.FromFile("PDFData.pdf")
			Dim extractedText As String = pdfDocument.ExtractAllText()
			Console.WriteLine(extractedText)
		End Using
	End Sub
End Class

VB C#

En este código, abrimos un archivo PDF llamado "PDFData.pdf" utilizando el método PdfDocument.FromFile. Este método devuelve una instancia de PdfDocument, que envolvemos en una sentencia 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, se llama automáticamente al método Dispose en el PdfDocument, liberando cualquier recurso que estuviera reteniendo.

Al utilizar la sentencia using con PdfDocument, nos aseguramos de que el archivo PDF se cierra correctamente después de que hayamos terminado de extraer texto de él, incluso si se produce una excepción durante el proceso. Este es un buen ejemplo de cómo la sentencia using puede ayudar a gestionar los recursos de forma eficaz en C#.

Csharp Using 1 related to Trabajar con IronPDF y la declaración Using

Conclusión

Y esto es todo un recorrido por la declaración de uso! Hemos visto cómo garantiza el manejo eficaz de objetos desechables, gestionando uno o varios recursos sin problemas. La sentencia using no sólo ayuda a mantener un código más limpio, sino que también mejora la legibilidad de su proyecto C#.

También presentamos IronPDF, una robusta biblioteca para la manipulación de PDF en C#. El empleo de la sentencia using junto con IronPDF demuestra la aplicación práctica de esta característica del código, reforzando el concepto y su importancia.

¿Está listo para utilizar IronPDF? Puede empezar con nuestro30 días de prueba gratuita de IronPDF y Iron Software's Suite. Además, su uso para fines de desarrollo es totalmente gratuito, por lo que podrás ver de qué está hecho. Y si le gusta lo que ve, IronPDF le ofrece desde tan sólo749 $ para opciones de licencia. Para ahorrar aún más, consulte laPaquete completo de software Iron Suite donde puede conseguir las nueve herramientas de Iron Software por el precio de dos. Feliz codificación!

Csharp Using 2 related to Conclusión