C# Params (Cómo funciona para los desarrolladores)

La palabra clave params en C# es una potente característica de .NET que permite que un método acepte un número variable de argumentos. Esto puede simplificar significativamente la sintaxis al llamar a métodos que requieren un número variable de parámetros. En esta completa guía, exploraremos la palabra clave params en C#, su sintaxis, casos de uso y mejores prácticas. Más adelante en este artículo, presentaremos la IronPDF biblioteca de Iron Software y explicará cómo utilizar la palabra clave params y IronPDFpara generar archivos PDF.

¿Qué es el tipo de argumento C# Params?

En el ámbito de C#, los métodos suelen ajustarse a un conjunto predeterminado de parámetros. Sin embargo, existen situaciones en las que uno puede no estar seguro del número exacto de argumentos destinados a un método. Aparece la palabra clave "params", una solución que permite especificar un parámetro de método capaz de alojar una matriz de argumentos. Esta funcionalidad resulta inestimable cuando el desarrollador no está seguro de antemano del número exacto de argumentos, 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
{
    public void PrintMessages(params string [] messages)
    {
        foreach (var message in messages)
        {
            Console.WriteLine(message);
        }
    }
}
//  Utilización
class Program {
public static void main(){
var example = new ParamsExample();
example.PrintMessages("Hello", "World", "!");
}
//  más ejemplos
public static void AddItemsToShoppingBasket(params string [] items)
{
  //  ....
}
public static void AddItemsSumToShoppingBasket(params int [] sum) //  params int
{
  //  ....
}

public class ParamsExample
{
    public void PrintMessages(params string [] messages)
    {
        foreach (var message in messages)
        {
            Console.WriteLine(message);
        }
    }
}
//  Utilización
class Program {
public static void main(){
var example = new ParamsExample();
example.PrintMessages("Hello", "World", "!");
}
//  más ejemplos
public static void AddItemsToShoppingBasket(params string [] items)
{
  //  ....
}
public static void AddItemsSumToShoppingBasket(params int [] sum) //  params int
{
  //  ....
}

Public Class ParamsExample
	Public Sub PrintMessages(ParamArray ByVal messages() As String)
		For Each message In messages
			Console.WriteLine(message)
		Next message
	End Sub
End Class
'  Utilización
Friend Class Program
Public Shared Sub main()
Dim example = New ParamsExample()
example.PrintMessages("Hello", "World", "!")
End Sub
'  más ejemplos
Public Shared Sub AddItemsToShoppingBasket(ParamArray ByVal items() As String)
  '  ....
End Sub
Public Shared Sub AddItemsSumToShoppingBasket(ParamArray ByVal sum() As Integer) '  params int
  '  ....
End Sub

El método "AddItemsToShoppingBasket" puede invocarse con un número variable de argumentos de parámetros de cadena. La palabra clave de objeto params simplifica la sintaxis de la llamada al método al permitir a los desarrolladores pasar los parámetros opcionales directamente, sin crear explícitamente una entrada de matriz.

class Program {
AddItemsToShoppingBasket("cake", "pizza", "cold drink");
AddItemsToShoppingBasket("snacks", "burger");
AddItemsToShoppingBasket(); //  Válido con cero parámetros valor por defecto
}

class Program {
AddItemsToShoppingBasket("cake", "pizza", "cold drink");
AddItemsToShoppingBasket("snacks", "burger");
AddItemsToShoppingBasket(); //  Válido con cero parámetros valor por defecto
}

Friend Class Program
AddItemsToShoppingBasket("cake", "pizza", "cold drink")
AddItemsToShoppingBasket("snacks", "burger")
AddItemsToShoppingBasket() '  Válido con cero parámetros valor por defecto
End Class

Consideraciones y buenas prácticas

Posicionar Params al final de la lista de parámetros: Una práctica recomendada es situar el parámetro params al final de la lista de parámetros del método. Esta práctica fomenta la claridad, mitigando la confusión durante las llamadas a métodos. Los parámetros que requieren valores explícitos deben preceder a los parámetros para una organización eficaz.

Especifique explícitamente los parámetros que no son parámetros: Al invocar un método con parámetros, asegúrese de proporcionar explícitamente los valores de los parámetros que no son parámetros. Esta práctica evita la ambigüedad y garantiza la invocación precisa del método con el número de argumentos necesario.

Tenga cuidado para evitar ambigüedades: La vigilancia es clave cuando se utilizan parámetros en métodos con múltiples sobrecargas o parámetros del mismo tipo. El compilador puede esforzarse en determinar el método apropiado a invocar, lo que puede dar lugar a errores de ambigüedad.

Explore métodos alternativos: Aunque los parámetros ofrecen comodidad, considere métodos alternativos en determinados escenarios. Utilizando colecciones como Listpuede ser preferible para mejorar la funcionalidad o cuando pasar parámetros con nombre se ajuste a sus objetivos.

Aplicar juiciosamente a escenarios relevantes: Despliegue params juiciosamente en escenarios donde el conteo de parámetros es variable y puede fluctuar a través de distintas llamadas a métodos. Reservar su uso para situaciones en las que el número de parámetros es impredecible, evitando su aplicación cuando el número de parámetros es fijo y conocido.

Matriz unidimensional para el tipo de parámetro

AddItemsToShoppingBasket también se puede utilizar llamando a un array unidimensional.

//  ejemplo
class Program {
public static void main()
{
var items = [] {"cold drink", "snack", "roll", }; //  Matriz de cadenas 1D
AddItemsToShoppingBasket(items); //  funciona
AddItemsToShoppingBasket( "cold drink", "coke", "roll",); //  igual que la línea anterior
}
}

//  ejemplo
class Program {
public static void main()
{
var items = [] {"cold drink", "snack", "roll", }; //  Matriz de cadenas 1D
AddItemsToShoppingBasket(items); //  funciona
AddItemsToShoppingBasket( "cold drink", "coke", "roll",); //  igual que la línea anterior
}
}

'  ejemplo
Friend Class Program
Public Shared Sub main()
Dim items = () {"cold drink", "snack", "roll"} '  Matriz de cadenas 1D
AddItemsToShoppingBasket(items) '  funciona
AddItemsToShoppingBasket("cold drink", "coke", "roll",) '  igual que la línea anterior
End Sub
End Class

Pasar una matriz separada por comas de argumentos del mismo tipo

AddItemsToShoppingBasket también puede ser llamado pasando una lista/array de variables en la llamada al método como se muestra a continuación.

//  ejemplo de firma de método
class Program {
AddItemsToShoppingBasket("snacks", "burger", "snacks", "burger", "cold drink"); //  valores separados por comas
AddItemsToShoppingBasket("snacks"); 
}

//  ejemplo de firma de método
class Program {
AddItemsToShoppingBasket("snacks", "burger", "snacks", "burger", "cold drink"); //  valores separados por comas
AddItemsToShoppingBasket("snacks"); 
}

'  ejemplo de firma de método
Friend Class Program
AddItemsToShoppingBasket("snacks", "burger", "snacks", "burger", "cold drink") '  valores separados por comas
AddItemsToShoppingBasket("snacks")
End Class

Pasar un array del tipo definido

El array debe contener el mismo tipo definido en el método params, de lo contrario se produce un error como el siguiente

//  ejemplo
AddItemsToShoppingBasket("snacks",2,"burger"); //  error 
AddItemsToShoppingBasket(2,3,4); //  error ya que el tipo params es string

//  ejemplo
AddItemsToShoppingBasket("snacks",2,"burger"); //  error 
AddItemsToShoppingBasket(2,3,4); //  error ya que el tipo params es string

'  ejemplo
AddItemsToShoppingBasket("snacks",2,"burger") '  error
AddItemsToShoppingBasket(2,3,4) '  error ya que el tipo params es string

Error de sintaxis ya que hay una falta de coincidencia de tipo de los parámetros definidos en el método.

Siempre el último parámetro del método

No se permiten parámetros adicionales después del parámetro params en una declaración de firma de método, y sólo se permite un argumento params en una declaración de parámetros de método.

La firma del método debe tener los parámetros definidos al final, no se permiten parámetros después. Si se define así, se producen errores de compilación.

class program {
static void Main(string [] args){
//  ejemplo 1
   public static void AddItemsToShoppingBasket(double total, params string [] items)
   {
     //  ....
   } //  Esto funciona
}
}
example 2
static void Main(string [] args){
   public static void AddItemsToShoppingBasket(double total, int total, params string [] items)
   {
     //  ....
   } //  Esto funciona
}
//  ejemplo 3 escenario de error
static void Main(string [] args){
   public static void AddItemsToShoppingBasket(params string [] items, decimal total, int total)
   {
     //  error
   } //  La palabra clave params se define como primer parámetro, debe estar en el último.
}

class program {
static void Main(string [] args){
//  ejemplo 1
   public static void AddItemsToShoppingBasket(double total, params string [] items)
   {
     //  ....
   } //  Esto funciona
}
}
example 2
static void Main(string [] args){
   public static void AddItemsToShoppingBasket(double total, int total, params string [] items)
   {
     //  ....
   } //  Esto funciona
}
//  ejemplo 3 escenario de error
static void Main(string [] args){
   public static void AddItemsToShoppingBasket(params string [] items, decimal total, int total)
   {
     //  error
   } //  La palabra clave params se define como primer parámetro, debe estar en el último.
}

Friend Class program
Shared Sub Main(ByVal args() As String)
'  ejemplo 1
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'   public static void AddItemsToShoppingBasket(double total, params string [] items)
'   {
'	 '  ....
'   } '  Esto funciona
End Sub
End Class
example 2 Shared Sub Main(ByVal args() As String)
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'   public static void AddItemsToShoppingBasket(double total, int total, params string [] items)
'   {
'	 '  ....
'   } '  Esto funciona
End Sub
'  ejemplo 3 escenario de error
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, decimal total, int total)
'   {
'	 '  error
'   } '  La palabra clave params se define como primer parámetro, debe estar en el último.
End Sub

Sólo una palabra clave params

Sólo se permite un parámetro params en la firma de un método. El compilador lanza un error si se encuentra más de una palabra clave params en la firma del método.

//sólo una palabra clave params ejemplo
class Program {
static void Main(string [] args){
public static void AddItemsToShoppingBasket(params string [] items, params string [] quantity)
{
} //  Error del compilador, Esto no funciona. 
}
}

//sólo una palabra clave params ejemplo
class Program {
static void Main(string [] args){
public static void AddItemsToShoppingBasket(params string [] items, params string [] quantity)
{
} //  Error del compilador, Esto no funciona. 
}
}

'sólo una palabra clave params ejemplo
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)
'{
'} '  Error del compilador, Esto no funciona.
End Sub
End Class

No puede pasar ningún argumento

Si un método sólo tiene parámetros con la palabra clave params entonces puede ser llamado sin ningún argumento como el de abajo y el compilador no arrojará un error.

AddItemsToShoppingBasket(); //  Obras

AddItemsToShoppingBasket(); //  Obras

AddItemsToShoppingBasket() '  Obras

Para cualquier parámetro con argumento params se considera un parámetro opcional y puede ser llamado sin pasar parámetros.

Ejemplo de código

Cree una nueva aplicación de consola. Abra Visual Studio, cree un nuevo proyecto y seleccione el tipo de aplicación de consola.

Ahora añade el siguiente código.

class Program {
Console.WriteLine("Params demo");
List<string> cart = new List<string>();
void AddItemsToShoppingBasket(params string [] samples)
{
    for (int i = 0; i < samples.Length; i++)
    {
        cart.Add(samples [i]);
    }
}
//  código de llamada
static void Main(string [] args) {
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);
}
}
}

class Program {
Console.WriteLine("Params demo");
List<string> cart = new List<string>();
void AddItemsToShoppingBasket(params string [] samples)
{
    for (int i = 0; i < samples.Length; i++)
    {
        cart.Add(samples [i]);
    }
}
//  código de llamada
static void Main(string [] args) {
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);
}
}
}

