C# Standard-Parameter (So funktioniert es für Entwickler)

Heute werden wir in die Welt von C# eintauchen und etwas über eine leistungsstarke Funktion lernen - Standardparameter. Wir werden sie auf leicht verständliche Weise aufschlüsseln und uns dabei auf das Konzept der Standardargumente und optionalen Argumente in C# konzentrieren.

Was sind Standardparameter?

In C#, standardparameter, auch als optionale Argumentparameter bekannt, ermöglichen es Ihnen, festen Argumenten in einer Methodendefinition einen Wert zuzuweisen. Wenn beim Aufruf der Funktion kein Argument für diesen Parameter angegeben wird, wird der Standardwert verwendet.

Ein Standard-Parameterwert wird in der Methodendefinition festgelegt, wie im folgenden Codeschnipsel gezeigt:

public void Greet(string name = "Friend")
{
    Console.WriteLine("Hello, " + name);
}

public void Greet(string name = "Friend")
{
    Console.WriteLine("Hello, " + name);
}

Public Sub Greet(Optional ByVal name As String = "Friend")
	Console.WriteLine("Hello, " & name)
End Sub

Hier ist der Parameter "Name" ein optionales Attribut. Die Zeichenfolge "Freund" ist der Standardwert. Wenn Sie Greet() ohne Übergabe eines Arguments, wird "Friend" als Wert für den Name verwendet.

Erforderliche Parameter und optionale Parameter

Erforderliche Parameter

Ein erforderlicher Parameter ist ein Parameter, der beim Aufruf der Funktion oder Methode angegeben werden muss. Sie hat keinen Standardwert, so dass immer ein Argument angegeben werden muss. Der Compiler prüft den Aufruf der Funktion oder Methode, und wenn der erforderliche Parameter nicht übergeben wird, wird ein Kompilierfehler ausgegeben.

Betrachten wir ein Beispiel:

//pass arguments in the same order
public void IntroduceYourself(string firstName, string lastName)
{
    Console.WriteLine("Hello, my name is " + firstName + " " + lastName);
}

//pass arguments in the same order
public void IntroduceYourself(string firstName, string lastName)
{
    Console.WriteLine("Hello, my name is " + firstName + " " + lastName);
}

'pass arguments in the same order
Public Sub IntroduceYourself(ByVal firstName As String, ByVal lastName As String)
	Console.WriteLine("Hello, my name is " & firstName & " " & lastName)
End Sub

In dieser Methode sind "Vorname" und "Nachname" beide erforderliche Parameter. Wenn Sie IntroduceYourself aufrufen, müssen Sie Werte für beide Parameter angeben. Wenn Sie die Argumente weglassen, erhalten Sie einen Kompilierfehler.

IntroduceYourself("John", "Doe"); // Following call is correct
IntroduceYourself("John"); // Error: lastName is missing

IntroduceYourself("John", "Doe"); // Following call is correct
IntroduceYourself("John"); // Error: lastName is missing

IntroduceYourself("John", "Doe") ' Following call is correct
IntroduceYourself("John") ' Error: lastName is missing

Optionale Parameter

Andererseits ermöglichen optionale Parameter Flexibilität. Sie haben einen Standardwert in der Methodendefinition, der verwendet wird, wenn die Methode ohne diesen Parameter aufgerufen wird.

Ändern wir zum Beispiel die Methode IntroduceYourself so, dass der Parameter lastName optional ist:

//named arguments
public void IntroduceYourself(string firstName, string lastName = "Doe")
{
    Console.WriteLine("Hello, my name is " + firstName + " " + lastName);
}

//named arguments
public void IntroduceYourself(string firstName, string lastName = "Doe")
{
    Console.WriteLine("Hello, my name is " + firstName + " " + lastName);
}

'named arguments
Public Sub IntroduceYourself(ByVal firstName As String, Optional ByVal lastName As String = "Doe")
	Console.WriteLine("Hello, my name is " & firstName & " " & lastName)
End Sub

Jetzt können Sie IntroduceYourself nur mit dem Parameter FirstName aufrufen. Wenn Sie dies tun, wird lastName standardmäßig auf "Doe" gesetzt.

IntroduceYourself("John", "Smith"); // Outputs: Hello, my name is John Smith
IntroduceYourself("John");          // Outputs: Hello, my name is John Doe

