El params es una característica poderosa de C# en .NET que permite a un método aceptar un número variable de argumentos. Esto puede simplificar significativamente la sintaxis al llamar métodos que requieren un número variable de parámetros. En esta guía integral, exploraremos el params en C#, su sintaxis, casos de uso y mejores prácticas. Más adelante en este artículo, presentaremos la biblioteca IronPDF de Iron Software y explicaremos cómo usar el params y IronPDF para generar PDFs.
En el ámbito de C#, los métodos generalmente se adhieren a un conjunto predeterminado de parámetros. No obstante, existen situaciones donde uno podría encontrarse inseguro sobre el número preciso de argumentos destinados a un método. Aquí entra la palabra clave "params", una solución que permite la especificación de un parámetro de método capaz de acomodar un arreglo de argumentos. Esta funcionalidad resulta invaluable cuando el desarrollador no está seguro sobre el número exacto de argumentos de antemano, facilitando el paso de un número indeterminado u opcional de parámetros, todos del mismo tipo, dentro de una declaración de método.
public class ParamsExample
{
// Method accepting a variable number of string arguments using the params keyword
public void PrintMessages(params string[] messages)
{
foreach (var message in messages)
{
Console.WriteLine(message);
}
}
}
// Usage
class Program
{
public static void Main()
{
var example = new ParamsExample();
example.PrintMessages("Hello", "World", "!");
}
// More examples
public static void AddItemsToShoppingBasket(params string[] items)
{
// Implementation to add items to a shopping basket
}
public static void AddItemsSumToShoppingBasket(params int[] sum) // Using params with int
{
// Implementation to add sum of items to the shopping basket
}
}Public Class ParamsExample
' Method accepting a variable number of string arguments using the params keyword
Public Sub PrintMessages(ParamArray ByVal messages() As String)
For Each message In messages
Console.WriteLine(message)
Next message
End Sub
End Class
' Usage
Friend Class Program
Public Shared Sub Main()
Dim example = New ParamsExample()
example.PrintMessages("Hello", "World", "!")
End Sub
' More examples
Public Shared Sub AddItemsToShoppingBasket(ParamArray ByVal items() As String)
' Implementation to add items to a shopping basket
End Sub
Public Shared Sub AddItemsSumToShoppingBasket(ParamArray ByVal sum() As Integer) ' Using params with int
' Implementation to add sum of items to the shopping basket
End Sub
End ClassEl método AddItemsToShoppingBasket se puede invocar con un número variable de argumentos de parámetros string. El params simplifica la sintaxis para la llamada al método al permitir que los desarrolladores pasen los parámetros opcionales directamente, sin crear explícitamente una entrada de matriz.
class Program
{
public static void Main()
{
AddItemsToShoppingBasket("cake", "pizza", "cold drink");
AddItemsToShoppingBasket("snacks", "burger");
AddItemsToShoppingBasket(); // Valid even with zero parameters, using default value
}
}Friend Class Program
Public Shared Sub Main()
AddItemsToShoppingBasket("cake", "pizza", "cold drink")
AddItemsToShoppingBasket("snacks", "burger")
AddItemsToShoppingBasket() ' Valid even with zero parameters, using default value
End Sub
End ClassColocar los parámetros al final de la lista de parámetros: Se recomienda colocar el parámetro params al final de la lista de parámetros del método. Esta práctica fomenta la claridad y reduce la confusión durante las llamadas a métodos. Los parámetros que requieren valores explícitos deben preceder a los params para una organización efectiva.
Especifique explícitamente los parámetros que no son params: Al invocar un método con params, asegúrese de que se proporcionen explícitamente valores para los parámetros que no son params. Esta práctica previene ambigüedades y garantiza la invocación precisa del método con el número requerido de argumentos.
Ejercite la precaución para prevenir la ambigüedad: La vigilancia es clave cuando se utiliza params en métodos con múltiples sobrecargas o parámetros del mismo tipo. El compilador puede tener dificultades para determinar el método apropiado a invocar, resultando potencialmente en errores de ambigüedad.
Explore enfoques alternativos: Aunque params ofrece conveniencia, considere métodos alternativos en ciertos escenarios. Utilizar colecciones como List<t> podría ser preferible para una funcionalidad mejorada o cuando pasar parámetros nombrados se alinea con sus objetivos.
Aplique con juicio en escenarios relevantes: Despliegue params juiciosamente en escenarios donde la cantidad de parámetros es variable y puede fluctuar entre distintas llamadas al método. Reservar su uso para situaciones donde el número de parámetros es impredecible, evitando su aplicación cuando el recuento de parámetros es fijo y conocido.
AddItemsToShoppingBasket también puede ser usado llamándolo con una matriz unidimensional.
class Program
{
public static void Main()
{
var items = new string[] { "cold drink", "snack", "roll" }; // 1D string array
AddItemsToShoppingBasket(items); // Works as expected
AddItemsToShoppingBasket("cold drink", "coke", "roll"); // Similar result to the above line
}
}Friend Class Program
Public Shared Sub Main()
Dim items = New String() { "cold drink", "snack", "roll" } ' 1D string array
AddItemsToShoppingBasket(items) ' Works as expected
AddItemsToShoppingBasket("cold drink", "coke", "roll") ' Similar result to the above line
End Sub
End ClassAddItemsToShoppingBasket puede ser llamado pasando una lista/matriz de variables en la llamada al método de la siguiente manera.
class Program
{
public static void Main()
{
// Example method signature
AddItemsToShoppingBasket("snacks", "burger", "snacks", "burger", "cold drink"); // Comma separated values
AddItemsToShoppingBasket("snacks");
}
}Friend Class Program
Public Shared Sub Main()
' Example method signature
AddItemsToShoppingBasket("snacks", "burger", "snacks", "burger", "cold drink") ' Comma separated values
AddItemsToShoppingBasket("snacks")
End Sub
End ClassEl arreglo debe contener el mismo tipo definido en el método params; de lo contrario, se lanza un error.
// Example that results in an error
AddItemsToShoppingBasket("snacks", 2, "burger"); // Error due to type mismatch
AddItemsToShoppingBasket(2, 3, 4); // Error since params type is string' Example that results in an error
AddItemsToShoppingBasket("snacks", 2, "burger") ' Error due to type mismatch
AddItemsToShoppingBasket(2, 3, 4) ' Error since params type is stringOcurre un error de sintaxis si hay una incompatibilidad de tipo en el params definido en el método.
No se permiten parámetros adicionales después del parámetro params en una firma de método. Solo se permite un argumento params en una declaración de parámetros de método. Definirlo incorrectamente conduce a errores de compilación.
class Program
{
static void Main(string[] args)
{
// Example 1
public static void AddItemsToShoppingBasket(double total, params string[] items)
{
// Works fine as `params` is the last parameter
}
// Example 2, error scenario
public static void AddItemsToShoppingBasket(params string[] items, decimal total, int total)
{
// Error: `params` keyword must be the last parameter
}
}
}Module Program
Sub Main(args As String())
' Example 1
Public Sub AddItemsToShoppingBasket(total As Double, ParamArray items As String())
' Works fine as `ParamArray` is the last parameter
End Sub
' Example 2, error scenario
' Public Sub AddItemsToShoppingBasket(ParamArray items As String(), total As Decimal, total As Integer)
' Error: `ParamArray` keyword must be the last parameter
' End Sub
End Sub
End ModuleparamsSolo se permite un parámetro params en una firma de método. El compilador arroja un error si se encuentra más de una palabra clave params en la firma del método.
class Program
{
static void Main(string[] args)
{
public static void AddItemsToShoppingBasket(params string[] items, params string[] quantity)
{
// Compiler Error: Only one params keyword is allowed in the method signature
}
}
}Friend Class Program
Shared Sub Main(ByVal args() As String)
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
' public static void AddItemsToShoppingBasket(params string[] items, params string[] quantity)
' {
' ' Compiler Error: Only one params keyword is allowed in the method signature
' }
End Sub
End ClassSi un método tiene un parámetro con la palabra clave params, puede ser llamado sin argumentos y el compilador no arrojará un error.
AddItemsToShoppingBasket(); // Works as expectedAddItemsToShoppingBasket() ' Works as expectedPara cualquier parámetro con un argumento params, se considera un parámetro opcional y puede ser invocado sin pasar parámetros.
Crea una nueva aplicación de consola. Abre Visual Studio, crea un nuevo proyecto y selecciona el tipo de aplicación de consola.
Ahora añade el siguiente código.
using System;
using System.Collections.Generic;
class Program
{
static void Main(string[] args)
{
List<string> cart = new List<string>();
void AddItemsToShoppingBasket(params string[] samples)
{
for (int i = 0; i < samples.Length; i++)
{
cart.Add(samples[i]);
}
}
// Caller code
Console.WriteLine("Enter the cart items as comma separated values");
var itemsString = Console.ReadLine();
if (itemsString != null)
{
var items = itemsString.Split(",").ToArray();
AddItemsToShoppingBasket(items);
}
AddItemsToShoppingBasket("Sample1", "Sample2");
Console.WriteLine("-------------------------------------------------------");
Console.WriteLine("Display Cart");
foreach (var item in cart)
{
Console.WriteLine(item);
}
}
}Imports System
Imports System.Collections.Generic
Module Program
Sub Main(args As String())
Dim cart As New List(Of String)()
Sub AddItemsToShoppingBasket(ParamArray samples As String())
For i As Integer = 0 To samples.Length - 1
cart.Add(samples(i))
Next
End Sub
' Caller code
Console.WriteLine("Enter the cart items as comma separated values")
Dim itemsString = Console.ReadLine()
If itemsString IsNot Nothing Then
Dim items = itemsString.Split(","c)
AddItemsToShoppingBasket(items)
End If
AddItemsToShoppingBasket("Sample1", "Sample2")
Console.WriteLine("-------------------------------------------------------")
Console.WriteLine("Display Cart")
For Each item In cart
Console.WriteLine(item)
Next
End Sub
End Module
La biblioteca IronPDF C# PDF de Iron Software es una biblioteca versátil que puede leer, escribir y manejar documentos PDF en C#. Soporta todo tipo de desarrollo de aplicaciones modernas como Móvil, Sitio Web, Escritorio, Docker, etc. Y también soporta diferentes sistemas operativos como Windows, Linux, Unix, etc. No depende de métodos nativos de SO.
IronPDF se destaca en la conversión de HTML a PDF, asegurando la preservación precisa de los diseños y estilos originales. Es perfecto para crear PDFs a partir de contenido basado en la web como informes, facturas y documentación. Con soporte para archivos HTML, URLs y cadenas HTML en bruto, IronPDF produce fácilmente documentos PDF de alta calidad.
using IronPdf;
class Program
{
static void Main(string[] args)
{
var renderer = new ChromePdfRenderer();
// 1. Convert HTML String to 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. Convert HTML File to PDF
var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");
// 3. Convert URL to PDF
var url = "http://ironpdf.com"; // Specify the 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. Convert HTML String to 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. Convert HTML File to PDF
Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")
' 3. Convert URL to PDF
Dim url = "http://ironpdf.com" ' Specify the URL
Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
pdfFromUrl.SaveAs("URLToPDF.pdf")
End Sub
End ClassLa biblioteca IronPDF se puede instalar usando el gestor de paquetes NuGet con el siguiente comando o usando el gestor de paquetes de Visual Studio.
Ahora usaremos IronPDF para generar el documento PDF desde el ejemplo anterior.
using System;
using System.Collections.Generic;
using System.Linq;
using IronPdf;
class Program
{
public static void Main()
{
List<string> cart = new List<string>();
void AddItemsToShoppingBasket(params string[] items)
{
for (int i = 0; i < items.Length; i++)
{
cart.Add(items[i]);
}
}
// Take input from console
Console.WriteLine("Enter the cart items as comma separated values");
var itemsString = Console.ReadLine();
// Read the items
if (itemsString != null)
{
var items = itemsString.Split(",").ToArray();
AddItemsToShoppingBasket(items);
}
// Add to cart
AddItemsToShoppingBasket("Sample1", "Sample2");
Console.WriteLine("------------------------------------------------");
Console.WriteLine("Display Cart");
Console.WriteLine("------------------------------------------------");
string name = "Sam";
var count = cart.Count;
string content = $@"<!DOCTYPE html>
<html>
<body>
<h1>Hello, {name}!</h1>
<p>You have {count} items in the cart.</p>
" +
string.Join("\n", cart.Select(x => $"<p>{x}</p>"))
+ @"
</body>
</html>";
// Create a new PDF document
var pdfDoc = new ChromePdfRenderer();
pdfDoc.RenderHtmlAsPdf(content).SaveAs("cart.pdf");
}
}Imports Microsoft.VisualBasic
Imports System
Imports System.Collections.Generic
Imports System.Linq
Imports IronPdf
Friend Class Program
Public Shared Sub Main()
Dim cart As New List(Of String)()
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
' void AddItemsToShoppingBasket(params string[] items)
' {
' for (int i = 0; i < items.Length; i++)
' {
' cart.Add(items[i]);
' }
' }
' Take input from console
Console.WriteLine("Enter the cart items as comma separated values")
Dim itemsString = Console.ReadLine()
' Read the items
If itemsString IsNot Nothing Then
Dim items = itemsString.Split(",").ToArray()
AddItemsToShoppingBasket(items)
End If
' Add to cart
AddItemsToShoppingBasket("Sample1", "Sample2")
Console.WriteLine("------------------------------------------------")
Console.WriteLine("Display Cart")
Console.WriteLine("------------------------------------------------")
Dim name As String = "Sam"
Dim count = cart.Count
Dim content As String = $"<!DOCTYPE html>
<html>
<body>
<h1>Hello, {name}!</h1>
<p>You have {count} items in the cart.</p>
" & String.Join(vbLf, cart.Select(Function(x) $"<p>{x}</p>")) & "
</body>
</html>"
' Create a new PDF document
Dim pdfDoc = New ChromePdfRenderer()
pdfDoc.RenderHtmlAsPdf(content).SaveAs("cart.pdf")
End Sub
End ClassEn el código anterior, estamos generando un documento HTML para los ítems del carrito y luego guardándolo como un documento PDF usando IronPDF.
IronPDF requiere una clave de licencia para funcionar en producción. Se puede obtener una clave de prueba desde la página de licencia aquí. Coloca la clave en appsettings.json.
"IronPdf.LicenseKey": "your license key"Proporciona tu correo electrónico para recibir una licencia de prueba.
La palabra clave params en C# ofrece una forma flexible de manejar métodos que requieren un número variable de parámetros. Simplifica las llamadas a métodos y hace que el código sea más legible y mantenible. Junto con IronPDF, es una gran combinación de habilidades para cualquier programador que quiera escribir código limpio.
Jacob Mellor es Director de Tecnología de Iron Software y un ingeniero visionario pionero en la tecnología C# PDF. Como desarrollador original de la base de código principal de Iron Software, ha dado forma a la arquitectura de productos de la empresa desde su creación, transformándola, junto con el director ejecutivo Cameron Rimington, en una empresa de más de 50 personas que presta servicios a la NASA, Tesla y organismos gubernamentales de todo el mundo.
IronPDF es parte de IRONSUITE
10 productos API .NET para tus documentos de oficina
Cuando necesitas que tu PDF se parezca al HTML, rápido.