Friend Class Program
Console.WriteLine("Params demo")
Dim cart As New List(Of String)()
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'void AddItemsToShoppingBasket(params string [] samples)
'{
'	for (int i = 0; i < samples.Length; i++)
'	{
'		cart.Add(samples [i]);
'	}
'}
'  código de llamada
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'static void Main(string [] args)
'{
'Console.WriteLine("Enter the cart items as comma separated values");
'var itemsString = Console.ReadLine();
'if (itemsString != Nothing)
'{
'	var items = itemsString.Split(",").ToArray();
'	AddItemsToShoppingBasket(items);
'}
'AddItemsToShoppingBasket("Sample1", "Sample2");
'Console.WriteLine("-------------------------------------------------------");
'Console.WriteLine("Display Cart");
'foreach (var item in cart)
'{
'	Console.WriteLine(item);
'}
'}
End Class

Salida

Presentación de IronPDF

IronPDF C# PDF library de Iron Softwarees una biblioteca versátil que puede leer, escribir y gestionar documentos PDF en C#. Soporta todo tipo de desarrollo de aplicaciones modernas como Mobile, Website, Desktop, Docker, etc. Y también es compatible con diferentes sistemas operativos como Windows, Linux, Unix, etc. No depende de los métodos nativos del sistema operativo.

