AYUDA .NET

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

Actualizado marzo 26, a. m.

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);
        }
    }
}
// Usage
class Program {
public static void main(){
var example = new ParamsExample();
example.PrintMessages("Hello", "World", "!");
}
// more examples
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);
        }
    }
}
// Usage
class Program {
public static void main(){
var example = new ParamsExample();
example.PrintMessages("Hello", "World", "!");
}
// more examples
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
' 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)
  ' ....
End Sub
Public Shared Sub AddItemsSumToShoppingBasket(ParamArray ByVal sum() As Integer) ' params int
  ' ....
End Sub

VB C#

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(); // Valid with zero parameters default value
}

class Program {
AddItemsToShoppingBasket("cake", "pizza", "cold drink");
AddItemsToShoppingBasket("snacks", "burger");
AddItemsToShoppingBasket(); // Valid with zero parameters default value
}

Friend Class Program
AddItemsToShoppingBasket("cake", "pizza", "cold drink")
AddItemsToShoppingBasket("snacks", "burger")
AddItemsToShoppingBasket() ' Valid with zero parameters default value
End Class

VB C#

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.

// example
class Program {
public static void main()
{
var items = [] {"cold drink", "snack", "roll", }; // 1D string array
AddItemsToShoppingBasket(items); // works
AddItemsToShoppingBasket( "cold drink", "coke", "roll",); // same as above line
}
}

// example
class Program {
public static void main()
{
var items = [] {"cold drink", "snack", "roll", }; // 1D string array
AddItemsToShoppingBasket(items); // works
AddItemsToShoppingBasket( "cold drink", "coke", "roll",); // same as above line
}
}

' example
Friend Class Program
Public Shared Sub main()
Dim items = () {"cold drink", "snack", "roll"} ' 1D string array
AddItemsToShoppingBasket(items) ' works
AddItemsToShoppingBasket("cold drink", "coke", "roll",) ' same as above line
End Sub
End Class

VB C#

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.

// example method signature
class Program {
AddItemsToShoppingBasket("snacks", "burger", "snacks", "burger", "cold drink"); // comma separated values
AddItemsToShoppingBasket("snacks"); 
}

// example method signature
class Program {
AddItemsToShoppingBasket("snacks", "burger", "snacks", "burger", "cold drink"); // comma separated values
AddItemsToShoppingBasket("snacks"); 
}

' example method signature
Friend Class Program
AddItemsToShoppingBasket("snacks", "burger", "snacks", "burger", "cold drink") ' comma separated values
AddItemsToShoppingBasket("snacks")
End Class

VB C#

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

// example
AddItemsToShoppingBasket("snacks",2,"burger"); // error 
AddItemsToShoppingBasket(2,3,4); // error as params type is string

// example
AddItemsToShoppingBasket("snacks",2,"burger"); // error 
AddItemsToShoppingBasket(2,3,4); // error as params type is string

' example
AddItemsToShoppingBasket("snacks",2,"burger") ' error
AddItemsToShoppingBasket(2,3,4) ' error as params type is string

VB C#

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){
// example 1
   public static void AddItemsToShoppingBasket(double total, params string [] items)
   {
     // ....
   } // This works
}
}
example 2
static void Main(string [] args){
   public static void AddItemsToShoppingBasket(double total, int total, params string [] items)
   {
     // ....
   } // This works
}
// example 3 error scenario
static void Main(string [] args){
   public static void AddItemsToShoppingBasket(params string [] items, decimal total, int total)
   {
     // error
   } // params keyword is defined as first parameter, needs to be at the last.
}

class program {
static void Main(string [] args){
// example 1
   public static void AddItemsToShoppingBasket(double total, params string [] items)
   {
     // ....
   } // This works
}
}
example 2
static void Main(string [] args){
   public static void AddItemsToShoppingBasket(double total, int total, params string [] items)
   {
     // ....
   } // This works
}
// example 3 error scenario
static void Main(string [] args){
   public static void AddItemsToShoppingBasket(params string [] items, decimal total, int total)
   {
     // error
   } // params keyword is defined as first parameter, needs to be at the last.
}

Friend Class program
Shared Sub Main(ByVal args() As String)
' example 1
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'   public static void AddItemsToShoppingBasket(double total, params string [] items)
'   {
'	 ' ....
'   } ' This works
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)
'   {
'	 ' ....
'   } ' This works
End Sub
' example 3 error scenario
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
'   } ' params keyword is defined as first parameter, needs to be at the last.
End Sub

VB C#

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.

//only one params keyword example
class Program {
static void Main(string [] args){
public static void AddItemsToShoppingBasket(params string [] items, params string [] quantity)
{
} // Compiler error, This does not work. 
}
}

//only one params keyword example
class Program {
static void Main(string [] args){
public static void AddItemsToShoppingBasket(params string [] items, params string [] quantity)
{
} // Compiler error, This does not work. 
}
}

'only one params keyword example
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, This does not work.
End Sub
End Class

VB C#

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(); // Works

AddItemsToShoppingBasket(); // Works

AddItemsToShoppingBasket() ' Works

VB C#

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.

Parámetros C (Cómo funciona para los desarrolladores): Figura 1 - Creación de una nueva 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]);
    }
}
// caller code
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]);
    }
}
// caller code
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]);
'	}
'}
' caller code
'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

VB C#

Salida

Parámetros C (Cómo funciona para los desarrolladores): Figura 2 - Salida del código anterior

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

VB C#

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]);
    }
}
// take input from console
Console.WriteLine("Enter the cart items as comma seperated 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");
}
}

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]);
    }
}
// take input from console
Console.WriteLine("Enter the cart items as comma seperated 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

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]);
'	}
'}
' take input from console
Console.WriteLine("Enter the cart items as comma seperated 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 Class

VB C#

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

Parámetros C# (Cómo funciona para desarrolladores): Figura 3 - Salida PDF del código anterior

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"

VB C#

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 IronPDFes una gran combinación de habilidades para que cualquier programador escriba código limpio.

< ANTERIOR
C# PostgreSQL (Cómo funciona para desarrolladores)

SIGUIENTE >
C# Enums (Cómo funcionan para los desarrolladores)