.NET-HILFE

C# Params (Wie es für Entwickler funktioniert)

Veröffentlicht 26. März 2024

Teilen Sie:

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 beim Aufruf von Methoden, die eine unterschiedliche Anzahl von Parametern erfordern, erheblich vereinfachen. In diesem umfassenden Leitfaden werden wir das params-Schlüsselwort in C#, seine Syntax, Anwendungsfälle und Best Practices untersuchen. Später in diesem Artikel werden wir die IronPDF bibliothek von Iron Software und erläutern, wie das Schlüsselwort params und IronPDF verwendet werden, um PDFs zu erzeugen.

Was ist der Argumenttyp C# Params?

In C# halten sich die Methoden in der Regel an einen vorgegebenen Satz von Parametern. Dennoch gibt es Situationen, in denen man sich über die genaue Anzahl der für eine Methode bestimmten Argumente unsicher sein kann. Mit dem Schlüsselwort "params" wurde eine Lösung gefunden, die die Angabe eines Methodenparameters ermöglicht, der ein Array von Argumenten aufnehmen kann. Diese Funktion ist von unschätzbarem Wert, wenn der Entwickler die genaue Anzahl der Argumente im Voraus nicht kennt, da sie die Übergabe einer unbestimmten oder optionalen Anzahl von Parametern desselben Typs innerhalb einer Methodendeklaration erleichtert.

public class ParamsExample
{
    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)
{
  // ....
}
public static void AddItemsSumToShoppingBasket(params int [] sum) // params int
{
  // ....
}

public class ParamsExample
{
    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)
{
  // ....
}
public static void AddItemsSumToShoppingBasket(params int [] sum) // params int
{
  // ....
}

Public Class ParamsExample
	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)
  ' ....
End Sub
Public Shared Sub AddItemsSumToShoppingBasket(ParamArray ByVal sum() As Integer) ' params int
  ' ....
End Sub

VB C#

die Methode "AddItemsToShoppingBasket" kann mit einer variablen Anzahl von Argumenten aus String-Parametern aufgerufen werden. Das params-Objektschlüsselwort vereinfacht die Syntax für den Methodenaufruf, indem es Entwicklern ermöglicht, die optionalen Parameter direkt zu übergeben, ohne explizit ein Array Input zu erstellen.

class Program {
AddItemsToShoppingBasket("cake", "pizza", "cold drink");
AddItemsToShoppingBasket("snacks", "burger");
AddItemsToShoppingBasket(); // Valid with zero parameters default value
}

class Program {
AddItemsToShoppingBasket("cake", "pizza", "cold drink");
AddItemsToShoppingBasket("snacks", "burger");
AddItemsToShoppingBasket(); // Valid with zero parameters default value
}

Friend Class Program
AddItemsToShoppingBasket("cake", "pizza", "cold drink")
AddItemsToShoppingBasket("snacks", "burger")
AddItemsToShoppingBasket() ' Valid with zero parameters default value
End Class

VB C#

Überlegungen und bewährte Praktiken

Positionierung von params am Ende der Parameterliste: Es wird empfohlen, den Parameter params am Ende der Parameterliste der Methode zu platzieren. Diese Praxis fördert die Klarheit und mindert die Verwirrung bei Methodenaufrufen. Parameter, die explizite Werte erfordern, sollten den Parametern vorangestellt werden, um eine effektive Organisation zu gewährleisten.

Explizite Angabe von Nicht-Param-Parametern: Wenn Sie eine Methode mit Parametern aufrufen, stellen Sie sicher, dass die Werte für die Nicht-Parameter explizit angegeben werden. Diese Praxis verhindert Mehrdeutigkeit und garantiert den korrekten Aufruf der Methode mit der erforderlichen Anzahl von Argumenten.

Vorsicht zur Vermeidung von Mehrdeutigkeit: Bei der Verwendung von Parametern in Methoden mit mehreren Überladungen oder Parametern desselben Typs ist Wachsamkeit angesagt. Der Compiler hat unter Umständen Schwierigkeiten, die richtige Methode für den Aufruf zu bestimmen, was zu Mehrdeutigkeitsfehlern führen kann.

Prüfen Sie alternative Ansätze: Params sind zwar bequem, aber in bestimmten Szenarien sollten Sie auch alternative Methoden in Betracht ziehen. Die Verwendung von Sammlungen wie List könnte für eine erweiterte Funktionalität vorzuziehen sein oder wenn die Übergabe von benannten Parametern mit Ihren Zielen übereinstimmt.

Umsichtig auf relevante Szenarien anwenden: Setzen Sie params mit Bedacht in Szenarien ein, in denen die Anzahl der Parameter variabel ist und über verschiedene Methodenaufrufe hinweg schwanken kann. Reservieren Sie seine Verwendung für Situationen, in denen die Anzahl der Parameter unvorhersehbar ist, und vermeiden Sie seine Anwendung, wenn die Anzahl der Parameter fest und bekannt ist.

