Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. .NET Hilfe
  4. C# Params
.NET HILFE

C# Params (Funktionsweise für Entwickler)

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
Aktualisiert:

Das params-Schlüsselwort in C# ist ein leistungsstarkes Feature in .NET, das es einer Methode ermöglicht, eine variable Anzahl von Argumenten zu akzeptieren. Dies kann die Syntax erheblich vereinfachen, wenn Methoden aufgerufen werden, die eine unterschiedliche Anzahl von Parametern erfordern. In diesem umfassenden Leitfaden werden wir das params-Schlüsselwort in C#, seine Syntax, Anwendungsfälle und bewährte Praktiken erkunden. Später in diesem Artikel werden wir die IronPDF-Bibliothek von Iron Software vorstellen und erklären, wie man das params-Schlüsselwort und IronPDF zur PDF-Erstellung verwendet.

Was ist der C# Params Argumenttyp?

Im Bereich von C# halten sich Methoden typischerweise an eine vorgegebene Menge an Parametern. Dennoch gibt es Situationen, in denen man sich über die genaue Anzahl der für eine Methode bestimmten Argumente unsicher sein könnte. Hier kommt das "params"-Schlüsselwort ins Spiel, eine Lösung, die es ermöglicht, einen Methodenparameter zu spezifizieren, der ein Array von Argumenten aufnehmen kann. Diese Funktionalität erweist sich als äußerst wertvoll, wenn der Entwickler im Voraus unsicher über die genaue Anzahl der Argumente ist, da sie die Passage einer unbestimmten oder optionalen Anzahl von Parametern, alle vom gleichen Typ, innerhalb einer Methodenerklärung erleichtert.

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

Die Methode AddItemsToShoppingBasket kann mit variabler Anzahl an String-Parametern aufgerufen werden. Das params-Schlüsselwort vereinfacht die Syntax für den Methodenaufruf, indem es Entwicklern erlaubt, die optionalen Parameter direkt zu übergeben, ohne explizit ein Array-Input zu erstellen.

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

Berücksichtigungen und bewährte Praktiken

  • Parameter am Ende der Parameterliste platzieren: Es empfiehlt sich, den Parameter params am Ende der Parameterliste der Methode zu platzieren. Dies fördert die Übersichtlichkeit und verringert Verwirrung bei Methodenaufrufen. Parameter, die explizite Werte erfordern, sollten den params vorangehen, um eine effektive Organisation zu gewährleisten.

  • Nicht-params-Parameter explizit angeben: Beim Aufruf einer Methode mit params muss sichergestellt werden, dass die Werte für die Nicht- params -Parameter explizit angegeben werden. Diese Praxis verhindert Mehrdeutigkeiten und garantiert den korrekten Aufruf der Methode mit der erforderlichen Anzahl von Argumenten.

  • Vorsicht ist geboten, um Mehrdeutigkeiten zu vermeiden: Wachsamkeit ist der Schlüssel bei der Verwendung params in Methoden mit mehreren Überladungen oder Parametern vom gleichen Typ. Der Compiler könnte Schwierigkeiten haben, die angemessene Methode zum Aufrufen zu bestimmen, was potenziell zu Mehrdeutigkeitsfehlern führen könnte.

  • Alternative Ansätze erkunden: Obwohl params den Komfort bietet, sollten in bestimmten Szenarien alternative Methoden in Betracht gezogen werden. Die Verwendung von Sammlungen wie List könnte für erweiterte Funktionalität oder wenn das Übergeben von benannten Parametern mit Ihren Zielen übereinstimmt vorzuziehen sein.

  • Umsichtig in relevanten Szenarien anwenden: Setzen Sie params umsichtig in Szenarien ein, in denen die Anzahl der Parameter variabel ist und bei verschiedenen Methodenaufrufen schwanken kann. Bewahren Sie seine Nutzung für Situationen auf, in denen die Anzahl der Parameter unvorhersehbar ist, und vermeiden Sie dessen Anwendung, wenn die Parameteranzahl festgelegt und bekannt ist.

Eindimensionales Array für den Parametertyp

AddItemsToShoppingBasket kann auch verwendet werden, indem es mit einem eindimensionalen Array aufgerufen wird.

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

