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

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

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

Heute werden wir in die Welt von C# eintauchen und ein leistungsstarkes Feature kennenlernen - Standardparameter. Wir werden es auf eine leicht verständliche Weise aufschlüsseln und uns dabei auf das Konzept des Standardargumentwerts und optionaler Argumente in C# konzentrieren.

Was sind Standardparameter?

In C# ermöglichen Standardparameter, auch bekannt als optionale Argumentparameter, Ihnen, einem festen Argument in einer Methodendefinition einen Wert zuzuweisen. Wenn bei einem Funktionsaufruf kein Argument für diesen Parameter angegeben wird, wird der Standardwert verwendet.

Ein Standardparameterwert wird in der Methodendefinition festgelegt, wie im folgenden Code-Snippet 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
$vbLabelText   $csharpLabel

Hier ist der Parameter name ein optionales Attribut. Die Zeichenkette "Friend" ist der Standardwert. Wenn Sie Greet() aufrufen, ohne ein Argument zu übergeben, wird "Friend" als Wert für 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. Er hat keinen Standardwert, daher muss immer ein Argument angegeben werden. Der Compiler überprüft den Aufruf der Funktion oder Methode, und wenn der erforderliche Parameter nicht angegeben wird, wird ein Kompilierzeitfehler ausgelöst.

Betrachten wir ein Beispiel:

// Method with required parameters
public void IntroduceYourself(string firstName, string lastName)
{
    Console.WriteLine("Hello, my name is " + firstName + " " + lastName);
}
// Method with required parameters
public void IntroduceYourself(string firstName, string lastName)
{
    Console.WriteLine("Hello, my name is " + firstName + " " + lastName);
}
' Method with required parameters
Public Sub IntroduceYourself(ByVal firstName As String, ByVal lastName As String)
	Console.WriteLine("Hello, my name is " & firstName & " " & lastName)
End Sub
$vbLabelText   $csharpLabel

In dieser Methode sind firstName und lastName erforderliche Parameter. Wenn Sie IntroduceYourself aufrufen, müssen Sie für beide Parameter Werte angeben. Wenn Sie Argumente weglassen, erhalten Sie einen Kompilierzeitfehler.

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
$vbLabelText   $csharpLabel

Optionale Parameter

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

Beispielsweise können wir die Methode IntroduceYourself so ändern, dass der lastName-Parameter optional wird:

// Method with an optional parameter
public void IntroduceYourself(string firstName, string lastName = "Doe")
{
    Console.WriteLine("Hello, my name is " + firstName + " " + lastName);
}
// Method with an optional parameter
public void IntroduceYourself(string firstName, string lastName = "Doe")
{
    Console.WriteLine("Hello, my name is " + firstName + " " + lastName);
}
' Method with an optional parameter
Public Sub IntroduceYourself(ByVal firstName As String, Optional ByVal lastName As String = "Doe")
	Console.WriteLine("Hello, my name is " & firstName & " " & lastName)
End Sub
$vbLabelText   $csharpLabel

Jetzt können Sie IntroduceYourself nur mit dem firstName-Parameter aufrufen. Falls Sie dies tun, wird lastName auf "Doe" zurückgesetzt.

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
$vbLabelText   $csharpLabel

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

Denken Sie daran, dass in der Methodendeklaration erforderliche Parameter immer vor optionalen Parametern aufgelistet werden müssen.

Den Unterschied verstehen

Der Unterschied zwischen erforderlichen und optionalen Parametern ist entscheidend, da er beeinflusst, wie Sie eine Methode aufrufen können. Optionale Parameter bieten Flexibilität, sodass Sie bei nicht benötigten Parametern die Eingabe überspringen können. Auf der anderen Seite stellen erforderliche Parameter sicher, dass die notwendigen Daten immer an die Funktion oder Methode übergeben werden, um Laufzeitfehler zu vermeiden.

Regeln für die Verwendung von Standardparametern

Beim Definieren 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 allen erforderlichen Parametern definiert werden.
  3. Wenn Sie eine Methode mit optionalen Parametern aufrufen, können Sie weggelassene Argumente für die optionalen Parameter in der festgelegten Reihenfolge angeben oder benannte Argumente verwenden.
  4. Der Standardwert wird verwendet, wenn kein optionaler Argumentwert angegeben wird.

Betrachten Sie das folgende Code-Snippet für optionale 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
$vbLabelText   $csharpLabel

In der Main-Methode rufen wir ShowMessage zweimal auf. Beim ersten Mal übergeben wir nur ein Argument, daher verwendet der name-Parameter seinen Standardwert "Friend". Beim zweiten Mal übergeben wir zwei Argumente, sodass "John" anstelle des Standardwerts verwendet wird.

Benannte und optionale Parameter

C# unterstützt auch benannte und optionale Parameter. Benannte Parameter erlauben es Ihnen, einen Wert für einen Parameter nach Namen anzugeben, anstatt nach Position. Dies kann nützlich sein, wenn eine Methode mehrere optionale Parameter hat und Sie für einen davon einen Wert angeben möchten, aber nicht für die anderen.

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
$vbLabelText   $csharpLabel

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

ShowGreetings("Hi");
ShowGreetings("Hi");
ShowGreetings("Hi")
$vbLabelText   $csharpLabel

Oder wir können benannte Argumente verwenden, um einen Wert für name anzugeben, während wir das greeting-Argument weglassen:

ShowGreetings(name: "John");
ShowGreetings(name: "John");
ShowGreetings(name:= "John")
$vbLabelText   $csharpLabel

Was ist der Vorteil der Verwendung benannter Parameter?

Benannte Parameter in C# bieten mehrere Vorteile:

  1. Verbesserte Lesbarkeit: Benannte Parameter können Ihren Code einfacher lesbar und verständlich machen. Indem Sie den Namen des Parameters angeben, wird klar, was jedes Argument darstellt. Dies kann besonders vorteilhaft in Methoden mit mehreren Parametern sein.
  2. Flexible Argumentreihenfolge: Mit benannten Parametern können Sie Argumente in beliebiger Reihenfolge angeben, nicht nur in der Reihenfolge, in der die Parameter in der Methodendeklaration erscheinen. Dies kann Ihren Code flexibler und in manchen Fällen auch lesbarer machen.
  3. Leichtigkeit bei optionalen Parametern: Benannte Parameter werden häufig mit optionalen Parametern verwendet. Wenn eine Methode mehrere optionale Parameter hat, können Sie mit benannten Parametern Werte für einige optionale Parameter angeben, nicht für andere. Auf diese Weise müssen Sie nicht für jeden optionalen Parameter einen Wert angeben, sondern nur für diejenigen, die Sie von ihren Standardwerten abweichen möchten.

Hier ist ein weiteres Beispiel für die Verwendung benannter 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)
$vbLabelText   $csharpLabel

Im obigen Code ist email ein optionaler Parameter, den wir weggelassen haben, und wir haben uns entschieden, subscribeToNewsletter auf true zu setzen, obwohl es der letzte Parameter in der Liste ist. Die Verwendung eines benannten Parameters macht klar, was jedes Argument darstellt und ermöglicht es uns, nur die Argumente anzugeben, die wir übergeben möchten.

Standardparameter und Methodenüberladung

Was ist Methodenüberladung?

In C# ist Methodenüberladung, oder Funktionsüberladung, ein Feature, das es Ihnen erlaubt, mehrere Methoden mit demselben Namen aber einem anderen Satz von Parametern zu definieren. Dies ermöglicht es Ihnen, verschiedene Operationen unter Verwendung desselben Methodennamens durchzuführen, wodurch Ihr Code intuitiver und einfacher zu verwenden wird.

Betrachten Sie das folgende Codebeispiel überladener 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
$vbLabelText   $csharpLabel

Im obigen Beispiel ist die Methode DisplayMessage überladen. Eine Version der Methode nimmt einen einzigen string Parameter, und die andere nimmt zwei string Parameter.

Verwendung von Standardparametern anstelle von Überladung

Standardparameter können oft als Alternative zur Überladung verwendet werden. Indem Sie in Ihrer Methode einen Standardwert für einen Parameter vorsehen, können Sie dem Aufrufer die Wahl lassen, ob er diesen Parameter bereitstellt. Dadurch kann Ihre Methode die gleiche Flexibilität wie die Methodenüberladung aufweisen, jedoch mit weniger Code.

Hier ist, wie Sie das obige Beispiel mit einem Standardparameter anstelle der Überladung umschreiben könnten:

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
$vbLabelText   $csharpLabel

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

DisplayMessage("Hello");
DisplayMessage("Hello", "John");
DisplayMessage("Hello");
DisplayMessage("Hello", "John");
DisplayMessage("Hello")
DisplayMessage("Hello", "John")
$vbLabelText   $csharpLabel

Im ersten Aufruf verwendet der name-Parameter seinen Standardwert "Friend". Beim zweiten Aufruf wird das übergebene Argument "John" anstelle dessen verwendet.

Denken Sie daran, dass der Standardwert für einen Standardparameter ein konstanter Ausdruck sein muss, was bedeutet, dass er keine Variable oder ein Methodenaufruf sein kann. Dies liegt daran, dass der Wert zur Kompilierungszeit bekannt sein muss.

Iron Software Suite

Tauchen wir in die Iron Software Suite ein, die die IronPDF-Bibliothek für PDF-Lösungen, IronXL für C# Excel-Operationen, IronOCR für fortschrittliche Texterkennung und IronBarcode für Barcode-Generierung umfasst. Diese leistungsstarken Bibliotheken sind speziell dazu konzipiert, Ihnen zu helfen, die Fähigkeiten Ihrer C#-Anwendungen zu erweitern. Sie können leicht mit den in diesem Artikel besprochenen Konzepten in Verbindung gebracht werden, einschließlich Standardparameter, benannte Argumentenspezifikationen und Methodenüberladung.

IronPDF: Dies ist eine C#-Bibliothek zum Konvertieren von HTML in PDF mit IronPDF. Das Verständnis von Standard- und optionalen Parametern kann entscheidend sein, wenn man IronPDF verwendet. Viele der Methoden in IronPDF haben optionale Parameter, die eine umfassende Anpassung ermöglichen, ohne die Methodensignaturen zu verkomplizieren. Mehr dazu finden Sie im IronPDF HTML zu PDF Tutorial.

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
$vbLabelText   $csharpLabel

IronXL: Diese Bibliothek ermöglicht es Ihrer C#-Anwendung, Excel-Dateien in verschiedenen Formaten zu lesen, zu schreiben und zu manipulieren. Methoden in IronXL können unterschiedliche Parameter haben, wie z.B. das Format, in dem eine Datei gespeichert werden soll, oder ob Kopfzeilen beim Importieren von Daten einbezogen werden sollen. Sie werden vielleicht auch feststellen, dass benannte und optionale Parameter häufig 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 Methoden von IronOCR können optionale Parameter für die Steuerung von Aspekten des OCR-Prozesses haben, wie z.B. die Sprache des Textes, den Grad der Fehlerkorrektur, der angewandt wird, und so weiter. Das Verständnis dieser Parameter kann Ihnen eine bessere Kontrolle über den OCR-Prozess geben.
IronBarcode: Diese Bibliothek ist ein vielseitiges Werkzeug zum Lesen und Generieren von Barcodes in .NET-Anwendungen. Auch hier ist das Verständnis von Standardparametern entscheidend. Beim Generieren eines Barcodes können Sie beispielsweise optionale Parameter verwenden, um die Größe, das Format oder den Wert des Barcodes anzugeben.

Abschluss

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

Apropos dieser Bibliotheken, denken Sie daran, dass die individuellen Lizenzen für jede von $799 beginnen, und diese Bibliotheken bieten auch eine kostenlose Testversion der Iron Software Produkte an. Allerdings bietet Iron Software ein Paketangebot: Sie können die gesamte Suite zum Preis von nur zwei individuellen Lizenzen erwerben.

Häufig gestellte Fragen

Wie verbessern Standardparameter die Codeeffizienz in C#?

Standardparameter in C# ermöglichen es Entwicklern, vordefinierte Werte an Methodenargumente zuzuweisen, wodurch die Notwendigkeit für mehrere Methodenüberladungen reduziert und die Wartung des Codes vereinfacht wird.

Können Standardparameter mit benannten Parametern in C# verwendet werden?

Ja, Standardparameter können mit benannten Parametern in C# kombiniert werden, wodurch Entwickler nur die notwendigen Argumente anhand des Namens angeben können, was die Lesbarkeit und Flexibilität des Codes erhöht.

Was sind die Vorteile der Verwendung von optionalen Parametern in C#?

Optionale Parameter in C# bieten Flexibilität, indem sie es erlauben, bei Methodenaufrufen bestimmte Argumente wegzulassen, die auf vordefinierte Werte zurückgreifen, wodurch der Methodenaufruf vereinfacht und Code-Redundanz verringert wird.

Wie unterscheidet sich die Methodenüberladung von der Verwendung von Standardparametern in C#?

Methodenüberladung beinhaltet das Erstellen mehrerer Methoden mit demselben Namen, aber unterschiedlichen Parametern, während Standardparameter einer einzigen Methode ermöglichen, durch Bereitstellung von Rückfallwerten für weggelassene Argumente mehrere Szenarien zu bedienen.

Welche Regeln sollten bei der Verwendung von Standardparametern in C# befolgt werden?

Wichtige Regeln beinhalten die Sicherstellung, dass Standardwerte konstante Ausdrücke sind, die Platzierung von optionalen Parametern nach den erforderlichen und die Nutzung von benannten Argumenten zur Spezifikation von weggelassenen Parametern.

Wie können Standardparameter die Nutzung der IronPDF-Bibliothek optimieren?

In IronPDF können Standardparameter die PDF-Generierung vereinfachen, indem sie Entwicklern ermöglichen, Einstellungen wie HTML-Inhalte oder Dateipfade anzupassen, ohne jedes Argument anzugeben, und somit die Ausgabe effizient zu individualisieren.

Welche Rolle spielen benannte Parameter bei der Verbesserung der Code-Lesbarkeit?

Benannte Parameter ermöglichen es, Argumente anhand des Namens statt der Position anzugeben, wodurch der Code leichter lesbar wird und Fehler in Bezug auf die Argumentreihenfolge reduziert werden.

Warum ist das Beherrschen von Standardparametern für Entwickler kritisch?

Das Beherrschen von Standardparametern ist entscheidend, da es die Programmier-Effizienz verbessert, indem es Flexibilität in Methodenaufrufen bietet, sicherstellt, dass die notwendigen Daten bereitgestellt werden und die Code-Struktur vereinfacht.

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