IntroduceYourself("John", "Smith"); // Outputs: Hello, my name is John Smith
IntroduceYourself("John");          // Outputs: Hello, my name is John Doe

IntroduceYourself("John", "Smith") ' Outputs: Hello, my name is John Smith
IntroduceYourself("John") ' Outputs: Hello, my name is John Doe

Wenn Sie die optionalen Argumente angeben, wird der Standardwert überschrieben.

Denken Sie daran, dass in der Methodendeklaration die erforderlichen Parameter immer vor den optionalen Parametern aufgeführt werden müssen.

Den Unterschied verstehen

Die Unterscheidung zwischen erforderlichen oder benannten und optionalen Parametern ist wichtig, da sie sich darauf auswirkt, wie Sie eine Methode aufrufen können. Optionale Parameter bieten Flexibilität und ermöglichen es Ihnen, die Eingabe bestimmter Parameter zu überspringen, wenn diese nicht benötigt werden. Andererseits stellen erforderliche Parameter sicher, dass die Funktion oder Methode immer mit den notwendigen Daten versorgt wird, um Laufzeitfehler zu vermeiden.

Regeln für die Verwendung von Standardparametern

Bei der Definition einer Methode mit Standardparametern gibt es einige wichtige Regeln zu beachten:

1. Der Standardwert muss ein konstanter Ausdruck sein. Sie können keine Variablen oder Methodenaufrufe verwenden.

2. Alle optionalen Parameter müssen am Ende der Parameterliste nach den erforderlichen Parametern definiert werden.

3. Wenn Sie eine Methode mit optionalen Parametern aufrufen, können Sie ausgelassene Argumente für die optionalen Parameter in der Reihenfolge angeben, in der sie definiert sind, oder Sie können benannte Argumente verwenden.

4. Der Standardwert wird verwendet, wenn kein optionaler Argumentwert angegeben wird.

   Betrachten Sie den folgenden Codeschnipsel für positionale Argumente:

static void Main(string [] args)
{
    ShowMessage("Hello");
    ShowMessage("Hello", "John");
}

public static void ShowMessage(string msg, string name = "Friend")
{
    Console.WriteLine(msg + ", " + name);
}

static void Main(string [] args)
{
    ShowMessage("Hello");
    ShowMessage("Hello", "John");
}

public static void ShowMessage(string msg, string name = "Friend")
{
    Console.WriteLine(msg + ", " + name);
}

Shared Sub Main(ByVal args() As String)
	ShowMessage("Hello")
	ShowMessage("Hello", "John")
End Sub

Public Shared Sub ShowMessage(ByVal msg As String, Optional ByVal name As String = "Friend")
	Console.WriteLine(msg & ", " & name)
End Sub

In der statischen void-Methode Main rufen wir ShowMessage zweimal auf. Beim ersten Mal übergeben wir nur ein Argument, so dass der Parameter "Name" den Standardwert "Friend" hat. Beim zweiten Mal werden zwei Argumente übergeben, so dass "John" anstelle des Standardwerts verwendet wird.

Benannte und optionale Parameter

C# unterstützt auch benannte und optionale Parameter. Mit benannten Parametern können Sie einen Wert für einen Parameter nach Namen und nicht nach Position angeben. Dies kann hilfreich sein, wenn eine Methode mehrere optionale Parameter hat und Sie einen Wert für einen, aber nicht für die anderen angeben wollen.

Im folgenden Beispiel hat ShowGreetings zwei optionale Parameter:

public static void ShowGreetings(string greeting = "Hello", string name = "Friend")
{
    Console.WriteLine(greeting + ", " + name);
}

public static void ShowGreetings(string greeting = "Hello", string name = "Friend")
{
    Console.WriteLine(greeting + ", " + name);
}

Public Shared Sub ShowGreetings(Optional ByVal greeting As String = "Hello", Optional ByVal name As String = "Friend")
	Console.WriteLine(greeting & ", " & name)
End Sub

Wir können diese Methode nur mit dem ersten Parameter aufrufen:

ShowGreetings("Hi");

ShowGreetings("Hi");

ShowGreetings("Hi")

Oder wir können benannte Argumente verwenden, um einen Wert für den Namen anzugeben, während wir das Argument Gruß weglassen:

ShowGreetings(name: "John");

ShowGreetings(name: "John");

ShowGreetings(name:= "John")