Übergeben Sie ein durch Kommas getrenntes Array von Argumenten desselben Typs.

AddItemsToShoppingBasket kann aufgerufen werden, indem eine Liste/ein Array von Variablen im Methodenaufruf wie unten gezeigt übergeben wird.

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

Ein Array des definierten Typs übergeben

Das Array sollte denselben Typ enthalten, der in der params-Methode definiert ist; andernfalls wird ein Fehler ausgegeben.

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

Ein Syntaxfehler tritt auf, wenn eine Typinkongruenz des definierten params in der Methode besteht.

Immer der letzte Parameter in der Methode

Es sind keine zusätzlichen Parameter nach dem params-Parameter in einer Methodensignatur zulässig. Nur ein params-Argument ist in einer Methodendeklaration erlaubt. Es führt zu Kompilierungsfehlern, wenn es falsch definiert wird.

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

Nur ein params Schlüsselwort

Nur ein params-Parameter ist in einer Methodensignatur erlaubt. Der Compiler wirft einen Fehler aus, wenn mehr als ein params-Schlüsselwort in der Methodensignatur gefunden wird.

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

Sie können keine Argumente vorbringen

Wenn eine Methode einen Parameter mit dem params-Schlüsselwort hat, kann sie ohne Argumente aufgerufen werden, und der Compiler wird keinen Fehler auslösen.

AddItemsToShoppingBasket(); // Works as expected
AddItemsToShoppingBasket(); // Works as expected
$vbLabelText   $csharpLabel

Für jeden Parameter mit einem params-Argument gilt er als optionaler Parameter und kann ohne übergebene Parameter aufgerufen werden.

Beispielcode

Erstellen Sie eine neue Konsolenanwendung. Öffnen Sie Visual Studio, erstellen Sie ein neues Projekt und wählen Sie den Konsolenanwendungstyp.

C# Params (Wie es für Entwickler funktioniert): Abbildung 1 - Neues Konsolenanwendungsprojekt erstellen

Fügen Sie den Code unten hinzu.

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

Ausgabe

C# Params (Wie es für Entwickler funktioniert): Abbildung 2 - Ausgabe des obigen Codes

Einführung in IronPDF

Die IronPDF C# PDF-Bibliothek von Iron Software ist eine vielseitige Bibliothek, die PDF-Dokumente in C# lesen, schreiben und verwalten kann. Sie unterstützt alle Arten der modernen Anwendungsentwicklung wie Mobile, Website, Desktop, Docker usw. und unterstützt auch verschiedene Betriebssysteme wie Windows, Linux, Unix usw. Sie ist nicht auf native Betriebssystemmethoden angewiesen.

IronPDF überzeugt in der HTML-zu-PDF-Konvertierung, indem es den originalen Layouts und Stilen präzise erhält. Es ist ideal zur Erstellung von PDFs aus webbasierten Inhalten wie Berichten, Rechnungen und Dokumentationen. Mit Unterstützung für HTML-Dateien, URLs und rohe HTML-Strings erstellt IronPDF problemlos hochwertige PDF-Dokumente.

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

Die IronPDF-Bibliothek kann mit der NuGet-Paketmanagerkonsole mit dem untenstehenden Befehl oder mit dem Visual Studio Paketmanager installiert werden.

Install-Package IronPdf

Verwendung von IronPDF zur PDF-Erzeugung

Jetzt werden wir IronPDF verwenden, um das PDF-Dokument aus dem obigen Beispiel zu erstellen.

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

Im obigen Code generieren wir ein HTML-Dokument für Warenkorbartikel und speichern es dann mit IronPDF als PDF-Dokument.

Ausgabe

C# Params (Wie es für Entwickler funktioniert): Abbildung 3 - PDF-Ausgabe aus dem obigen Code

Lizenzierung (Kostenlose Testversion verfügbar)

IronPDF erfordert einen Lizenzschlüssel, um in der Produktion zu funktionieren. Ein Testschlüssel kann auf der Lizenzseite hier erworben werden. Platzieren Sie den Schlüssel in appsettings.json.

"IronPdf.LicenseKey": "your license key"

Geben Sie Ihre E-Mail-Adresse an, um einen Testschlüssel zu erhalten.

Abschluss

Das params-Schlüsselwort in C# bietet eine flexible Möglichkeit, mit Methoden umzugehen, die eine variable Anzahl von Parametern erfordern. Es vereinfacht die Methodenaufrufe und macht den Code lesbarer und wartungsfreundlicher. Zusammen mit IronPDF stellt es eine großartige Kombination von Fähigkeiten für jeden Programmierer dar, um sauberen Code zu schreiben.

Häufig gestellte Fragen

Was ist das 'params'-Schlüsselwort in C#?

Das 'params'-Schlüsselwort in C# ermöglicht es einer Methode, eine variable Anzahl von Argumenten anzunehmen, wodurch die Syntax für Methodenaufrufe mit unterschiedlichen Parameteranzahlen vereinfacht wird.

Wie funktioniert das 'params'-Schlüsselwort in einer Methodensignatur?

In einer Methodensignatur wird das 'params'-Schlüsselwort vor dem Parametertyp und dem Parameternamen verwendet, sodass die Methode eine beliebige Anzahl von Argumenten dieses Typs als Array annehmen kann.

Kann eine Methode mit 'params' null Argumente annehmen?

Ja, eine Methode mit einem 'params'-Parameter kann ohne Argumente aufgerufen werden, da der 'params'-Parameter als optional behandelt wird.

Was sind die Best Practices für die Verwendung von 'params' in C#?

Best Practices beinhalten, den 'params'-Parameter am Ende der Parameterliste zu platzieren, nicht-'params'-Parameter explizit anzugeben und es nur dann maßvoll zu verwenden, wenn die Anzahl der Parameter variieren kann.

Kann eine C#-Methode mehr als einen 'params'-Parameter haben?

Nein, eine C#-Methode kann nur einen 'params'-Parameter haben, und dieser muss der letzte Parameter in der Methodensignatur sein.

Wie kann die Verwendung von 'params' die Flexibilität von Methoden in C# verbessern?

Die Verwendung von 'params' in C#-Methoden ermöglicht Entwicklern, flexibleren Code zu schreiben, der eine dynamische Anzahl von Parametern handhaben kann, was die Wartung und Erweiterung erleichtert.

Wie kann das 'params'-Schlüsselwort mit einer C#-Bibliothek für die Dokumentenerstellung kombiniert werden?

Das 'params'-Schlüsselwort kann mit einer C#-Bibliothek verwendet werden, um eine flexible Anzahl von Parametern für Dokumentenerstellungsaufgaben zu übergeben, z.B. zur Erstellung von PDFs mit wechselndem Inhalt mithilfe von IronPDF.

Wie können Sie HTML mithilfe einer C#-Bibliothek in PDF umwandeln?

Sie können eine C#-Bibliothek wie IronPDF verwenden, um HTML in PDF umzuwandeln, indem Sie Methoden wie RenderHtmlAsPdf für HTML-Strings oder RenderHtmlFileAsPdf für HTML-Dateien verwenden.

Was sind einige gängige Anwendungsfälle für das 'params'-Schlüsselwort in C#?

Gängige Anwendungsfälle für das 'params'-Schlüsselwort umfassen Methoden, die eine variierende Anzahl von Eingaben benötigen, wie das Protokollieren von Nachrichten, mathematische Operationen oder das Erstellen von Zeichenfolgenausgaben.

Wie integriert man eine C#-Bibliothek zur PDF-Manipulation in ein Projekt?

Um eine C#-Bibliothek zur PDF-Manipulation wie IronPDF zu integrieren, können Sie sie mithilfe von NuGet mit dem Befehl dotnet add package [LibraryName] installieren und dann deren API verwenden, um PDF-Aufgaben durchzuführen.

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
  Jetzt mit dem Ingenieurteam chatten
Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der führend in der C# PDF-Technologie ist. Als ursprünglicher Entwickler der Iron Software-Kerncodebasis hat er die Produktarchitektur des Unternehmens seit seiner Gründung gestaltet und zusammen mit CEO Cameron Rimington in ein Unternehmen ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen