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

Einführung

Kontrollflussanweisungen sind in der Programmierung von entscheidender Bedeutung, da sie die Ausführungsreihenfolge von Anweisungen innerhalb eines Programms vorgeben. In C# sind drei grundlegende Anweisungen zur Steuerung von Schleifen 'continue', 'break' und 'goto'. Diese Anweisungen bieten Programmierern die Möglichkeit, den Ausführungsfluss innerhalb von Schleifen zu ändern und so die Effizienz und Lesbarkeit des Codes zu verbessern. In diesem Artikel tauchen wir in die Feinheiten der continue- und break-Methoden in C# ein, indem wir ihre Syntax, Anwendungen und Best Practices untersuchen. Später im Artikel werden wir auch über IronPDF - eine robuste C# PDF-Bibliothek von Iron Software lernen, um PDF-Dokumente zu lesen und zu schreiben.

Verständnis der 'continue;'-Anweisung

Die continue-Anweisung wird in Schleifenstrukturen verwendet, um den verbleibenden Codeblock zu überspringen und mit der nächsten Iteration der Schleife fortzufahren. Im Wesentlichen weist sie die Programmkontrolle an, den verbleibenden Code der aktuellen Iteration zu überspringen und zur nächsten Iteration überzugehen.

Syntax

continue;

continue;

continue

Beispiel

public class Program
{
    public static void Main()
    {
        Console.WriteLine("Demonstrate Continue Method in C#");
        Console.WriteLine("Print 1 to 10 skip 5");
        for (int i = 0; i < 10; i++)
        {
            if (i == 5)
            {
                continue; // Skips iteration when i equals 5
            }
            Console.WriteLine(i);
        }
    }
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine("Demonstrate Continue Method in C#");
        Console.WriteLine("Print 1 to 10 skip 5");
        for (int i = 0; i < 10; i++)
        {
            if (i == 5)
            {
                continue; // Skips iteration when i equals 5
            }
            Console.WriteLine(i);
        }
    }
}

Public Class Program
	Public Shared Sub Main()
		Console.WriteLine("Demonstrate Continue Method in C#")
		Console.WriteLine("Print 1 to 10 skip 5")
		For i As Integer = 0 To 9
			If i = 5 Then
				Continue For ' Skips iteration when i equals 5
			End If
			Console.WriteLine(i)
		Next i
	End Sub
End Class

In diesem Beispiel wird, wenn i gleich 5 ist, die continue-Anweisung ausgeführt, wodurch der verbleibende Code innerhalb der Schleife für diese Iteration übersprungen wird. Infolgedessen wird die Zahl 5 nicht gedruckt, und die Schleife geht zur nächsten Iteration über.

Ausgabe

Erforschung der "Pause;"-Methode

Im Gegensatz zu continue wird die break-Anweisung verwendet, um eine Schleife vorzeitig zu beenden. Wenn er auftritt, beendet er die Ausführung der Schleife, unabhängig von der Schleifenbedingung. Sie wird häufig verwendet, um eine Schleife, wie z. B. eine while-Schleife, vorzeitig zu beenden, wenn eine bestimmte Bedingung erfüllt ist.

Beispiel

int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
foreach (int number in numbers)
{
    if (number == 6)
    {
        break; // Exits loop when number equals 6
    }
    Console.WriteLine(number);
}

int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
foreach (int number in numbers)
{
    if (number == 6)
    {
        break; // Exits loop when number equals 6
    }
    Console.WriteLine(number);
}

Dim numbers() As Integer = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }
For Each number As Integer In numbers
	If number = 6 Then
		Exit For ' Exits loop when number equals 6
	End If
	Console.WriteLine(number)
Next number

In diesem Beispiel durchläuft die Schleife das Zahlenfeld. Wenn die Zahl 6 auftritt, wird die break-Anweisung ausgeführt, wodurch die Schleife vorzeitig beendet wird. Infolgedessen werden nur die Nummern 1 bis 5 gedruckt.

Erkunden Sie die Anweisung 'goto';.