Instalación

La biblioteca IronPDF puede instalarse utilizando el comando NuGet con el siguiente comando o utilizando el gestor de paquetes de Visual Studio.

dotnet add package IronPdf

dotnet add package IronPdf

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'dotnet add package IronPdf

Uso de IronPDF para generar un PDF

Ahora utilizaremos IronPDF para generar el documento PDF del ejemplo anterior.

class program
{
public static void main()
{
Console.WriteLine("IronPDF to generate the PDF document for Params Example");
List<string> cart = new List<string>();
void AddItemsToShoppingBasket(params string [] items)
{
    for (int i = 0; i < items.Length; i++)
    {
        cart.Add(items [i]);
    }
}
//  tomar datos de la consola
Console.WriteLine("Enter the cart items as comma seperated values");
var itemsString = Console.ReadLine();
//  leer los artículos
if (itemsString != null)
{
    var items = itemsString.Split(",").ToArray();
    AddItemsToShoppingBasket(items);
}
//  añadir a la cesta
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>";
//  Crear un nuevo documento PDF
var pdfDoc = new ChromePdfRenderer();
pdfDoc.RenderHtmlAsPdf(content).SaveAs("cart.pdf");
}
}

class program
{
public static void main()
{
Console.WriteLine("IronPDF to generate the PDF document for Params Example");
List<string> cart = new List<string>();
void AddItemsToShoppingBasket(params string [] items)
{
    for (int i = 0; i < items.Length; i++)
    {
        cart.Add(items [i]);
    }
}
//  tomar datos de la consola
Console.WriteLine("Enter the cart items as comma seperated values");
var itemsString = Console.ReadLine();
//  leer los artículos
if (itemsString != null)
{
    var items = itemsString.Split(",").ToArray();
    AddItemsToShoppingBasket(items);
}
//  añadir a la cesta
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>";
//  Crear un nuevo documento PDF
var pdfDoc = new ChromePdfRenderer();
pdfDoc.RenderHtmlAsPdf(content).SaveAs("cart.pdf");
}
}

Imports Microsoft.VisualBasic

Friend Class program
Public Shared Sub main()
Console.WriteLine("IronPDF to generate the PDF document for Params Example")
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]);
'	}
'}
'  tomar datos de la consola
Console.WriteLine("Enter the cart items as comma seperated values")
Dim itemsString = Console.ReadLine()
'  leer los artículos
If itemsString IsNot Nothing Then
	Dim items = itemsString.Split(",").ToArray()
	AddItemsToShoppingBasket(items)
End If
'  añadir a la cesta
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>"
'  Crear un nuevo documento PDF
Dim pdfDoc = New ChromePdfRenderer()
pdfDoc.RenderHtmlAsPdf(content).SaveAs("cart.pdf")
End Sub
End Class

En el código anterior, estamos generando un documento HTML para los artículos del carrito y luego lo guardamos como un documento PDF utilizando IronPDF.

Salida

Licencias (prueba gratuita disponible)

IronPDF requiere una clave de licencia para funcionar en producción. Se puede obtener una clave de prueba en la página de licencias aquí. Coloca la clave en appsettings.json.

"IronPdf.LicenseKey": "your license key"

"IronPdf.LicenseKey": "your license key"

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'"IronPdf.LicenseKey": "your license key"

Indique su dirección de correo electrónico para recibir una licencia de prueba.

Conclusión

La palabra clave params en C# con .NET 8 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 fácil de mantener. Junto con IronPDF es una gran combinación de habilidades para que cualquier programador escriba código limpio.