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

Si estás empezando con la programación en C# o incluso si tienes algo de experiencia, estás en el lugar adecuado. En este tutorial, exploraremos la sentencia using, su propósito y cómo utilizarla eficazmente en tu código. Así que, vamos a sumergirnos!

¿Qué es la Declaración de Uso?

La sentencia using en C# es una forma cómoda de trabajar con recursos que implementan la interfaz IDisposable. Los objetos IDisposable suelen contener recursos no gestionados, como manejadores de archivos o conexiones de red, que deben ser liberados cuando termines de utilizarlos. Aquí es donde entra en juego la sentencia using, que te ayuda a asegurarte de que estos recursos se eliminan correctamente después de su uso. Por ejemplo, la sentencia using es muy útil en C#

Cómo funciona la declaración de uso

Cuando utilices la sentencia using, C# llamará automáticamente al método Dispose del objeto cuando ya no sea necesario. Esto significa que no tienes que llamar manualmente al método Dispose o preocuparte de olvidarte de hacerlo. La sentencia using se encarga de esto por ti!

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

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 reader, 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

Con la declaración using no son necesarias 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

Como puedes 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. Puedes apilar las sentencias using una tras otra, o utilizar una única sentencia using para manejar múltiples recursos en una lista separada por comas. Aquí tienes un ejemplo que muestra 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}");
            }

            //  También puede utilizar una única sentencia using con varios recursos:

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

            //  También puede utilizar una única sentencia using con varios recursos:

            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

			'  También puede utilizar una única sentencia using con varios recursos:

			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

Ambos enfoques aseguran que el método Dispose es llamado en cada objeto StreamReader cuando el bloque using es finalizado, liberando cualquier recurso que estuviera reteniendo.

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, deberías implementar la interfaz IDisposable.

Este es 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

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

Cuando el bloque using termine, 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

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

Trabajar con IronPDF y la declaración Using

IronPDF es una popular 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:

Install-Package 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

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 los recursos que tuviera retenidos.

Al utilizar la sentencia using con PdfDocument, nos aseguramos de que el archivo PDF se cierra correctamente una vez que hemos 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#.

Conclusión

En este tutorial, hemos profundizado en la sentencia using de C#, explorando su propósito, funcionalidad y aplicación en el mundo real. 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 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.

IronPDF ofrece un prueba gratuita Así tendrá la oportunidad de probar sus posibilidades y ver cómo puede beneficiar a sus proyectos. Las licencias comienzan a partir de $749.