Eindimensionales Array für den Parametertyp

AddItemsToShoppingBasket kann auch durch den Aufruf eines eindimensionalen Arrays verwendet werden.

// example
class Program {
public static void main()
{
var items = [] {"cold drink", "snack", "roll", }; // 1D string array
AddItemsToShoppingBasket(items); // works
AddItemsToShoppingBasket( "cold drink", "coke", "roll",); // same as above line
}
}

// example
class Program {
public static void main()
{
var items = [] {"cold drink", "snack", "roll", }; // 1D string array
AddItemsToShoppingBasket(items); // works
AddItemsToShoppingBasket( "cold drink", "coke", "roll",); // same as above line
}
}

' example
Friend Class Program
Public Shared Sub main()
Dim items = () {"cold drink", "snack", "roll"} ' 1D string array
AddItemsToShoppingBasket(items) ' works
AddItemsToShoppingBasket("cold drink", "coke", "roll",) ' same as above line
End Sub
End Class

VB C#

Übergabe eines durch Komma getrennten Arrays von Argumenten desselben Typs

AddItemsToShoppingBasket kann auch durch Übergabe einer Liste/eines Arrays von Variablen im Methodenaufruf wie unten aufgerufen werden.

// example method signature
class Program {
AddItemsToShoppingBasket("snacks", "burger", "snacks", "burger", "cold drink"); // comma separated values
AddItemsToShoppingBasket("snacks"); 
}

// example method signature
class Program {
AddItemsToShoppingBasket("snacks", "burger", "snacks", "burger", "cold drink"); // comma separated values
AddItemsToShoppingBasket("snacks"); 
}

' example method signature
Friend Class Program
AddItemsToShoppingBasket("snacks", "burger", "snacks", "burger", "cold drink") ' comma separated values
AddItemsToShoppingBasket("snacks")
End Class

VB C#

Übergeben Sie ein Array des definierten Typs

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

// example
AddItemsToShoppingBasket("snacks",2,"burger"); // error 
AddItemsToShoppingBasket(2,3,4); // error as params type is string

// example
AddItemsToShoppingBasket("snacks",2,"burger"); // error 
AddItemsToShoppingBasket(2,3,4); // error as params type is string

' example
AddItemsToShoppingBasket("snacks",2,"burger") ' error
AddItemsToShoppingBasket(2,3,4) ' error as params type is string

VB C#

Syntaxfehler, da die definierten Parameter in der Methode vom Typ her nicht übereinstimmen.

Immer der letzte Parameter in der Methode

In einer Methodensignaturdeklaration sind nach dem Parameter params keine weiteren Parameter zulässig, und in einer Methodenparameterdeklaration ist nur ein Argument params zulässig.

In der Methodensignatur sollten die Parameter am Ende definiert werden, danach sind keine Parameter mehr erlaubt. Eine solche Definition führt zu Kompilierungsfehlern.

class program {
static void Main(string [] args){
// example 1
   public static void AddItemsToShoppingBasket(double total, params string [] items)
   {
     // ....
   } // This works
}
}
example 2
static void Main(string [] args){
   public static void AddItemsToShoppingBasket(double total, int total, params string [] items)
   {
     // ....
   } // This works
}
// example 3 error scenario
static void Main(string [] args){
   public static void AddItemsToShoppingBasket(params string [] items, decimal total, int total)
   {
     // error
   } // params keyword is defined as first parameter, needs to be at the last.
}

class program {
static void Main(string [] args){
// example 1
   public static void AddItemsToShoppingBasket(double total, params string [] items)
   {
     // ....
   } // This works
}
}
example 2
static void Main(string [] args){
   public static void AddItemsToShoppingBasket(double total, int total, params string [] items)
   {
     // ....
   } // This works
}
// example 3 error scenario
static void Main(string [] args){
   public static void AddItemsToShoppingBasket(params string [] items, decimal total, int total)
   {
     // error
   } // params keyword is defined as first parameter, needs to be at the last.
}

Friend Class program
Shared Sub Main(ByVal args() As String)
' example 1
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'   public static void AddItemsToShoppingBasket(double total, params string [] items)
'   {
'	 ' ....
'   } ' This works
End Sub
End Class
example 2 Shared Sub Main(ByVal args() As String)
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'   public static void AddItemsToShoppingBasket(double total, int total, params string [] items)
'   {
'	 ' ....
'   } ' This works
End Sub
' example 3 error scenario
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, decimal total, int total)
'   {
'	 ' error
'   } ' params keyword is defined as first parameter, needs to be at the last.
End Sub

VB C#

Nur ein params-Schlüsselwort

In einer Methodensignatur ist nur ein Parameter params zulässig. Der Compiler gibt einen Fehler aus, wenn mehr als ein params-Schlüsselwort in der Methodensignatur gefunden wird.

