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

Incluso si estás empezando a familiarizarte con C#, es probable que ya te hayas encontrado 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);
           }
       }
   }

IRON VB CONVERTER ERROR developers@ironsoftware.com

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

IRON VB CONVERTER ERROR developers@ironsoftware.com

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

IRON VB CONVERTER ERROR developers@ironsoftware.com

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()t
       {
           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{conten1}\nContent from example2.txt:\n{content2}");
           }
       }
   }

   using System.IO;
   class Program
   {
       static void Main()t
       {
           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{conten1}\nContent from example2.txt:\n{content2}");
           }
       }
   }

IRON VB CONVERTER ERROR developers@ironsoftware.com

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

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

IRON VB CONVERTER ERROR developers@ironsoftware.com

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

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

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

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 nuestro 30 días de prueba gratuita. 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ólo $749. Para ahorrar aún más, consulte el Iron Suite donde puede conseguir las nueve herramientas de Iron Software por el precio de dos. Feliz codificación!