Das Schlüsselwort params in C# ist eine leistungsfähige Funktion in .NET, die es ermöglicht, dass eine Methode eine variable Anzahl von Argumenten akzeptiert. Dies kann die Syntax erheblich vereinfachen, wenn Methoden aufgerufen werden, die eine unterschiedliche Anzahl von Parametern erfordern. In diesem umfassenden Leitfaden werden wir das Schlüsselwort params in C#, seine Syntax, Anwendungsfälle und Best Practices erkunden. Später in diesem Artikel werden wir die IronPDF-Bibliothek von Iron Software vorstellen und erklären, wie Sie das Schlüsselwort params und IronPDF nutzen können, um PDFs zu erzeugen.
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 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 ClassDie Methode AddItemsToShoppingBasket kann mit einer variablen Anzahl von Argumenten von Zeichenfolgenparametern aufgerufen werden. Das Schlüsselwort params vereinfacht die Syntax für den Methodenaufruf, indem es Entwicklern ermöglicht, die optionalen Parameter direkt zu übergeben, ohne ein Array explizit erstellen zu müssen.
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 ClassParameter am Ende der Parameterliste platzieren: Es empfiehlt sich, den Parameter params am Ende der Parameterliste der Methode zu platzieren. Dies erhöht die Übersichtlichkeit und beugt Verwirrung bei Methodenaufrufen vor. Parameter, die explizite Werte erfordern, sollten den params vorangehen, um eine effektive Organisation zu gewährleisten.
Geben Sie nicht-Params-Parameter explizit an: Bei einem Aufruf einer Methode mit params sorgen Sie für eine explizite Bereitstellung der Werte für nicht-params-Parameter. Diese Praxis verhindert Mehrdeutigkeiten und garantiert den korrekten Aufruf der Methode mit der erforderlichen Anzahl von Argumenten.
Vorsicht walten lassen, um Mehrdeutigkeiten zu vermeiden: Wachsamkeit ist entscheidend, wenn params in Methoden mit mehreren Überladungen oder Parametern desselben 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, ziehen Sie in bestimmten Szenarien alternative Methoden in Betracht. Die Nutzung von Sammlungen wie List<t> könnte vorzuziehen sein, um eine erweiterte Funktionalität zu erreichen oder wenn die Übergabe benannter Parameter Ihren Zielsetzungen entspricht.
Überlegt auf relevante Szenarien anwenden: Setzen Sie params überlegt in Szenarien ein, in denen die Parameteranzahl variabel ist und zwischen 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.
AddItemsToShoppingBasket kann auch durch Aufruf mit einem eindimensionalen Array verwendet werden.
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 kann aufgerufen werden, indem eine Liste/Array von Variablen im Methodenaufruf wie unten übergeben wird.
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 ClassDas 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 stringEin Syntaxfehler tritt auf, wenn es zu einer Typinkongruenz mit dem definierten params in der Methode kommt.
Nach dem Parameter params sind in einer Methodensignatur keine zusätzlichen Parameter erlaubt. In einer Methodenerklärung für Parameter 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
}
}
}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 Moduleparams SchlüsselwortIn einer Methodensignatur ist nur ein params Parameter erlaubt. Der Compiler wirft einen Fehler, 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
}
}
}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 ClassWenn eine Methode einen Parameter mit dem Schlüsselwort params hat, kann sie ohne Argumente aufgerufen werden, und der Compiler wird keinen Fehler werfen.
AddItemsToShoppingBasket(); // Works as expectedAddItemsToShoppingBasket() ' Works as expectedBei jedem Parameter mit einem params-Argument wird er als optionaler Parameter angesehen und kann ohne die Übergabe von Parametern aufgerufen werden.
Erstellen Sie eine neue Konsolenanwendung. Öffnen Sie Visual Studio, erstellen Sie ein neues Projekt und wählen Sie den Konsolenanwendungstyp.
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);
}
}
}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
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");
}
}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 ClassDie IronPDF-Bibliothek kann mit der NuGet-Paketmanagerkonsole mit dem untenstehenden Befehl oder mit dem Visual Studio Paketmanager installiert werden.
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");
}
}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 ClassIm obigen Code generieren wir ein HTML-Dokument für Warenkorbartikel und speichern es dann mit IronPDF als PDF-Dokument.
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.
Das Schlüsselwort params in C# bietet eine flexible Möglichkeit, Methoden zu handhaben, 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.
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 Cameron Rimington in ein Unternehmen mit mehr als 50 Mitarbeitern verwandelt, das die NASA, Tesla und globale Regierungsbehörden beliefert.
IronPDF ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Wenn Ihr PDF wie HTML aussehen soll, schnell.
