AYUDA .NET

Métodos de extensión de C# (Cómo funciona para los desarrolladores)

Actualizado 16 de mayo, 2023
Compartir:

Los métodos de extensión son una potente característica de C# que permite añadir nuevas funciones a tipos existentes sin modificar su código fuente. Pueden ser muy útiles para que el código sea más legible y fácil de mantener. En este tutorial, exploraremos los fundamentos de los métodos de extensión y cómo implementarlos.

¿Qué son los métodos de ampliación?

Los métodos de extensión son métodos estáticos especiales que pueden invocarse como si fueran métodos de instancia de un tipo existente. Son una forma cómoda de añadir nuevos métodos a una clase existente sin cambiar el código fuente original ni heredar de la clase.

Para crear un método de extensión, es necesario definir un método estático dentro de una clase estática. El primer parámetro del método debe ser el tipo que desea extender, prefijado con la palabra clave this. Esta palabra clave especial indica al compilador de C# que se trata de un método de extensión.

Implementación de métodos de extensión en C#

Ahora que sabemos lo que son los métodos de extensión, vamos a implementar uno. Imagina que tienes una cadena que quieres invertir. En lugar de escribir una función separada para hacer esto, puedes crear un método de extensión para la clase string.

En primer lugar, vamos a crear una nueva clase estática llamada StringExtensions. El nombre de la clase no es importante, pero es una convención común utilizar el nombre del tipo que se está extendiendo seguido de "Extensiones". Dentro de esta clase, definiremos un método estático llamado Reverse:

public static class StringExtensions
{
    public static string Reverse(this string input)
    {
        char [] chars = input.ToCharArray();
        Array.Reverse(chars);
        return new string(chars);
    }
}
public static class StringExtensions
{
    public static string Reverse(this string input)
    {
        char [] chars = input.ToCharArray();
        Array.Reverse(chars);
        return new string(chars);
    }
}
Public Module StringExtensions
	<System.Runtime.CompilerServices.Extension> _
	Public Function Reverse(ByVal input As String) As String
		Dim chars() As Char = input.ToCharArray()
		Array.Reverse(chars)
		Return New String(chars)
	End Function
End Module
VB   C#

En este ejemplo, hemos creado un método public static string llamado Reverse con un único parámetro. La palabra clave this delante del tipo string indica que se trata de un método de extensión de la clase string.

Veamos ahora cómo utilizar este nuevo método de extensión en nuestra clase Program:

class Program
{
    static void Main(string [] args)
    {
        string example = "Hello, World!";
        string reversed = example.Reverse();
        Console.WriteLine(reversed); //  !dlroW ,olleH
    }
}
class Program
{
    static void Main(string [] args)
    {
        string example = "Hello, World!";
        string reversed = example.Reverse();
        Console.WriteLine(reversed); //  !dlroW ,olleH
    }
}
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim example As String = "Hello, World!"
		Dim reversed As String = example.Reverse()
		Console.WriteLine(reversed) '  !dlroW ,olleH
	End Sub
End Class
VB   C#

Observa que no hemos tenido que crear una instancia de la clase StringExtensions. En su lugar, utilizamos el método Reverse directamente en la instancia string como si fuera un método de instancia.

Sintaxis del método de ampliación

Los métodos de extensión parecen y se comportan como los métodos de instancia, pero hay algunas diferencias importantes que hay que tener en cuenta:

  1. Los métodos de extensión no pueden acceder a miembros privados del tipo extendido.
  2. Tampoco participan en la herencia ni en el polimorfismo.
  3. No se puede sobrescribir un método existente con un método de extensión.

    Si el tipo extendido tiene un método con la misma firma que un método de extensión, el método de instancia siempre tendrá preferencia. Los métodos de extensión sólo se invocan cuando no existe un método de instancia correspondiente.

Ejemplos reales de métodos de ampliación

Ahora que ya conocemos los conceptos básicos de los métodos de extensión en C#, veamos algunos ejemplos reales.

Método de extensión de cadenas Recuento de palabras

Imagina que quieres contar el número de palabras de una cadena. Puedes crear un método de extensión WordCount para la clase string:

public static class StringExtensions
{
    public static int WordCount(this string input)
    {
        return input.Split(new [] { ' ', '\t', '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries).Length;
    }
}
public static class StringExtensions
{
    public static int WordCount(this string input)
    {
        return input.Split(new [] { ' ', '\t', '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries).Length;
    }
}
Imports Microsoft.VisualBasic

Public Module StringExtensions
	<System.Runtime.CompilerServices.Extension> _
	Public Function WordCount(ByVal input As String) As Integer
		Return input.Split( { " "c, ControlChars.Tab, ControlChars.Cr, ControlChars.Lf }, StringSplitOptions.RemoveEmptyEntries).Length
	End Function
End Module
VB   C#

Ahora, puedes contar fácilmente el número de palabras de una cadena como ésta:

string text = "Extension methods are awesome!";
int wordCount = text.WordCount();
Console.WriteLine($"The text has {wordCount} words."); //  El texto tiene 4 palabras.
string text = "Extension methods are awesome!";
int wordCount = text.WordCount();
Console.WriteLine($"The text has {wordCount} words."); //  El texto tiene 4 palabras.
Dim text As String = "Extension methods are awesome!"
Dim wordCount As Integer = text.WordCount()
Console.WriteLine($"The text has {wordCount} words.") '  El texto tiene 4 palabras.
VB   C#

Método de extensión IEnumerable Median

Supongamos que tienes una colección de números y quieres calcular el valor de la mediana. Puede crear un método de extensión para IEnumerable:

public static class EnumerableExtensions
{
    public static double Median(this IEnumerable source)
    {
        int [] sorted = source.OrderBy(x => x).ToArray();
        int count = sorted.Length;

        if (count == 0)
        {
            throw new InvalidOperationException("The collection is empty.");
        }

        if (count % 2 == 0)
        {
            return (sorted [count / 2 - 1] + sorted [count / 2]) / 2.0;
        }
        else
        {
            return sorted [count / 2];
        }
    }
}
public static class EnumerableExtensions
{
    public static double Median(this IEnumerable source)
    {
        int [] sorted = source.OrderBy(x => x).ToArray();
        int count = sorted.Length;

        if (count == 0)
        {
            throw new InvalidOperationException("The collection is empty.");
        }

        if (count % 2 == 0)
        {
            return (sorted [count / 2 - 1] + sorted [count / 2]) / 2.0;
        }
        else
        {
            return sorted [count / 2];
        }
    }
}
Public Module EnumerableExtensions
	<System.Runtime.CompilerServices.Extension> _
	Public Function Median(ByVal source As IEnumerable) As Double
		Dim sorted() As Integer = source.OrderBy(Function(x) x).ToArray()
		Dim count As Integer = sorted.Length

		If count = 0 Then
			Throw New InvalidOperationException("The collection is empty.")
		End If

		If count Mod 2 = 0 Then
			Return (sorted (count \ 2 - 1) + sorted (count \ 2)) / 2.0
		Else
			Return sorted (count \ 2)
		End If
	End Function
End Module
VB   C#

Con este método de extensión, puede encontrar fácilmente el valor mediano de una colección:

int [] numbers = { 5, 3, 9, 1, 4 };
double median = numbers.Median();
Console.WriteLine($"The median value is {median}."); //  El valor mediano es 4.
int [] numbers = { 5, 3, 9, 1, 4 };
double median = numbers.Median();
Console.WriteLine($"The median value is {median}."); //  El valor mediano es 4.
Dim numbers() As Integer = { 5, 3, 9, 1, 4 }
Dim median As Double = numbers.Median()
Console.WriteLine($"The median value is {median}.") '  El valor mediano es 4.
VB   C#

Extensión DateTime Método StartOfWeek

Supongamos que desea encontrar el inicio de la semana para una fecha determinada. Puede crear un método de extensión para la estructura DateTime:

public static class DateTimeExtensions
{
    public static DateTime StartOfWeek(this DateTime dt, DayOfWeek startOfWeek = DayOfWeek.Monday)
    {
        int diff = (7 + (dt.DayOfWeek - startOfWeek)) % 7;
        return dt.AddDays(-1 * diff).Date;
    }
}
public static class DateTimeExtensions
{
    public static DateTime StartOfWeek(this DateTime dt, DayOfWeek startOfWeek = DayOfWeek.Monday)
    {
        int diff = (7 + (dt.DayOfWeek - startOfWeek)) % 7;
        return dt.AddDays(-1 * diff).Date;
    }
}
Public Module DateTimeExtensions
'INSTANT VB NOTE: The parameter startOfWeek was renamed since Visual Basic will not allow parameters with the same name as their enclosing function or property:
	<System.Runtime.CompilerServices.Extension> _
	Public Function StartOfWeek(ByVal dt As DateTime, Optional ByVal startOfWeek_Conflict As DayOfWeek = DayOfWeek.Monday) As DateTime
		Dim diff As Integer = (7 + (dt.DayOfWeek - startOfWeek_Conflict)) Mod 7
		Return dt.AddDays(-1 * diff).Date
	End Function
End Module
VB   C#

Ahora, puedes encontrar fácilmente el inicio de la semana para cualquier fecha:

DateTime today = DateTime.Today;
DateTime startOfWeek = today.StartOfWeek();
Console.WriteLine($"The start of the week is {startOfWeek.ToShortDateString()}."); //  El inicio de la semana es 05/08/2023.
DateTime today = DateTime.Today;
DateTime startOfWeek = today.StartOfWeek();
Console.WriteLine($"The start of the week is {startOfWeek.ToShortDateString()}."); //  El inicio de la semana es 05/08/2023.
Dim today As DateTime = DateTime.Today
Dim startOfWeek As DateTime = today.StartOfWeek()
Console.WriteLine($"The start of the week is {startOfWeek.ToShortDateString()}.") '  El inicio de la semana es 05/08/2023.
VB   C#

Generación de PDF con IronPDF y métodos de extensión

En esta sección, presentaremos IronPDF una popular biblioteca para generar y trabajar con archivos PDF en C#. También veremos cómo podemos aprovechar los métodos de extensión para crear una experiencia más fluida e intuitiva al trabajar con esta biblioteca.

IronPDF convierte HTML a PDF de forma que se conserve la disposición y el estilo de los contenidos tal y como aparecerían en un navegador web. La biblioteca puede trabajar con HTML sin procesar de archivos, URL y cadenas.

using IronPdf;

class Program
{
    static void Main(string [] args)
    {
        var renderer = new ChromePdfRenderer();

        //  1. Convertir cadena HTML a PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        //  2. Convertir archivo HTML a PDF
        var htmlFilePath = "path_to_your_html_file.html"; //  Especifique la ruta a su archivo HTML
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        //  3. Convertir URL a PDF
        var url = "http://ironpdf.com"; // Especificar la URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}
using IronPdf;

class Program
{
    static void Main(string [] args)
    {
        var renderer = new ChromePdfRenderer();

        //  1. Convertir cadena HTML a PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        //  2. Convertir archivo HTML a PDF
        var htmlFilePath = "path_to_your_html_file.html"; //  Especifique la ruta a su archivo HTML
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        //  3. Convertir URL a PDF
        var url = "http://ironpdf.com"; // Especificar la URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}
Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		'  1. Convertir cadena HTML a PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		'  2. Convertir archivo HTML a PDF
		Dim htmlFilePath = "path_to_your_html_file.html" '  Especifique la ruta a su archivo HTML
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		'  3. Convertir URL a PDF
		Dim url = "http://ironpdf.com" ' Especificar la URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class
VB   C#

Instalación de IronPDF

En primer lugar, debe instalar el paquete IronPDF NuGet. En la carpeta de su proyecto, ejecute el siguiente comando:

Install-Package IronPdf

Esto instalará la última versión del paquete IronPDF.

Crear un PDF sencillo

Antes de sumergirnos en los métodos de extensión, veamos cómo crear un PDF sencillo a partir de HTML utilizando IronPDF:

using IronPdf;

class Program
{
    static void Main(string [] args)
    {
        var renderer = new ChromePdfRenderer();;
        var PDF = renderer.RenderHtmlAsPdf("Hello, World!");
        PDF.SaveAs("HelloWorld.PDF");
    }
}
using IronPdf;

class Program
{
    static void Main(string [] args)
    {
        var renderer = new ChromePdfRenderer();;
        var PDF = renderer.RenderHtmlAsPdf("Hello, World!");
        PDF.SaveAs("HelloWorld.PDF");
    }
}
Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()
		Dim PDF = renderer.RenderHtmlAsPdf("Hello, World!")
		PDF.SaveAs("HelloWorld.PDF")
	End Sub
End Class
VB   C#

Este fragmento de código crea un PDF con el texto "Hello, World!" y lo guarda en un archivo llamado "HolaMundo.PDF".

Métodos de extensión para IronPDF

Ahora, vamos a explorar cómo podemos utilizar los métodos de extensión para mejorar la funcionalidad de IronPDF y hacer que sea más fácil trabajar con él. Por ejemplo, podemos crear un método de extensión que tome una instancia de la clase string y genere un PDF directamente a partir de ella.

public static class StringExtensions
{
    public static void SaveAsPdf(this string htmlContent, string filePath)
    {
        var renderer = new ChromePdfRenderer();;
        var PDF = renderer.RenderHtmlAsPdf(htmlContent);
        PDF.SaveAs(filePath);
    }
}
public static class StringExtensions
{
    public static void SaveAsPdf(this string htmlContent, string filePath)
    {
        var renderer = new ChromePdfRenderer();;
        var PDF = renderer.RenderHtmlAsPdf(htmlContent);
        PDF.SaveAs(filePath);
    }
}
Public Module StringExtensions
	<System.Runtime.CompilerServices.Extension> _
	Public Sub SaveAsPdf(ByVal htmlContent As String, ByVal filePath As String)
		Dim renderer = New ChromePdfRenderer()
		Dim PDF = renderer.RenderHtmlAsPdf(htmlContent)
		PDF.SaveAs(filePath)
	End Sub
End Module
VB   C#

Con este método de extensión, ahora podemos generar un PDF directamente a partir de una cadena:

string html = "Extension Methods and IronPDFGenerating PDFs has never been easier!";
html.SaveAsPdf("ExtensionMethodsAndIronPDF.PDF");
string html = "Extension Methods and IronPDFGenerating PDFs has never been easier!";
html.SaveAsPdf("ExtensionMethodsAndIronPDF.PDF");
Dim html As String = "Extension Methods and IronPDFGenerating PDFs has never been easier!"
html.SaveAsPdf("ExtensionMethodsAndIronPDF.PDF")
VB   C#

Generar PDF a partir de URL

Otro método de extensión útil que podemos crear es uno que genere un PDF a partir de una URL. Podemos extender la clase Uri para conseguirlo:

public static class UriExtensions
{
    public static void SaveAsPdf(this Uri url, string filePath)
    {
        var renderer = new ChromePdfRenderer();;
        var PDF = renderer.RenderUrlAsPdf(url.AbsoluteUri);
        PDF.SaveAs(filePath);
    }
}
public static class UriExtensions
{
    public static void SaveAsPdf(this Uri url, string filePath)
    {
        var renderer = new ChromePdfRenderer();;
        var PDF = renderer.RenderUrlAsPdf(url.AbsoluteUri);
        PDF.SaveAs(filePath);
    }
}
Public Module UriExtensions
	<System.Runtime.CompilerServices.Extension> _
	Public Sub SaveAsPdf(ByVal url As Uri, ByVal filePath As String)
		Dim renderer = New ChromePdfRenderer()
		Dim PDF = renderer.RenderUrlAsPdf(url.AbsoluteUri)
		PDF.SaveAs(filePath)
	End Sub
End Module
VB   C#

Ahora, podemos generar fácilmente un PDF a partir de una URL como ésta:

Uri url = new Uri("https://www.ironpdf.com/");
url.SaveAsPdf("UrlToPdf.PDF");
Uri url = new Uri("https://www.ironpdf.com/");
url.SaveAsPdf("UrlToPdf.PDF");
Dim url As New Uri("https://www.ironpdf.com/")
url.SaveAsPdf("UrlToPdf.PDF")
VB   C#

Métodos de extensión de C# (Cómo funciona para los desarrolladores) Figura 1

Conclusión

En este tutorial, exploramos el concepto de métodos de extensión en C#, aprendimos a implementarlos utilizando métodos estáticos y clases estáticas, y vimos ejemplos reales para varios tipos. Además, presentamos IronPDF, una biblioteca para generar y trabajar con archivos PDF en C#. Combinando la potencia de los métodos de extensión y IronPDF, podemos crear una experiencia más intuitiva y fluida al trabajar con archivos PDF en proyectos C#.

Vale la pena mencionar que IronPDF ofrece un prueba gratuita para que pueda evaluar sus características y capacidades sin ningún compromiso. Si decide que IronPDF es la solución adecuada para su proyecto, la licencia comienza a partir de $749,

Tenga en cuenta las directrices y limitaciones de los métodos de extensión cuando los incorpore a sus proyectos. A medida que empiece a utilizar los métodos de extensión y IronPDF juntos, verá cómo su código puede llegar a ser mucho más limpio, legible y eficiente.

< ANTERIOR
Try/Catch en C# (Cómo funciona para desarrolladores)
SIGUIENTE >
Uso de C# (Cómo funciona para desarrolladores)

¿Listo para empezar? Versión: 2024.6 recién publicada

Comenzar prueba gratuita Descargas totales: 9,541,998
Ver licencias >