Pruebas en un entorno real
Pruebe en producción sin marcas de agua.
Funciona donde lo necesites.
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.
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.
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
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
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.
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:
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.
Ahora que ya conocemos los conceptos básicos de los métodos de extensión en C#, veamos algunos ejemplos reales.
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
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.
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
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.
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
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.
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
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.
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
Este fragmento de código crea un PDF con el texto "Hello, World!" y lo guarda en un archivo llamado "HolaMundo.PDF".
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
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")
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
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")
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.
9 productos API .NET para sus documentos de oficina