1. IronPDF
  2. IronPDF Blog
  3. aide .NET
  4. Params C#
AIDE .NET

Params C# (Comment ça marche pour les développeurs)

Publié mars 26, 2024
Partager:

Le mot-clé params en C# est une fonctionnalité puissante de .NET qui permet à une méthode d'accepter un nombre variable d'arguments. Cela peut simplifier considérablement la syntaxe lors de l'appel de méthodes nécessitant un nombre variable de paramètres. Dans ce guide complet, nous allons explorer le mot-clé params en C#, sa syntaxe, ses cas d'utilisation et ses meilleures pratiques. Dans la suite de cet article, nous présenterons leIronPDF bibliothèque deIron Software et expliquer comment utiliser le mot-clé params et IronPDF pour générer des PDF.

Qu'est-ce que le type d'argument C# ; Params ?

Dans le domaine du C#, les méthodes respectent généralement un ensemble prédéterminé de paramètres. Néanmoins, il existe des situations où l'on peut se trouver dans l'incertitude quant au nombre précis d'arguments destinés à une méthode. Le mot-clé "params" est une solution qui permet de spécifier un paramètre de méthode capable d'accueillir un tableau d'arguments. Cette fonctionnalité s'avère précieuse lorsque le développeur n'est pas sûr du nombre exact d'arguments à l'avance, facilitant le passage d'un nombre indéterminé ou optionnel de paramètres, tous du même type, au sein d'une déclaration de méthode.

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#

la méthode "AddItemsToShoppingBasket" peut être invoquée avec un nombre variable d'arguments de type chaîne de caractères. Le mot-clé objet params simplifie la syntaxe de l'appel de méthode en permettant aux développeurs de passer les paramètres optionnels directement, sans créer explicitement un tableau d'entrée.

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#

Considérations et bonnes pratiques

Positionner le paramètre params à la fin de la liste des paramètres : Il est recommandé de placer le paramètre params à la fin de la liste des paramètres de la méthode. Cette pratique favorise la clarté et permet d'éviter toute confusion lors de l'appel d'une méthode. Les paramètres nécessitant des valeurs explicites doivent précéder les params pour une organisation efficace.

Spécifier explicitement les paramètres non paramétrés : Lors de l'invocation d'une méthode avec des paramètres, veiller à fournir explicitement des valeurs pour les paramètres non paramétriques. Cette pratique permet d'éviter toute ambiguïté et garantit l'invocation exacte de la méthode avec le nombre d'arguments requis.

Faites preuve de prudence pour éviter toute ambiguïté : La vigilance est de mise lors de l'utilisation de params dans des méthodes ayant plusieurs surcharges ou des paramètres du même type. Le compilateur peut avoir du mal à déterminer la méthode appropriée à invoquer, ce qui peut entraîner des erreurs d'ambiguïté.

Explorer d'autres approches : Bien que les paramètres soient pratiques, il convient d'envisager d'autres méthodes dans certains cas. En utilisant des collections telles que Listpeut être préférable pour améliorer les fonctionnalités ou lorsque le passage de paramètres nommés correspond à vos objectifs.

Appliquer judicieusement aux scénarios pertinents : Déployer judicieusement les params dans les scénarios où le nombre de paramètres est variable et peut fluctuer d'un appel de méthode à l'autre. Réserver son utilisation aux situations où le nombre de paramètres est imprévisible, en évitant de l'appliquer lorsque le nombre de paramètres est fixe et connu.

Tableau unidimensionnel pour le type de paramètre

AddItemsToShoppingBasket peut également être utilisé en appelant un tableau à une dimension.

// 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#

Passer un tableau d'arguments de même type séparés par des virgules

AddItemsToShoppingBasket peut également être appelé en passant une liste/un tableau de variables dans l'appel de la méthode, comme ci-dessous.

// 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#

Transmettre un tableau du type défini