Was ist der Vorteil der Verwendung benannter Parameter?

Benannte Parameter in C# bieten mehrere Vorteile:

1. bessere Lesbarkeit": Benannte Parameter können Ihren Code leichter lesbar und verständlich machen. Indem Sie den Namen des Parameters angeben, machen Sie deutlich, wofür jedes Argument steht. Dies kann insbesondere bei Methoden mit mehreren Parametern von Vorteil sein.

2. flexible Argumentreihenfolge": Bei benannten Parametern können Sie die Argumente in beliebiger Reihenfolge angeben, nicht nur in der Reihenfolge, in der die Parameter in der Methodenerklärung erscheinen. Dies kann Ihren Code flexibler machen und in manchen Fällen die Lesbarkeit verbessern.

3. leichtigkeit mit optionalen Parametern": Benannte Parameter werden häufig mit optionalen Parametern verwendet. Wenn eine Methode mehrere optionale Parameter hat, können Sie diese Parameter verwenden, um Werte für einige optionale Parameter zu liefern, für andere nicht. Auf diese Weise müssen Sie nicht für jeden optionalen Parameter einen Wert angeben, sondern nur für diejenigen, die Sie von den Standardwerten abweichen lassen wollen.

   Hier ist ein weiteres Beispiel für den Werttyp "benannte Parameter":

// Method Declaration
public void RegisterUser(string username, string password, string email = "", bool subscribeToNewsletter = false)
{
    // Method body
}

// Method Call
RegisterUser(username: "JohnDoe", password: "password123", subscribeToNewsletter: true);

// Method Declaration
public void RegisterUser(string username, string password, string email = "", bool subscribeToNewsletter = false)
{
    // Method body
}

// Method Call
RegisterUser(username: "JohnDoe", password: "password123", subscribeToNewsletter: true);

' Method Declaration
Public Sub RegisterUser(ByVal username As String, ByVal password As String, Optional ByVal email As String = "", Optional ByVal subscribeToNewsletter As Boolean = False)
	' Method body
End Sub

' Method Call
RegisterUser(username:= "JohnDoe", password:= "password123", subscribeToNewsletter:= True)

Im obigen Code ist email ein optionaler Parameter, den wir weggelassen haben, und wir haben uns entschieden, subscribeToNewsletter auf true zu setzen, auch wenn es der letzte Parameter in der Liste ist. Die Verwendung von benannten Parametern macht deutlich, wofür jedes Argument steht, und erlaubt es uns, nur die Argumente anzugeben, die wir bereitstellen wollen.

Standardparameter und Methodenüberladung

Was ist Methodenüberladung?

In C# ist die Methodenüberladung oder Funktionsüberladung eine Funktion, mit der Sie mehrere Methoden mit demselben Namen, aber mit unterschiedlichen Parametern definieren können. Auf diese Weise können Sie verschiedene Operationen unter Verwendung desselben Methodennamens durchführen, was Ihren Code intuitiver und benutzerfreundlicher macht.

Betrachten Sie das folgende Codebeispiel für überladene Methoden:

public void DisplayMessage(string message)
{
    Console.WriteLine(message);
}

public void DisplayMessage(string message, string name)
{
    Console.WriteLine(message + ", " + name);
}

public void DisplayMessage(string message)
{
    Console.WriteLine(message);
}

public void DisplayMessage(string message, string name)
{
    Console.WriteLine(message + ", " + name);
}

Public Sub DisplayMessage(ByVal message As String)
	Console.WriteLine(message)
End Sub

Public Sub DisplayMessage(ByVal message As String, ByVal name As String)
	Console.WriteLine(message & ", " & name)
End Sub

In dem obigen Beispiel wird die Methode "DisplayMessage" überladen. Eine Version der Methode nimmt einen einzelnen "String"-Parameter, die andere zwei "String"-Parameter.

Verwendung von Standardparametern anstelle von Überladung

Standardparameter können oft als Alternative zum Überladen verwendet werden. Indem Sie einen Standardwert für einen Parameter in Ihrer Methode angeben, können Sie dem Aufrufer die Wahl lassen, ob er diesen Parameter bereitstellen will. Dies kann Ihrer Methode die gleiche Flexibilität verleihen wie das Überladen von Methoden, aber mit weniger Code.

So könnten Sie das obige Beispiel umschreiben, indem Sie einen Standardparameter anstelle der Überladung verwenden:

public void DisplayMessage(string message, string name = "Friend")
{
    Console.WriteLine(message + ", " + name);
}

public void DisplayMessage(string message, string name = "Friend")
{
    Console.WriteLine(message + ", " + name);
}

Public Sub DisplayMessage(ByVal message As String, Optional ByVal name As String = "Friend")
	Console.WriteLine(message & ", " & name)
End Sub

Jetzt kann "DisplayMessage" entweder mit einem oder mit zwei Argumenten aufgerufen werden:

DisplayMessage("Hello");
DisplayMessage("Hello", "John");

DisplayMessage("Hello");
DisplayMessage("Hello", "John");

DisplayMessage("Hello")
DisplayMessage("Hello", "John")

Beim ersten Aufruf wird für den Parameter "Name" der Standardwert "Friend" verwendet. Beim zweiten Aufruf wird stattdessen das übergebene Argument "John" verwendet.

Denken Sie daran, dass der Standardwert für einen Standardparameter ein konstanter Ausdruck sein muss, d. h. es kann sich nicht um eine Variable oder einen Methodenaufruf handeln. Der Grund dafür ist, dass der Wert zur Kompilierzeit bekannt sein muss.

Iron Software Suite

Die Iron Software Suite umfasst folgende Komponenten IronPDF, IronXL, IronOCRund IronBarcode. Diese leistungsstarken Bibliotheken wurden speziell entwickelt, um die Möglichkeiten Ihrer C#-Anwendungen zu erweitern. Sie können leicht mit den Konzepten in Verbindung gebracht werden, die wir in diesem Artikel besprochen haben, einschließlich Standardparameter, Spezifikationen für benannte Argumente und Methodenüberladung.

IronPDF: Dies ist eine C#-Bibliothek für konvertierung von HTML in PDF. Das Verständnis von Standard- und optionalen Parametern kann bei der Verwendung von IronPDF entscheidend sein. Viele der Methoden in IronPDF haben optionale Parameter, die eine umfassende Anpassung ermöglichen, ohne die Methodensignaturen zu kompliziert zu machen. Mehr dazu finden Sie auf der IronPDF HTML-zu-PDF-Tutorial seite.

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

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 Class

IronXL: Diese Bibliothek ermöglicht Ihrer C#-Anwendung das Lesen, Schreiben und Bearbeiten von Excel-Dateien in verschiedenen Formaten. Die Methoden in IronXL können unterschiedliche Parameter haben, z.B. für das Format, in dem eine Datei gespeichert werden soll, oder dafür, ob beim Importieren von Daten Kopfzeilen mit einbezogen werden sollen. Sie werden feststellen, dass benannte und optionale Parameter ausgiebig für die Angabe von Zellbereichen, Formatierungsoptionen und mehr verwendet werden.

IronOCR: Eine fortschrittliche optische Zeichenerkennung (OCR) bibliothek, die Text und Barcodes aus Bildern und PDFs in Ihren C#-Anwendungen lesen kann. Die IronOCR-Methoden können optionale Parameter zur Steuerung von Aspekten des OCR-Prozesses enthalten, wie z. B. die Sprache des Textes, den Grad der anzuwendenden Fehlerkorrektur und so weiter. Wenn Sie diese Parameter verstehen, können Sie den OCR-Prozess besser kontrollieren.

IronBarcode: Diese Bibliothek ist ein vielseitiges Werkzeug zum Lesen und Generieren von Barcodes in .NET-Anwendungen. Auch hier ist das Verständnis der Standardparameter entscheidend. Bei der Erstellung eines Strichcodes können Sie beispielsweise optionale Parameter zur Angabe der Größe, des Formats oder des Werts des Strichcodes verwenden.

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass die Beherrschung der Verwendung von Standard- und optionalen Parametern in C# Ihre Programmiereffizienz und die Vielseitigkeit Ihres Codes erheblich verbessern kann. Diese Konzepte sind grundlegend für C#.

Apropos diese Bibliotheken, denken Sie daran, dass die individuellen Lizenzen für jede von ihnen mit $749 beginnen, und diese Bibliotheken bieten auch eine kostenloser Test. Iron Software bietet jedoch ein Pauschalangebot: Sie können die gesamte Suite zum Preis von nur zwei Einzellizenzen erwerben.