C# Case-Anweisung (Wie es funktioniert für Entwickler)

Die switch-Anweisung in C# bietet eine schlankere und besser lesbare Alternative zu mehreren if-else-Anweisungen. Es ist von Vorteil, wenn Sie eine Variable haben, die einen von mehreren verschiedenen Werten annehmen kann, und Sie müssen je nach Wert unterschiedlichen Code ausführen. Diese Case-Anweisung wertet einen Ausdruck aus und führt statischen ungültigen Hauptcode auf der Grundlage des übereinstimmenden Wertes aus, wodurch sie zu einem integralen Bestandteil der Entscheidungsfindung in Ihrem Code wird.

Während if-else-Strukturen für einfache Bedingungen oder Prüfungen gut geeignet sind, glänzen switch case-Anweisungen bei komplexeren Bedingungsprüfungen, insbesondere bei solchen, die auf einer einzelnen Variablen oder einem Mustervergleichsausdruck basieren. Sie bieten eine sauberere und verständlichere Syntax als die if-Anweisung, was sowohl für das Schreiben als auch für die Wartung desselben Codes entscheidend ist.

Grundlagen der Switch-Anweisung

Was ist eine Switch-Anweisung?

Eine switch-Anweisung in C# ist eine Kontrollstruktur, mit der einer von mehreren Codepfaden zur Ausführung ausgewählt wird. Die Auswahl basiert auf dem Wert oder einem Ausdruck mit einem der Datentypen. Dies ist eine effiziente Alternative zur Verwendung mehrerer if-else-Bedingungen, insbesondere wenn es sich um eine Variable handelt, die mehrere unterschiedliche Werte haben kann.

Syntax

Die grundlegende Syntax einer switch-Anweisung ist einfach:

//switch statement
switch (variable)
{
    case value1:
        // Code to execute if variable equals value1
        break;
    case value2:
        // Code to execute if variable equals value2
        break;
    // More cases as needed
    default:
        // Code to execute if variable doesn't match any case or fall through behavior
        break;
}

//switch statement
switch (variable)
{
    case value1:
        // Code to execute if variable equals value1
        break;
    case value2:
        // Code to execute if variable equals value2
        break;
    // More cases as needed
    default:
        // Code to execute if variable doesn't match any case or fall through behavior
        break;
}

'switch statement
Select Case variable
	Case value1
		' Code to execute if variable equals value1
	Case value2
		' Code to execute if variable equals value2
	' More cases as needed
	Case Else
		' Code to execute if variable doesn't match any case or fall through behavior
End Select

• Schalter (variabel)`: Hier geben Sie die Variable oder den Ausdruck an, der ausgewertet werden soll, wie im obigen Programm gezeigt.
• Fall Wert1: Dies sind die verschiedenen Werte oder Bedingungen, die Sie für die Variable prüfen.
• Break: Dieses Schlüsselwort wird verwendet, um den Switch-Block zu verlassen, sobald ein passender Fall ausgeführt wurde.
• Anweisung default: Dieser optionale "goto"-Block wird ausgeführt, wenn keiner der angegebenen Fälle auf die Variable zutrifft.

Verstehen der Break-Anweisung

Die Break-Anweisung im Switch ist entscheidend. Sie verhindert das "Fall Through"-Verhalten, bei dem die Ausführung zum nächsten Fall übergeht, auch wenn die entsprechende Bedingung bereits erfüllt ist. Jeder Case-Block endet normalerweise mit einer Break-Anweisung, um sicherzustellen, dass nur der Code unter dem entsprechenden Case ausgeführt wird.

Vergleich von Switch-Anweisungen und If-Else-Anweisungen

Während die Struktur der if-else-Anweisung die Überprüfung einer Bedingung und die Ausführung eines Code-Blocks beinhaltet, wenn die Bedingung erfüllt ist, wird bei switch-Anweisungen eine einzelne Variable oder ein Ausdruck mit mehreren möglichen Werten verglichen. Dadurch wird die switch-Anweisung übersichtlicher und leichter zu lesen, wenn Sie viele Bedingungen oder Fallmuster zu prüfen haben.

Beispiel: Verwendung einer Switch-Anweisung

int number = 3;
switch (number)
{
    case 1:
        Console.WriteLine("One");
        break;
    case 2:
        Console.WriteLine("Two");
        break;
    case 3:
        Console.WriteLine("Three");
        break;
    default:
        Console.WriteLine("Other Number");// print to console
        break;
}

int number = 3;
switch (number)
{
    case 1:
        Console.WriteLine("One");
        break;
    case 2:
        Console.WriteLine("Two");
        break;
    case 3:
        Console.WriteLine("Three");
        break;
    default:
        Console.WriteLine("Other Number");// print to console
        break;
}

Dim number As Integer = 3
Select Case number
	Case 1
		Console.WriteLine("One")
	Case 2
		Console.WriteLine("Two")
	Case 3
		Console.WriteLine("Three")
	Case Else
		Console.WriteLine("Other Number") ' print to console
End Select

In diesem Beispiel wird das Programm "Drei" ausgeben, da die Zahl dem Fall 3 entspricht.

Die Rolle des Standardfalls

Verstehen der Voreinstellung in einem Schalterblock

In einer switch-Anweisung spielt der Standardfall eine entscheidende Rolle. Sie dient als Auffangoption, die ausgeführt wird, wenn keine der angegebenen Fallbezeichnungen mit dem Wert des Schalterausdrucks übereinstimmt. Obwohl es optional ist, ist es eine gute Praxis, einen Standardfall einzuschließen, insbesondere um unerwartete oder unbekannte Werte zu behandeln.

Wie und wann Sie die Standardbescheinigung verwenden

Der Standardfall wird verwendet, wenn Sie einen Codeblock ausführen möchten, auf den keiner der spezifischen Fälle zutrifft. Sie stellt sicher, dass die switch-Anweisung unabhängig von der Eingabe immer ein bestimmtes Verhalten aufweist. Der Standardfall wird mit dem Schlüsselwort default, gefolgt von einem Doppelpunkt, angegeben.

default:
    // Code to execute if no case matches
    break;

default:
    // Code to execute if no case matches
    break;

Case Else
	' Code to execute if no case matches
	break

Der Standardfall kann an beliebiger Stelle innerhalb des Schalterblocks stehen, wird aber aus Gründen der Lesbarkeit in der Regel an das Ende gesetzt.

Beispiel: Switch-Anweisung mit Standardfall

Stellen Sie sich ein Szenario vor, in dem Sie einen Wochentag auswerten:

int day = 5;
string dayName;
switch (day)
{
    case 1:
        dayName = "Monday";
        break;
    case 2:
        dayName = "Tuesday";
        break;
    case 3:
        dayName = "Wednesday";
        break;
    case 4:
        dayName = "Thursday";
        break;
    case 5:
        dayName = "Friday";
        break;
    case 6:
        dayName = "Saturday";
        break;
    case 7:
        dayName = "Sunday";
        break;
    default:
        dayName = "Invalid day";
        break;
}
Console.WriteLine(dayName);

int day = 5;
string dayName;
switch (day)
{
    case 1:
        dayName = "Monday";
        break;
    case 2:
        dayName = "Tuesday";
        break;
    case 3:
        dayName = "Wednesday";
        break;
    case 4:
        dayName = "Thursday";
        break;
    case 5:
        dayName = "Friday";
        break;
    case 6:
        dayName = "Saturday";
        break;
    case 7:
        dayName = "Sunday";
        break;
    default:
        dayName = "Invalid day";
        break;
}
Console.WriteLine(dayName);

Dim day As Integer = 5
Dim dayName As String
Select Case day
	Case 1
		dayName = "Monday"
	Case 2
		dayName = "Tuesday"
	Case 3
		dayName = "Wednesday"
	Case 4
		dayName = "Thursday"
	Case 5
		dayName = "Friday"
	Case 6
		dayName = "Saturday"
	Case 7
		dayName = "Sunday"
	Case Else
		dayName = "Invalid day"
End Select
Console.WriteLine(dayName)

In diesem Beispiel wird, wenn "Tag" einen anderen Wert als 1 bis 7 hat, der Standardfall ausgeführt und "Tagesname" auf "Ungültiger Tag" gesetzt.

Bewährte Praktiken für den Standardfall

Stets einen Standardfall einbeziehen: Auch wenn Sie glauben, dass Sie alle möglichen Fälle abgedeckt haben, sollten Sie einen Standardfall vorsehen, um unvorhergesehene Werte zu behandeln.

Sinnvolle Aktionen: Verwenden Sie den Standardfall, um sinnvolle Aktionen durchzuführen, z. B. einen Fehler zu protokollieren, einen Standardwert zu setzen oder den Benutzer über einen unbekannten Wert zu benachrichtigen.

Erweiterte Schalterfunktionen

Einführung in Switch-Ausdrücke in C##

Mit der Entwicklung von C# wurden Switch-Ausdrücke als prägnantere und aussagekräftigere Methode zur Handhabung mehrerer bedingter Verzweigungen eingeführt. Im Gegensatz zu traditionellen switch-Anweisungen geben switch-Ausdrücke einen Wert zurück und sind schlanker, was sie zu einem leistungsstarken Werkzeug in der modernen C#-Programmierung macht.

Syntax der Schalterausdrücke

Die Syntax eines switch-Ausdrucks in C# ist eine kompaktere Form der switch case-Anweisung. Hier ist eine Grundstruktur:

var result = variable switch
{
    value1 => result1,
    value2 => result2,
    _ => defaultResult
};

var result = variable switch
{
    value1 => result1,
    value2 => result2,
    _ => defaultResult
};

'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'var result = variable switch
'{
'	value1 => result1,
'	value2 => result2,
'	_ => defaultResult
'};

Der Unterstrich (_) symbol stellt den Standardfall in switch-Ausdrücken dar und funktioniert ähnlich wie der Standardblock in herkömmlichen switch-Anweisungen.

Beispiel: Verwendung eines Switch-Ausdrucks

Stellen Sie sich ein Szenario vor, in dem Sie eine Temperaturmessung kategorisieren müssen:

int temperature = 25;
string weatherDescription = temperature switch
{
    <= 0 => "Freezing",
    < 20 => "Cold",
    < 30 => "Mild",
    _ => "Hot"
};
Console.WriteLine(weatherDescription);

int temperature = 25;
string weatherDescription = temperature switch
{
    <= 0 => "Freezing",
    < 20 => "Cold",
    < 30 => "Mild",
    _ => "Hot"
};
Console.WriteLine(weatherDescription);

Dim temperature As Integer = 25
'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'string weatherDescription = temperature switch
'{
'	<= 0 => "Freezing",
'	< 20 => "Cold",
'	< 30 => "Mild",
'	_ => "Hot"
'};
Console.WriteLine(weatherDescription)

In diesem Beispiel kategorisiert der switch-Ausdruck die Temperatur kurz und bündig, wobei der Standardfall (_) die alle Szenarien abdecken, die nicht von den anderen Fällen abgedeckt werden.

Mustervergleich mit Switch-Ausdrücken

Switch-Ausdrücke in C# ermöglichen den Abgleich von Mustern, was sie noch vielseitiger macht. Sie können Typen, Werte oder sogar Muster abgleichen:

object obj = // some object;
string description = obj switch
{
    int i => $"Integer: {i}",
    string s => $"String: {s}",
    _ => "Unknown type"
};

object obj = // some object;
string description = obj switch
{
    int i => $"Integer: {i}",
    string s => $"String: {s}",
    _ => "Unknown type"
};

'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'object obj = string description = obj switch
'{
'	int i => $"Integer: {i}",
'	string s => $"String: {s}",
'	_ => "Unknown type"
'};

C# Switch-Anweisung vs. Switch-Ausdruck

C# Switch-Anweisung: Wird traditionell für die Ausführung verschiedener Codeblöcke auf der Grundlage des Werts einer Variablen verwendet. Sie erfordert für jeden Fall eine Break-Anweisung.

Switch-Ausdruck: Dieser in C# 8.0 eingeführte Ausdruck bietet eine prägnantere Syntax und wird in der Regel verwendet, wenn ein Wert auf der Grundlage einer Bedingung zurückgegeben werden muss.

Integration von Switch-Anweisungen mit IronPDF in C#;

IronPDF ist eine .NET PDF-Bibliothek zum Erstellen, Bearbeiten und Arbeiten mit PDF-Dokumenten. In Kombination mit C#-Switch-Anweisungen oder -Ausdrücken wird es zu einem leistungsfähigen Werkzeug für die Handhabung verschiedener PDF-bezogener Operationen auf der Grundlage bestimmter Bedingungen. Diese Integration ist besonders nützlich für Aufgaben, die Entscheidungen auf der Grundlage von PDF-Inhalten oder Metadaten erfordern.

Das Hauptmerkmal von IronPDF ist die Konvertierung HTML zu PDF, während Layouts und Stile intakt bleiben. Dies ist ideal für das Erstellen von PDFs aus Webinhalten, einschließlich Berichten, Rechnungen und Dokumentationen. HTML-Dateien, URLs und HTML-Strings können alle in PDF-Dateien 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

Beispiel: Bedingtes Wasserzeichen mit IronPDF und Switch-Anweisungen

Nehmen wir ein Szenario an, in dem Sie ein PDF-Dokument haben und Folgendes tun möchten verschiedene Wasserzeichen anwenden basierend auf der Anzahl der Seiten des Dokuments. Hier sehen Sie, wie Sie dies mit IronPDF in Kombination mit einer C# Switch-Anweisung erreichen können:

using IronPdf;
IronPdf.License.LicenseKey = "Your-License-Code";
PdfDocument pdf = PdfDocument.FromFile("sample.pdf");
// Define different watermark HTML for each case
string watermarkHtmlOnePage = "<div style='color:red;'>One Page Document</div>";
string watermarkHtmlTwoPage = "<div style='color:blue;'>Two Page Document</div>";
switch (pdf.PageCount)
{
    case 1:
        // Apply watermark for one-page document
        pdf.ApplyWatermark(watermarkHtmlOnePage);
        break;
    case 2:
        // Apply watermark for two-page documents
        pdf.ApplyWatermark(watermarkHtmlTwoPage);
        break;
    default:
        // Apply a default watermark for other cases
        pdf.ApplyWatermark("<div style='color:green;'>Multiple Page Document</div>");
        break;
}
// Save the watermarked PDF
pdf.SaveAs("watermarked.pdf");

using IronPdf;
IronPdf.License.LicenseKey = "Your-License-Code";
PdfDocument pdf = PdfDocument.FromFile("sample.pdf");
// Define different watermark HTML for each case
string watermarkHtmlOnePage = "<div style='color:red;'>One Page Document</div>";
string watermarkHtmlTwoPage = "<div style='color:blue;'>Two Page Document</div>";
switch (pdf.PageCount)
{
    case 1:
        // Apply watermark for one-page document
        pdf.ApplyWatermark(watermarkHtmlOnePage);
        break;
    case 2:
        // Apply watermark for two-page documents
        pdf.ApplyWatermark(watermarkHtmlTwoPage);
        break;
    default:
        // Apply a default watermark for other cases
        pdf.ApplyWatermark("<div style='color:green;'>Multiple Page Document</div>");
        break;
}
// Save the watermarked PDF
pdf.SaveAs("watermarked.pdf");

Imports IronPdf
IronPdf.License.LicenseKey = "Your-License-Code"
Dim pdf As PdfDocument = PdfDocument.FromFile("sample.pdf")
' Define different watermark HTML for each case
Dim watermarkHtmlOnePage As String = "<div style='color:red;'>One Page Document</div>"
Dim watermarkHtmlTwoPage As String = "<div style='color:blue;'>Two Page Document</div>"
Select Case pdf.PageCount
	Case 1
		' Apply watermark for one-page document
		pdf.ApplyWatermark(watermarkHtmlOnePage)
	Case 2
		' Apply watermark for two-page documents
		pdf.ApplyWatermark(watermarkHtmlTwoPage)
	Case Else
		' Apply a default watermark for other cases
		pdf.ApplyWatermark("<div style='color:green;'>Multiple Page Document</div>")
End Select
' Save the watermarked PDF
pdf.SaveAs("watermarked.pdf")

Hier ist die PDF-Ausgabedatei von einer Seite:

Schlussfolgerung

In diesem Tutorium haben wir die switch case-Anweisung in C# kennengelernt, eine Art der Entscheidungsfindung in der Programmierung. Wir begannen damit, die Grundstruktur zu verstehen und verglichen sie mit traditionellen if-else-Anweisungen, wobei wir ihre Vorteile in Bezug auf Lesbarkeit und Einfachheit bei der Handhabung mehrerer Bedingungen hervorhoben.

Wir erstellen einfache Schaltfälle, behandeln verschiedene Szenarien mit dem Standardfall und erkunden erweiterte Funktionen wie Schaltausdrücke. Die praktische Anwendung von Switch-Anweisungen wurde anhand eines Beispiels demonstriert, bei dem IronPDF für die dynamische PDF-Verarbeitung integriert wurde, um zu zeigen, wie wertvoll Switch-Anweisungen im Werkzeugkasten eines Programmierers sein können.

IronPDF bietet eine kostenloser Testund ermöglicht es Ihnen, die Merkmale und Funktionen zu erkunden. Für die dauerhafte Nutzung und den Zugriff auf die komplette Suite von IronPDF gibt es Lizenzen ab $749, die eine umfassende Lösung für alle Ihre PDF-Verarbeitungsanforderungen in C# bieten.