Le tableau doit contenir le même type que celui défini dans la méthode params, sinon l'erreur suivante est générée

// 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#

Erreur de syntaxe car il y a une incompatibilité de type avec les paramètres définis dans la méthode.

Toujours le dernier paramètre de la méthode

Aucun paramètre supplémentaire n'est autorisé après le paramètre params dans une déclaration de signature de méthode, et un seul argument params est autorisé dans une déclaration de paramètres de méthode.

La signature de la méthode doit comporter des paramètres définis à la fin, aucun paramètre n'étant autorisé après. Définir ainsi conduit à des erreurs de compilation.

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#

Un seul mot-clé params

Un seul paramètre params est autorisé dans la signature d'une méthode. Le compilateur lance une erreur si plus d'un mot-clé params est trouvé dans la signature de la méthode.

//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#

Vous pouvez ne passer aucun argument

Si une méthode n'a qu'un paramètre avec le mot-clé params, elle peut être appelée sans aucun argument comme ci-dessous et le compilateur ne lancera pas d'erreur.

AddItemsToShoppingBasket(); // Works
AddItemsToShoppingBasket(); // Works
AddItemsToShoppingBasket() ' Works
VB   C#

Pour tout paramètre avec params, l'argument est considéré comme un paramètre optionnel et peut être appelé sans passer de paramètres.

Exemple de code

Créez une nouvelle application console. Ouvrez Visual Studio, créez un nouveau projet et sélectionnez le type d'application console.

Params C# (Comment ça marche pour les développeurs) : Figure 1 - Création d'une nouvelle application console

Ajoutez maintenant le code ci-dessous.

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#

Sortie

Params C# (Comment ça marche pour les développeurs) : Figure 2 - Sortie du code ci-dessus

Présentation de IronPDF

La bibliothèque PDF IronPDF C# d'Iron Software est une bibliothèque polyvalente qui permet de lire, d'écrire et de gérer des documents PDF en C#. Il prend en charge tous les types de développement d'applications modernes comme les applications mobiles, les sites Web, les ordinateurs de bureau, Docker, etc. Il prend également en charge différents systèmes d'exploitation tels que Windows, Linux, Unix, etc. Il ne dépend pas des méthodes natives du système d'exploitation.

Installation

La bibliothèque IronPDF peut être installée à l'aide du fichierNuGet avec la commande ci-dessous ou en utilisant le gestionnaire de paquets 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#

Utilisation d'IronPDF pour générer un PDF

Nous allons maintenant utiliser IronPDF pour générer le document PDF à partir de l'exemple ci-dessus.

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#

Dans le code ci-dessus, nous générons un document HTML pour les articles du panier, puis nous l'enregistrons en tant que document PDF à l'aide de la commandeIronPDF.

Sortie

Params C# (Comment ça marche pour les développeurs) : Figure 3 - Sortie PDF du code ci-dessus

Licence (essai gratuit disponible)

IronPDF nécessite une clé de licence pour fonctionner en production. Une clé d'essai peut être obtenue à partir de la page de licenceici. Placez la clé dans 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#

Indiquez votre adresse e-mail pour recevoir une licence d'essai à votre adresse e-mail.

Conclusion

Le mot-clé params en C# avec .NET 8 offre un moyen flexible de gérer les méthodes qui requièrent un nombre variable de paramètres. Il simplifie les appels de méthodes et rend le code plus lisible et plus facile à maintenir. Ensemble avecIronPDFil s'agit d'une excellente combinaison de compétences pour tout programmeur qui souhaite écrire un code propre.

< PRÉCÉDENT
C# PostgreSQL (Comment ça marche pour les développeurs)
SUIVANT >
Enums C# (Comment ça marche pour les développeurs)

Signaler un problème

Prêt à commencer ? Version : 2024.12 vient de paraître

Téléchargement gratuit de NuGet Nombre total de téléchargements : 11,622,374 Voir les licences > ;