Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. C# Params
.NET AIDE

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

Jacob Mellor, Directeur technique @ Team Iron
Jacob Mellor
Mis à jour:

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 qui nécessitent un nombre variable de paramètres. Dans ce guide complet, nous explorerons le mot-clé params en C#, sa syntaxe, ses cas d'utilisation, et les meilleures pratiques. Plus tard dans cet article, nous introduirons la bibliothèque IronPDF de Iron Software et expliquerons comment utiliser le mot-clé params et IronPDF pour générer des PDF.

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

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 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
    }
}
$vbLabelText   $csharpLabel

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

class Program
{
    public static void Main()
    {
        AddItemsToShoppingBasket("cake", "pizza", "cold drink");
        AddItemsToShoppingBasket("snacks", "burger");
        AddItemsToShoppingBasket(); // Valid even with zero parameters, using default value
    }
}
class Program
{
    public static void Main()
    {
        AddItemsToShoppingBasket("cake", "pizza", "cold drink");
        AddItemsToShoppingBasket("snacks", "burger");
        AddItemsToShoppingBasket(); // Valid even with zero parameters, using default value
    }
}
$vbLabelText   $csharpLabel

Considérations et meilleures pratiques

  • Placer les paramètres en fin de liste : 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 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 autres que les paramètres params : lors de l'appel d'une méthode avec params , assurez-vous de fournir explicitement des valeurs pour les paramètres autres que les paramètres 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 toute ambiguïté : la vigilance est essentielle lors de l'utilisation params dans des méthodes comportant plusieurs surcharges ou des paramètres de 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 d'autres approches : Bien que params offrent une certaine commodité, envisagez d'autres méthodes dans certains cas. L'utilisation de collections telles que List pourrait être préférable pour une fonctionnalité accrue ou lorsque le passage de paramètres nommés s'aligne avec vos objectifs.

  • Appliquer judicieusement aux scénarios pertinents : Déployez params judicieusement dans les scénarios où le nombre de paramètres est variable et peut fluctuer d'un appel de méthode à l'autre. 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.

Tableau unidimensionnel pour le type de paramètre

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
    }
}
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
    }
}
$vbLabelText   $csharpLabel

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

AddItemsToShoppingBasket peut être appelé en passant une liste/tableau de variables dans l'appel de la 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");
    }
}
class Program
{
    public static void Main()
    {
        // Example method signature
        AddItemsToShoppingBasket("snacks", "burger", "snacks", "burger", "cold drink"); // Comma separated values
        AddItemsToShoppingBasket("snacks");
    }
}
$vbLabelText   $csharpLabel

Passer un tableau du type défini

Le 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 string
$vbLabelText   $csharpLabel

Une erreur de syntaxe se produit s'il y a un décalage de type par rapport au params défini 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 signature de méthode. Un seul argument params est autorisé 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 
        }
    }
}
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 
        }
    }
}
$vbLabelText   $csharpLabel

Un seul mot-clé params

Un 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 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
        }
    }
}
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
        }
    }
}
$vbLabelText   $csharpLabel

Vous pouvez ne passer aucun argument

Si 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 expected
AddItemsToShoppingBasket(); // Works as expected
$vbLabelText   $csharpLabel

Pour tout paramètre avec un argument params, il est considéré comme un paramètre facultatif et peut être invoqué 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.

C# Params (Comment cela fonctionne pour les développeurs) : Figure 1 - Création d'une nouvelle 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);
        }
    }
}
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);
        }
    }
}
$vbLabelText   $csharpLabel

Sortie

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

Introduction à IronPDF

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");
    }
}
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");
    }
}
$vbLabelText   $csharpLabel

Installation

La 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.

Install-Package IronPdf

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.

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");
    }
}
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");
    }
}
$vbLabelText   $csharpLabel

Dans 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.

Sortie

C# Params (Comment cela fonctionne 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 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.

Conclusion

Le mot-clé params en C# offre une façon flexible de gérer des méthodes nécessitant 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.

Questions Fréquemment Posées

Qu'est-ce que le mot-clé 'params' en C# ?

Le mot-clé 'params' en C# permet à une méthode d'accepter un nombre variable d'arguments, simplifiant ainsi la syntaxe pour appeler des méthodes avec un nombre de paramètres variable.

Comment fonctionne le mot-clé 'params' dans une signature de méthode ?

Dans une signature de méthode, le mot-clé 'params' est utilisé avant le type de paramètre et le nom du paramètre, permettant à la méthode d'accepter n'importe quel nombre d'arguments de ce type sous forme de tableau.

Une méthode avec 'params' peut-elle accepter zéro argument ?

Oui, une méthode avec un paramètre 'params' peut être appelée sans aucun argument, car le paramètre 'params' est traité comme optionnel.

Quelles sont les meilleures pratiques pour utiliser 'params' en C# ?

Les meilleures pratiques incluent de placer le paramètre 'params' à la fin de la liste des paramètres, de spécifier explicitement les paramètres non-'params', et de l'utiliser judicieusement uniquement lorsque le nombre de paramètres peut varier.

Une méthode C# peut-elle avoir plus d'un paramètre 'params' ?

Non, une méthode en C# peut avoir un seul paramètre 'params', et il doit être le dernier paramètre dans la signature de la méthode.

Comment l'utilisation de 'params' peut-elle améliorer la flexibilité des méthodes en C# ?

L'utilisation de 'params' dans les méthodes C# permet aux développeurs d'écrire un code plus flexible qui peut gérer un nombre dynamique de paramètres, facilitant ainsi sa maintenance et son extension.

Comment le mot-clé 'params' peut-il être combiné avec une bibliothèque C# pour la génération de documents ?

Le mot-clé 'params' peut être utilisé avec une bibliothèque C# pour transmettre un nombre flexible de paramètres pour les tâches de génération de documents, comme la création de PDF avec un contenu varié en utilisant IronPDF.

Comment pouvez-vous convertir HTML en PDF en utilisant une bibliothèque C# ?

Vous pouvez utiliser une bibliothèque C# comme IronPDF pour convertir HTML en PDF en utilisant des méthodes telles que RenderHtmlAsPdf pour les chaînes HTML ou RenderHtmlFileAsPdf pour les fichiers HTML.

Quels sont quelques cas d'utilisation courants pour le mot-clé 'params' en C# ?

Les cas d'utilisation courants du mot-clé 'params' incluent des méthodes qui doivent gérer un nombre variable d'entrées, telles que la journalisation des messages, les opérations mathématiques ou la construction de sorties de chaînes.

Comment intégrer une bibliothèque C# pour la manipulation de PDF dans un projet ?

Pour intégrer une bibliothèque C# pour la manipulation de PDF, comme IronPDF, vous pouvez l'installer en utilisant NuGet avec la commande dotnet add package [LibraryName] et ensuite utiliser son API pour effectuer des tâches PDF.

Jacob Mellor, Directeur technique @ Team Iron
Jacob Mellor
  Discutez maintenant avec l'équipe d'ingénierie
Directeur technique

Jacob Mellor est directeur technique chez Iron Software et un ingénieur visionnaire pionnier dans la technologie des PDF en C#. En tant que développeur original derrière la base de code principale d'Iron Software, il a façonné l'architecture du produit de l'entreprise depuis sa création, ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit