C# Switch Expression (So funktioniert es für Entwickler)

C# wird kontinuierlich weiterentwickelt und enthält Funktionen, die die Ausdruckskraft der Sprache erhöhen und die Erfahrung der Entwickler insgesamt verbessern. Unter diesen Merkmalen ist der Switch-Ausdruck besonders hervorzuheben, der als wirksames und prägnantes Instrument zur Verwaltung mehrerer Bedingungen innerhalb eines einzigen Ausdrucks dient.

Diese umfassende Untersuchung befasst sich mit den Feinheiten des C#-Switch-Ausdrucks und bietet Beispiele, die seine Syntax, Anwendungen und Vorteile hervorheben.

Von Mustervergleichen und konstanten Werten bis hin zu Typmustern und der Verwendung von Schlüsselwörtern wie "switch" und "case" navigieren wir durch die verschiedenen Elemente dieser Sprachfunktion. Die Diskussion umfasst verschiedene Muster, wie Konstantenmuster, relationale Muster und Typmuster, und erläutert ihre Rolle im Kontext des Schalterausdrucks.

Darüber hinaus untersuchen wir die Einbindung von Switch-Ausdrücken in reale Szenarien, um ihren Nutzen zu demonstrieren und Klarheit über ihre Syntax und Implementierung zu schaffen. Mehr Insiderwissen über Schalterausdrücke finden Sie hier artikel.

In diesem Artikel werden wir die Beispiele für Switch-Ausdrücke durchgehen und ihren Anwendungsfall mit IronPDF C# PDF-Bibliothek.

1. Einführung in Switch Expression

Der Switch-Ausdruck, der in C# 8.0 eingeführt wurde, stellt einen Paradigmenwechsel in der Art und Weise dar, wie Entwickler mit bedingter Logik umgehen. Traditionell war die switch-Anweisung das Mittel der Wahl für Verzweigungen auf der Grundlage verschiedener Werte, aber sie hatte Einschränkungen in Bezug auf die Ausführlichkeit und Flexibilität bei der Verwendung von Schlüsselwörtern. Der Switch-Ausdruck geht auf diese Probleme ein, indem er eine prägnante Syntax bietet, die einen ausdrucksstarken und funktionalen Code ermöglicht.

In seiner einfachsten Form ähnelt der switch-Ausdruck einer herkömmlichen switch-Anweisung, ist aber vielseitiger. Er wertet einen Ausdruck aus und wählt auf der Grundlage des Wertes dieses Ausdrucks eine Verzweigung aus. Dieser Paradigmenwechsel ermöglicht es den Entwicklern, saubereren, besser lesbaren Code zu schreiben, der weniger Standardformulierungen enthält.

2. Syntax und grundlegende Verwendung

Die Syntax des C#-Switch-Ausdrucks ist intuitiv, so dass sie von Entwicklern, die mit traditionellen Switch-Anweisungen vertraut sind, leicht übernommen werden kann. Hier ein einfaches Beispiel

string result = input switch 
    { 
    "case1" => "Result for case 1",
    "case2" => "Result for case 2",
    _ => "Default result for case label" 
    };

string result = input switch 
    { 
    "case1" => "Result for case 1",
    "case2" => "Result for case 2",
    _ => "Default result for case label" 
    };

Dim tempVar As String
Select Case input
	Case "case1"
		tempVar = "Result for case 1"
	Case "case2"
		tempVar = "Result for case 2"
	Case Else
		tempVar = "Default result for case label"
End Select
Dim result As String = tempVar

In diesem Beispiel wird die Variable Eingabe gegen mehrere Fälle ausgewertet. Wenn das Muster auf einen der angegebenen Fälle zutrifft, wird das entsprechende Ergebnis der Variablen Ergebnis zugewiesen. Der Unterstrich (_) steht für den optionalen Standardfall, ähnlich wie das Schlüsselwort default in einer herkömmlichen switch-Anweisung.

Der Switch-Ausdruck unterstützt eine breite Palette von Mustern, einschließlich Konstantenmustern, Typmustern, Typmustern, relationalen Mustern und mehr, was ihn zu einem vielseitigen Werkzeug für die Handhabung komplexer Szenarien macht. Sie kann besonders nützlich sein, wenn es um Aufzählungen geht, da sie die Notwendigkeit von sich wiederholenden case-Anweisungen vermeidet.

3. Fortgeschrittene Patterns und Dekonstruktion

Eine der Stärken des Schalterausdrucks liegt in seiner Fähigkeit, mit fortgeschrittenen Mustern und Dekonstruktionen zu arbeiten. Dies ermöglicht es Entwicklern, Werte aus Objekten, Arrays und Mustern in einer prägnanten Weise zu extrahieren. Betrachten Sie das folgende Beispiel für einen Switch-Ausdruck:

var result = shape switch 
    { 
    (Circle c) => $"Circle with radius {c.Radius}",
    (Rectangle r) => $"Rectangle with dimensions {r.Length}x{r.Width}",
    _ => "Unknown shape" 
    };

var result = shape switch 
    { 
    (Circle c) => $"Circle with radius {c.Radius}",
    (Rectangle r) => $"Rectangle with dimensions {r.Length}x{r.Width}",
    _ => "Unknown shape" 
    };

'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'var result = shape switch
'	{ 
'	(Circle c) => $"Circle with radius {c.Radius}",
'	(Rectangle r) => $"Rectangle with dimensions {r.Length}x{r.Width}",
'	_ => "Unknown shape"
'	};

In diesem Fall wird der anfängliche Eingabewert, die Variable shape, in ihre Bestandteile zerlegt (Kreis oder Rechteck)und die entsprechende Meldung wird auf der Grundlage des Typs und der Werte generiert.

4. Switch-Ausdruck vs. Switch-Anweisung

Obwohl der Switch-Ausdruck Ähnlichkeiten mit dem traditionellen switch-ähnlichen Semantikmuster aufweist, bietet er mehrere Vorteile. Der switch-Schlüsselwortausdruck ist prägnanter, macht break-case-Anweisungen überflüssig und reduziert den Boilerplate-Code. Sie ermöglicht auch die Zuweisung von Werten direkt innerhalb des Ausdrucks, was den Code ausdrucksstärker macht.

Ein weiteres bemerkenswertes Merkmal ist die Möglichkeit, Ausdrücke aus dem Switch-Ausdruck in einem Lambda-Ausdruck oder als Teil eines Elements mit Ausdruck in Methoden oder Eigenschaften zu verwenden, was zu einem funktionalen Programmierstil beiträgt.

Darüber hinaus fördert der Switch-Ausdruck die Verwendung von konstantem Musterabgleich und bietet so eine natürlichere und leistungsfähigere Möglichkeit, verschiedene Fälle zu behandeln.

5. Leistungsüberlegungen und -einschränkungen

Auch wenn die Umstellung viele Vorteile mit sich bringt, ist es wichtig, sich der Leistungsaspekte bewusst zu sein. In einigen Szenarien kann die switch-Anweisung leistungsfähiger sein, insbesondere bei einer großen Anzahl von Fällen. Die Entwickler sollten die spezifischen Anforderungen ihrer Anwendung bewerten und dementsprechend das geeignete Konstrukt wählen.

Außerdem ist zu beachten, dass der switch-Ausdruck die switch-Anweisung nicht vollständig ersetzen kann. Es gibt Fälle, in denen die switch-Anweisung mit ihrem Fall-Through-Verhalten die bessere Wahl sein könnte.

Außerdem ist der Switch-Ausdruck nur in C# 8.0 und neueren Versionen verfügbar, so dass Projekte, die auf frühere Versionen abzielen, keinen Zugriff auf diese Funktion haben.

Das herausragende Merkmal von IronPDF ist seine HTML zu PDF funktion, wobei alle Layouts und Stile erhalten bleiben. Es ermöglicht die Erstellung von PDF-Dateien aus Webinhalten, ideal für Berichte, Rechnungen und Dokumentationen. HTML-Dateien, URLs und HTML-Strings können mühelos in PDFs umgewandelt werden.

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

6. Real-world Anwendung mit IronPDF

Die Anwendung des C#-Switch-Ausdrucks ist in realen Szenarien besonders wirkungsvoll, vor allem bei der Verwaltung mehrerer Bedingungen oder Aufzählungen, wie in einem IronPDF-Anwendungsfall gezeigt wird. Untersuchen wir die praktische Anwendbarkeit in einem Dokumentenklassifizierungssystem

using IronPdf;
using System;
class Program
{
    static void Main()
    {
        // Simulating HTML content for the PDF document
        string htmlContent = GetHtmlContent();
        // Creating IronPDF Document
        var pdfDocument = new ChromePdfRenderer();
        // Converting HTML to PDF
        var pdf = pdfDocument.RenderHtmlAsPdf(htmlContent);
        // Classifying the document based on the page count
        string classification = pdf switch
        {
            { PageCount: 1 } => "Single Page Document",
            { PageCount: >= 2 and <= 10 } => "Small Document",
            { PageCount: > 10 } => "Large Document",
            _ => "Unknown Classification"
        };
        // Save the PDF to a file
        pdf.SaveAs("document_output.pdf");
        // Displaying the classification result
        Console.WriteLine($"PDF created successfully. Document Classification: {classification}");
    }
    static string GetHtmlContent()
    {
        // In a real-world scenario, you would obtain the HTML content from an actual source.
        // For the sake of this example, we'll create a simple HTML string.
        string htmlContent = "<html><body><h1>Hello IronPDF!</h1><p>This is a sample HTML content.</p></body></html>";
        return htmlContent;
    }
}

using IronPdf;
using System;
class Program
{
    static void Main()
    {
        // Simulating HTML content for the PDF document
        string htmlContent = GetHtmlContent();
        // Creating IronPDF Document
        var pdfDocument = new ChromePdfRenderer();
        // Converting HTML to PDF
        var pdf = pdfDocument.RenderHtmlAsPdf(htmlContent);
        // Classifying the document based on the page count
        string classification = pdf switch
        {
            { PageCount: 1 } => "Single Page Document",
            { PageCount: >= 2 and <= 10 } => "Small Document",
            { PageCount: > 10 } => "Large Document",
            _ => "Unknown Classification"
        };
        // Save the PDF to a file
        pdf.SaveAs("document_output.pdf");
        // Displaying the classification result
        Console.WriteLine($"PDF created successfully. Document Classification: {classification}");
    }
    static string GetHtmlContent()
    {
        // In a real-world scenario, you would obtain the HTML content from an actual source.
        // For the sake of this example, we'll create a simple HTML string.
        string htmlContent = "<html><body><h1>Hello IronPDF!</h1><p>This is a sample HTML content.</p></body></html>";
        return htmlContent;
    }
}

Imports IronPdf
Imports System
Friend Class Program
	Shared Sub Main()
		' Simulating HTML content for the PDF document
		Dim htmlContent As String = GetHtmlContent()
		' Creating IronPDF Document
		Dim pdfDocument = New ChromePdfRenderer()
		' Converting HTML to PDF
		Dim pdf = pdfDocument.RenderHtmlAsPdf(htmlContent)
		' Classifying the document based on the page count
'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'		string classification = pdf switch
'		{
'			{ PageCount: 1 } => "Single Page Document",
'			{ PageCount: >= 2 and <= 10 } => "Small Document",
'			{ PageCount: > 10 } => "Large Document",
'			_ => "Unknown Classification"
'		};
		' Save the PDF to a file
		pdf.SaveAs("document_output.pdf")
		' Displaying the classification result
		Console.WriteLine($"PDF created successfully. Document Classification: {classification}")
	End Sub
	Private Shared Function GetHtmlContent() As String
		' In a real-world scenario, you would obtain the HTML content from an actual source.
		' For the sake of this example, we'll create a simple HTML string.
		Dim htmlContent As String = "<html><body><h1>Hello IronPDF!</h1><p>This is a sample HTML content.</p></body></html>"
		Return htmlContent
	End Function
End Class

In diesem C#-Codefragment wird der ChromePdfRenderer von IronPDF verwendet, um simulierte HTML-Inhalte in ein PDF-Dokument zu konvertieren. Die resultierende PDF-Datei wird dann anhand der Seitenzahl mit Hilfe eines Switch-Ausdrucks klassifiziert.

Der Switch-Ausdruck verwendet ein rekursives Muster, um das Dokument in verschiedene Typen zu kategorisieren, z. B. "Einzelseitiges Dokument", "Kleines Dokument" oder "Großes Dokument", abhängig von bestimmten Seitenzahlbereichen. Das klassifizierte Dokument wird anschließend in einer Datei mit dem Namen "document_output.pdf" gespeichert, und eine Konsolenmeldung teilt die erfolgreiche PDF-Erstellung zusammen mit dem Klassifizierungsergebnis mit.

Dieser prägnante und dynamische Ansatz zeigt die Vielseitigkeit des Switch-Ausdrucks bei der effizienten Handhabung verschiedener Szenarien und bietet eine rationelle Möglichkeit, Dokumente anhand ihrer Eigenschaften zu kategorisieren.

6.1. Ausgabekonsole

7. Schlussfolgerung

Der C#-Switch-Ausdruck, der in C# 8.0 als entscheidende Weiterentwicklung der Sprache eingeführt wurde, hat sich zu einem überzeugenden Werkzeug für Entwickler entwickelt, um bedingte Logik zu rationalisieren und die Ausdruckskraft von Code zu verbessern.

Diese umfassende Untersuchung hat sich mit seiner Syntax, seinen Anwendungen und Vorteilen befasst und seine Vielseitigkeit anhand von Beispielen mit verschiedenen Positionsmustern und Schlüsselwörtern wie "switch" und "case" aufgezeigt Von seiner intuitiven Syntax und grundlegenden Verwendung bis hin zu fortgeschrittenen Deklarationsmustern und Dekonstruktionsfähigkeiten hat sich der switch-Ausdruck als unschätzbar wertvoll für die Erstellung von sauberem, lesbarem Code erwiesen.

Der Vergleich mit der traditionellen switch-Anweisung unterstreicht die Prägnanz und die Unterstützung für ausdrucksstarke Konstrukte, einschließlich Lambda-Ausdrücke und ausdrucksstarke Elemente. Die Fähigkeit, sich nahtlos in externe Bibliotheken zu integrieren und zur optimierten PDF-Erzeugung beizutragen, unterstreicht die Rolle des Switch-Ausdrucks bei der Weiterentwicklung moderner C#-Entwicklungspraktiken.

Da C# sich ständig weiterentwickelt, ist der Switch-Ausdruck ein Beweis für das Engagement der Sprache, Entwicklern effiziente und ausdrucksstarke Werkzeuge zur effektiven Problemlösung an die Hand zu geben.