Die goto-Anweisung in C# bietet eine Möglichkeit, die Kontrolle zu einem angegebenen Label innerhalb derselben Methode, innerhalb derselben Switch-Anweisung oder innerhalb derselben Schleife zu übertragen. Während goto ein leistungsstarkes Werkzeug sein kann, um den Ausführungsfluss zu Sprunganweisungen zu ändern, wird es in modernen Programmierpraktiken oft nicht empfohlen, da es potenziell dazu führen kann, dass der Code weniger lesbar und wartungsfreundlich wird. Es gibt jedoch Situationen, in denen Goto wirksam und sicher eingesetzt werden kann.

Syntax

Die Syntax der goto-Anweisung in C# ist unkompliziert:

goto label;

goto label;

GoTo label

Wo das Label ein Bezeichner gefolgt von einem Doppelpunkt (:) ist, der den Zielort im Code angibt.

Beispiel

Stellen Sie sich ein Szenario vor, in dem Sie eine geschachtelte Schleife vorzeitig verlassen wollen, wenn eine bestimmte Bedingung erfüllt ist. Sie können dies mit einer goto-Anweisung erreichen:

for (int i = 0; i < 5; i++)
{
    for (int j = 0; j < 5; j++)
    {
        if (i * j > 10)
        {
            goto exitLoop;
        }
        Console.WriteLine($"i: {i}, j: {j}");
    }
}
exitLoop:
Console.WriteLine("Exited the nested loop prematurely.");

for (int i = 0; i < 5; i++)
{
    for (int j = 0; j < 5; j++)
    {
        if (i * j > 10)
        {
            goto exitLoop;
        }
        Console.WriteLine($"i: {i}, j: {j}");
    }
}
exitLoop:
Console.WriteLine("Exited the nested loop prematurely.");

For i As Integer = 0 To 4
	For j As Integer = 0 To 4
		If i * j > 10 Then
			GoTo exitLoop
		End If
		Console.WriteLine($"i: {i}, j: {j}")
	Next j
Next i
exitLoop:
Console.WriteLine("Exited the nested loop prematurely.")

In diesem Beispiel überträgt die goto-Anweisung die Kontrolle zum exitLoop-Label, wenn die Bedingung i * j > 10 erfüllt ist, wodurch effektiv aus der verschachtelten Schleife ausgestiegen wird.

Einführung von IronPDF - Umfassende PDF-Bibliothek von Iron Software.

IronPDF, entwickelt von Iron Software, ist eine leistungsstarke C# PDF-Bibliothek, die eine All-in-One-Lösung für die Arbeit mit PDFs in .NET-Projekten bietet. Egal, ob Sie PDF-Dokumente erstellen, bearbeiten, exportieren, sichern, laden oder manipulieren müssen, IronPDF hat alles, was Sie brauchen. Hier sind einige wichtige Funktionen und Anwendungsfälle:

1. HTML-zu-PDF-Konvertierung: Konvertieren Sie HTML-Inhalte nahtlos in das PDF-Format. Sie können PDFs aus HTML, MVC, ASPX und sogar Bildern erzeugen.

2. Signieren, Bearbeiten und Lesen von PDFs: Mit über 50 Funktionen ermöglicht IronPDF das Signieren, Bearbeiten und Extrahieren von Inhalten aus PDF-Dateien. Egal, ob Sie digitale Signaturen hinzufügen oder vorhandene PDFs ändern möchten, IronPDF macht es Ihnen leicht.

3. Plattformübergreifende Unterstützung: IronPDF ist für C#, F# und VB.NET entwickelt und läuft auf verschiedenen .NET-Versionen, einschließlich .NET Core, .NET Standard und .NET Framework. Es ist auch für Java, Node.js und Python verfügbar.

4. Kompatibilität und Umgebungen:

   • .NET-Versionen: Unterstützt C#, VB.NET und F#.

   • Projekttypen: Funktioniert mit Webanwendungen (Blazor & WebForms), Desktop-Anwendungen (WPF & MAUI) und Konsolenanwendungen.

   • Anwendungsumgebungen: Kompatibel mit Windows, Linux, Mac, Docker, Azure, AWS und mehr.

   • IDEs: Integriert sich nahtlos in Microsoft Visual Studio und JetBrains Rider.

   • Betriebssysteme & Prozessoren: Läuft auf Windows, Mac und Linux (x64, x86, ARM).

5. PDF-Standards und -Bearbeitung:

   • Unterstützt verschiedene PDF-Versionen (1.2 - 1.7), PDF/UA und PDF/A.

   • Legen Sie Eigenschaften, Sicherheit und Komprimierung für PDF-Dateien fest.

   • Bearbeiten Sie Metadaten, Änderungshistorie und Dokumentstruktur.

   • Seitenvorlagen, Kopf- und Fußzeilen sowie Seiteneinstellungen anwenden.

6. Leistungsoptimierung:

   • Volle Multithreading- und Async-Unterstützung für effiziente PDF-Erzeugung.

   • Legt Wert auf Genauigkeit, Benutzerfreundlichkeit und Geschwindigkeit.

   Da wir nun über die IronPDF-Bibliothek Bescheid wissen, lassen Sie uns eine Anwendung schreiben, um IronPDF sowie die continue-Anweisung, break-Anweisung und goto-Anweisung zu verwenden.

PDF-Dokument mit Continue-Anweisung generieren

Erstellen wir zunächst eine Visual Studio-Konsolenanwendung

Geben Sie den Namen und den Standort des Projekts an.

Nächster Schritt: Wählen Sie die gewünschte .NET-Version aus und klicken Sie auf Erstellen.

Installieren Sie nun IronPDF mit dem unten stehenden Befehl.

dotnet add package IronPdf --version 2024.4.2

dotnet add package IronPdf --version 2024.4.2

Lassen Sie uns nun ein PDF-Dokument mit Hilfe der Steueranweisungen erstellen.

using System;
using System.Threading.Tasks;
using System.Diagnostics;
using IronPdf;
class Program
{
    public static async Task Main()
    {
        Console.WriteLine("Generate PDF document Using IronPDF");
        var htmlToPdf = new ChromePdfRenderer();
        var content = "<h1>Generate Numbers from 1 to 10, skip 5</h1>";
        for (int i = 0; i < 10; i++)
        {
            if (i == 5)
            {
                continue;
            }
            content += $"<p>{i}</p>";
        }
        content += "<h1>Generate Numbers from 1 to 10, stop at 7</h1>";
        for (int i = 0; i < 10; i++)
        {
            if (i == 7)
            {
                break;
            }
            content += $"<p>{i}</p>";
        }
        var pdf = htmlToPdf.RenderHtmlAsPdf(content);
        pdf.SaveAs("AwesomeIronPDF.pdf");
        Console.WriteLine("PDF generated successfully.");
    }
}

using System;
using System.Threading.Tasks;
using System.Diagnostics;
using IronPdf;
class Program
{
    public static async Task Main()
    {
        Console.WriteLine("Generate PDF document Using IronPDF");
        var htmlToPdf = new ChromePdfRenderer();
        var content = "<h1>Generate Numbers from 1 to 10, skip 5</h1>";
        for (int i = 0; i < 10; i++)
        {
            if (i == 5)
            {
                continue;
            }
            content += $"<p>{i}</p>";
        }
        content += "<h1>Generate Numbers from 1 to 10, stop at 7</h1>";
        for (int i = 0; i < 10; i++)
        {
            if (i == 7)
            {
                break;
            }
            content += $"<p>{i}</p>";
        }
        var pdf = htmlToPdf.RenderHtmlAsPdf(content);
        pdf.SaveAs("AwesomeIronPDF.pdf");
        Console.WriteLine("PDF generated successfully.");
    }
}

Imports System
Imports System.Threading.Tasks
Imports System.Diagnostics
Imports IronPdf
Friend Class Program
	Public Shared Async Function Main() As Task
		Console.WriteLine("Generate PDF document Using IronPDF")
		Dim htmlToPdf = New ChromePdfRenderer()
		Dim content = "<h1>Generate Numbers from 1 to 10, skip 5</h1>"
		For i As Integer = 0 To 9
			If i = 5 Then
				Continue For
			End If
			content &= $"<p>{i}</p>"
		Next i
		content &= "<h1>Generate Numbers from 1 to 10, stop at 7</h1>"
		For i As Integer = 0 To 9
			If i = 7 Then
				Exit For
			End If
			content &= $"<p>{i}</p>"
		Next i
		Dim pdf = htmlToPdf.RenderHtmlAsPdf(content)
		pdf.SaveAs("AwesomeIronPDF.pdf")
		Console.WriteLine("PDF generated successfully.")
	End Function
