Le mot-clé params en C# est une fonctionnalité puissante dans .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 qui nécessitent 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 les meilleures pratiques. Plus loin dans cet article, nous allons introduire la bibliothèque IronPDF de Iron Software et expliquer comment utiliser le mot-clé params et IronPDF pour générer des PDF.
Dans le domaine de C#, les méthodes respectent généralement un ensemble prédéfini de paramètres. Néanmoins, il existe des situations où l'on peut se retrouver incertain quant au nombre précis d'arguments destinés à une méthode. C'est là qu'intervient le mot-clé "params", 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 inestimable 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 facultatif de paramètres, tous du même type, dans une déclaration de méthode.
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 ClassLa méthode AddItemsToShoppingBasket peut être invoquée avec un nombre variable d'arguments de paramètres string. Le mot-clé params simplifie la syntaxe pour l'appel de méthode en permettant aux développeurs de passer directement les paramètres optionnels, sans créer explicitement un tableau d'entrée.
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 ClassPlacer le paramètre params en fin de liste : Il est recommandé de placer ce paramètre à la fin de la liste des paramètres de la méthode. Cette pratique favorise la clarté et réduit les risques de confusion lors des appels de méthode. Les paramètres nécessitant des valeurs explicites doivent précéder les params pour une organisation efficace.
Spécifiez explicitement les paramètres non-params : Lors de l'invocation d'une méthode avec params, assurez-vous de fournir explicitement les valeurs pour les paramètres non-params. Cette pratique évite l'ambiguïté et garantit l'appel précis de la méthode avec le nombre d'arguments requis.
Faites preuve de prudence pour éviter les ambiguïtés : La vigilance est essentielle lors de l'utilisation de params dans des méthodes avec plusieurs surcharges ou 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é.
Explorez des approches alternatives : Bien que params offre de la commodité, envisagez des méthodes alternatives dans certains scénarios. Utiliser des collections comme List<t> pourrait être préférable pour une fonctionnalité améliorée ou lorsque le passage de paramètres nommés s'aligne avec vos objectifs.
Appliquez judicieusement à des scénarios pertinents : Déployez params judicieusement dans des scénarios où le nombre de paramètres est variable et peut fluctuer entre différents appels de méthode. Réservez son utilisation pour les situations où le nombre de paramètres est imprévisible, en évitant son application lorsque le nombre de paramètres est fixe et connu.
AddItemsToShoppingBasket peut également être utilisé en l'appelant avec un tableau unidimensionnel.
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 peut être appelé en passant une liste/un tableau de variables dans l'appel de méthode comme ci-dessous.
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 ClassLe tableau doit contenir le même type défini dans la méthode params; sinon, une erreur est générée.
// 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 stringUne erreur de syntaxe se produit s'il y a une incompatibilité de type par rapport à la params définie dans la méthode.
Aucun paramètre supplémentaire n'est autorisé après le paramètre params dans la signature d'une méthode. Un seul argument params est permis dans une déclaration de paramètres de méthode. Le définir incorrectement entraîne des erreurs de compilation.
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 ModuleparamsUn seul paramètre params dans une signature de méthode est autorisé. Le compilateur génère une erreur si plus d'un mot-clé params est trouvé dans la signature de la méthode.
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 une méthode a un paramètre avec le mot-clé params, elle peut être appelée sans aucun argument et le compilateur ne générera pas d'erreur.
AddItemsToShoppingBasket(); // Works as expectedAddItemsToShoppingBasket() ' Works as expectedPour tout paramètre avec un argument params, il est considéré comme un paramètre optionnel et peut être invoqué sans passer de paramètres.
Créez une nouvelle Application Console. Ouvrez Visual Studio, créez un nouveau projet et sélectionnez le type d'application console.
Ajoutez maintenant le code ci-dessous.
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 bibliothèque PDF C# IronPDF d'Iron Software est une bibliothèque polyvalente qui peut lire, écrire et gérer des documents PDF en C#. Elle prend en charge toutes sortes de développements d'applications modernes comme Mobile, Site Web, Bureau, Docker, etc. Et prend également en charge différents systèmes d'exploitation tels que Windows, Linux, Unix, etc. Elle ne dépend pas des méthodes natives de l'OS.
IronPDF excelle dans la conversion HTML en PDF, garantissant une préservation précise des mises en page et styles originaux. Il est parfait pour créer des PDF à partir de contenus basés sur le Web tels que des rapports, des factures et de la documentation. Avec le support des fichiers HTML, des URLs et des chaînes HTML brutes, IronPDF produit facilement des documents PDF de haute qualité.
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 bibliothèque IronPDF peut être installée à l'aide de la console du gestionnaire de packages NuGet avec la commande ci-dessous ou en utilisant le gestionnaire de packages de Visual Studio.
Nous allons maintenant utiliser IronPDF pour générer le document PDF à partir de l'exemple ci-dessus.
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 ClassDans le code ci-dessus, nous générons un document HTML pour les articles du panier et le sauvegardons ensuite en tant que document PDF en utilisant IronPDF.
IronPDF nécessite une clé de licence pour fonctionner en production. Une clé d'essai peut être obtenue depuis la page de licence ici. Placez la clé dans appsettings.json.
"IronPdf.LicenseKey": "your license key"Fournissez votre identifiant email pour obtenir une licence d'essai envoyée à votre identifiant email.
Le mot-clé params en C# offre un moyen flexible de gérer les méthodes qui nécessitent un nombre variable de paramètres. Il simplifie les appels de méthode et rend le code plus lisible et maintenable. Ensemble avec IronPDF, il représente une excellente combinaison de compétences pour tout programmeur souhaitant écrire un code propre.
Jacob Mellor est directeur de la technologie chez Iron Software et un ingénieur visionnaire pionnier de la technologie C# PDF. En tant que développeur à l'origine de la base de code centrale d'Iron Software, il a façonné l'architecture des produits de l'entreprise depuis sa création, la transformant aux côtés du PDG Cameron Rimington en une entreprise de plus de 50 personnes au service de la NASA, de Tesla et d'agences gouvernementales mondiales.
IronPDF fait partie de IRONSUITE
10 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