//only one params keyword example
class Program {
static void Main(string [] args){
public static void AddItemsToShoppingBasket(params string [] items, params string [] quantity)
{
} // Compiler error, This does not work. 
}
}

//only one params keyword example
class Program {
static void Main(string [] args){
public static void AddItemsToShoppingBasket(params string [] items, params string [] quantity)
{
} // Compiler error, This does not work. 
}
}

'only one params keyword example
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, This does not work.
End Sub
End Class

VB C#

Sie können keine Argumente übergeben

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

AddItemsToShoppingBasket(); // Works

AddItemsToShoppingBasket(); // Works

AddItemsToShoppingBasket() ' Works

VB C#

Denn jeder Parameter mit dem Argument params gilt als optionaler Parameter und kann ohne Übergabe von Parametern aufgerufen werden.

Code-Beispiel

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

C# Params (Wie es für Entwickler funktioniert): Abbildung 1 - Erstellen einer neuen Konsolenanwendung

Fügen Sie nun den folgenden Code ein.

class Program {
Console.WriteLine("Params demo");
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
static void Main(string [] args) {
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);
}
}
}

class Program {
Console.WriteLine("Params demo");
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
static void Main(string [] args) {
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);
}
}
}

Friend Class Program
Console.WriteLine("Params demo")
Dim cart As New List(Of String)()
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'void AddItemsToShoppingBasket(params string [] samples)
'{
'	for (int i = 0; i < samples.Length; i++)
'	{
'		cart.Add(samples [i]);
'	}
'}
' caller code
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'static void Main(string [] args)
'{
'Console.WriteLine("Enter the cart items as comma separated values");
'var itemsString = Console.ReadLine();
'if (itemsString != Nothing)
'{
'	var items = itemsString.Split(",").ToArray();
'	AddItemsToShoppingBasket(items);
'}
'AddItemsToShoppingBasket("Sample1", "Sample2");
'Console.WriteLine("-------------------------------------------------------");
'Console.WriteLine("Display Cart");
'foreach (var item in cart)
'{
'	Console.WriteLine(item);
'}
'}
End Class

VB C#

Ausgabe

C# Params (Wie es für Entwickler funktioniert): Abbildung 2 - Obige Codeausgabe

Wir stellen vor: IronPDF

IronPDF C# PDF-Bibliothek von Iron Software ist eine vielseitige Bibliothek, die PDF-Dokumente in C# lesen, schreiben und verwalten kann. Es unterstützt alle Arten der modernen Anwendungsentwicklung wie Mobile, Website, Desktop, Docker, etc. Und unterstützt auch verschiedene Betriebssysteme wie Windows, Linux, Unix, etc. Es ist nicht abhängig von nativen OS-Methoden.

Einrichtung

Die IronPDF-Bibliothek kann mit dem Befehl *NuGet paketmanager-Konsole mit dem unten stehenden Befehl oder über den Visual Studio-Paketmanager.

dotnet add package IronPdf

dotnet add package IronPdf

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'dotnet add package IronPdf

VB C#

IronPDF zum Erzeugen einer PDF-Datei verwenden

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

class program
{
public static void main()
{
Console.WriteLine("IronPDF to generate the PDF document for Params Example");
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 seperated 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");
}
}

class program
{
public static void main()
{
Console.WriteLine("IronPDF to generate the PDF document for Params Example");
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 seperated 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

Friend Class program
Public Shared Sub main()
Console.WriteLine("IronPDF to generate the PDF document for Params Example")
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 seperated 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 Class

VB C#

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

Ausgabe

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

Lizenzierung (kostenlose Testversion verfügbar)

IronPDF benötigt einen Lizenzschlüssel, um in der Produktion zu funktionieren. Einen Testschlüssel erhalten Sie auf der Lizenzseite hier. Platzieren Sie den Schlüssel in appsettings.json.

"IronPdf.LicenseKey": "your license key"

"IronPdf.LicenseKey": "your license key"

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'"IronPdf.LicenseKey": "your license key"

VB C#

Geben Sie Ihre E-Mail-ID an, um eine Testlizenz an Ihre E-Mail-ID zu erhalten.

Schlussfolgerung

Das params-Schlüsselwort in C# mit .NET 8 bietet eine flexible Möglichkeit zur Handhabung von Methoden, die eine variable Anzahl von Parametern erfordern. Es vereinfacht die Methodenaufrufe und macht den Code lesbarer und wartbarer. Zusammen mit IronPDFes ist eine großartige Kombination von Fähigkeiten für jeden Programmierer, um sauberen Code zu schreiben.

< PREVIOUS
C# PostgreSQL (Wie es für Entwickler funktioniert)

NÄCHSTES >
C# Enums (Wie es für Entwickler funktioniert)