End Class

Code Erläuterung

1. Zunächst erstellen wir Inhalte, die in einem PDF-Dokument verwendet werden sollen.

2. Wir bereiten den Inhalt als HTML-Dokument auf.

3. Wir verwenden die continue-Anweisung innerhalb der for-Schleife, um von 1 bis 10 zu drucken und 5 zu überspringen.

4. Außerdem verwenden wir die break-Anweisung, um von 1 bis 7 zu drucken und dann abzubrechen.

5. Dann verwenden wir das ChromePdfRenderer-Objekt, um das HTML-Dokument in ein PDF-Dokument zu speichern.

Ausgabe

Bewährte Praktiken und Überlegungen

1. Klarheit und Lesbarkeit: In den meisten Fällen können strukturierte Kontrollflussanweisungen wie break, continue oder geschachtelte Schleifen Ihren Code lesbarer und verständlicher machen. Die goto-Anweisungen können den Code schwerer nachvollziehbar machen, insbesondere bei größeren Codebasen oder bei übermäßigem Gebrauch.

2. Vermeidung unbeabsichtigter Folgen: Der Missbrauch von goto kann zu Spaghetti-Code führen und es schwierig machen, das Programmverhalten nachzuvollziehen. Es ist wichtig, goto umsichtig zu verwenden und sicherzustellen, dass seine Verwendung klar und gut dokumentiert ist.

3. Fehlerbehandlung: Ein häufiger Anwendungsfall für goto ist in Szenarien zur Fehlerbehandlung, wo es genutzt werden kann, um zu einer Bereinigungs- oder Fehlerbehandlungsroutine zu springen. Moderne C#-Codebasen verwenden jedoch häufig strukturiertes Exception-Handling (try-catch-finally) zur Fehlerbehandlung, was einen strukturierteren und besser lesbaren Ansatz bietet.

4. Leistungserwägungen: In Bezug auf die Leistung hat goto in der Regel minimale Auswirkungen. Das Hauptanliegen bei goto ist jedoch die Wartbarkeit und Lesbarkeit, nicht die Leistung.

Lizenz (Testversion verfügbar)

Entdecken Sie die Lizenzdetails von IronPDF.

Eine Testentwickler-Testlizenz ist verfügbar Testlizenz erhalten.

Bitte ersetzen Sie den Schlüssel in der appSettings.json-Datei wie unten gezeigt.

{
  "IronPdf.License.LicenseKey": "The Key Here"
}

Schlussfolgerung

Zusammenfassend sind die continue- und break-Methoden unverzichtbare Werkzeuge zur Steuerung der Schleifenausführung in C#. Wenn Sie diese Anweisungen strategisch in Ihren Code einbauen, können Sie dessen Effizienz, Lesbarkeit und Wartbarkeit verbessern. Während die goto-Anweisung in C# eine Möglichkeit bietet, den Ablauf der Ausführung zu ändern, sollte ihr Einsatz mit Vorsicht angegangen werden. In den meisten Fällen bieten strukturierte Kontrollflussanweisungen wie break, continue oder verschachtelte Schleifen klarere und besser wartbare Lösungen. Es gibt jedoch Nischenszenarien, in denen goto effektiv und sicher eingesetzt werden kann, z. B. in bestimmten Situationen der Fehlerbehandlung. Wie bei jedem Programmierkonstrukt ist es wichtig, bei der Entscheidung über die Verwendung von goto die Kompromisse abzuwägen und die Lesbarkeit und Wartbarkeit des Codes zu berücksichtigen.

Zusammen mit der IronPDF - Comprehensive PDF Solutions-Bibliothek von Iron Software, um PDF-Dokumente zu lesen und zu erstellen, können Entwickler fortgeschrittene Fähigkeiten erwerben, um moderne Anwendungen zu entwickeln.