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 eine leistungsstarke Funktion in .NET, die 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 Best Practices erkunden. Später in diesem Artikel stellen wir die IronPDF-Bibliothek von Iron Software vor und erklären, wie man das params-Schlüsselwort und IronPDF nutzen kann, um PDFs zu erstellen.

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 AddItemsToShoppingBasket-Methode kann mit einer variablen Anzahl von Argumenten von Zeichenfolgenparametern aufgerufen werden. Das params-Schlüsselwort vereinfacht die Syntax für den Methodenaufruf, indem es Entwicklern ermöglicht, die optionalen Parameter direkt zu übergeben, ohne ein Array explizit 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

  • Positionieren Sie Params am Ende der Parameterliste: Eine empfohlene Praxis ist, den Params-Parameter am Ende der Parameterliste der Methode zu platzieren. Diese Praxis fördert die Klarheit und mindert Verwirrung bei Methodenaufrufen. Parameter, die explizite Werte erfordern, sollten den params vorangehen, um eine effektive Organisation zu gewährleisten.

  • Geben Sie Nicht-Params-Parameter explizit an: Beim Aufrufen einer Methode mit params stellen Sie sicher, dass die Werte für Nicht-params-Parameter explizit angegeben sind. Diese Praxis verhindert Mehrdeutigkeiten und garantiert den korrekten Aufruf der Methode mit der erforderlichen Anzahl von Argumenten.

  • Vorsicht, um Mehrdeutigkeit zu vermeiden: Wachsamkeit ist entscheidend, wenn params in Methoden mit mehreren Überladungen oder Parametern des gleichen Typs verwendet wird. 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: Während params Bequemlichkeit bietet, sollten Sie in bestimmten Szenarien alternative Methoden in Betracht ziehen. Die Nutzung von Sammlungen wie List<t> könnte für erweiterte Funktionalität oder wenn das Übergeben benannter Parameter mit Ihren Zielen übereinstimmt, vorzuziehen sein.

  • Vergleichsweise in relevanten Szenarien anwenden: Setzen Sie params maßvoll in Szenarien ein, in denen die Parameteranzahl 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 des gleichen Typs

AddItemsToShoppingBasket kann durch Übergeben einer Liste/eines Arrays von Variablen, wie im folgenden Methodenaufruf, aufgerufen werden.

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 es einen Typenunterschied vom definierten params in der Methode gibt.

Immer der letzte Parameter in der Methode

Keine zusätzlichen Parameter sind nach dem params-Parameter in einer Methodensignatur erlaubt. In einer Methodenparameterdeklaration ist nur ein params-Argument 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

Es ist nur ein params-Parameter in einer Methoden-Signatur erlaubt. Der Compiler gibt einen Fehler aus, wenn mehr als ein params-Schlüsselwort in der Methoden-Signatur 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 über einen Parameter mit dem params-Schlüsselwort verfügt, kann sie ohne Argumente aufgerufen werden, und der Compiler gibt keinen Fehler aus.

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

Für jeden Parameter mit einem params-Argument wird er als optionaler Parameter betrachtet und kann ohne Übergabe von Parametern 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 - Erstellen einer neuen Konsolenanwendung

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 - Oben gezeigte Codeausgabe

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 oben gezeigten 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 Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO ...

Weiterlesen

Verwandte Artikel

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

Iron Support Team

We're online 24 hours, 5 days a week.
Chat
Email
Call Me