Mustererkennung in C# ist ein leistungsstarkes Feature, das in C# 7.0 eingeführt und seitdem in nachfolgenden Versionen erweitert wurde. Es ermöglicht Entwicklern, prägnanteren und ausdrucksstärkeren Code zu schreiben, wenn es um bedingte Anweisungen, Typprüfung und die Zerlegung von Objekten geht.
Mustererkennungsausdrücke bieten eine flexible und intuitive Möglichkeit, Werte mit Mustern abzugleichen und entsprechende Codeblöcke auszuführen. In diesem Artikel werden wir die Feinheiten der Mustererkennungsausdrücke in C# erkunden, einschließlich Syntax, Anwendungsfällen und Codebeispielen. Am Ende des Artikels werden wir auch ein wenig über IronPDF PDF Erstellung Bibliothek von Iron Software sprechen, um ein PDF-Dokument in C#-Anwendungen spontan zu erstellen.
Mustererkennung in C#-Code bietet eine Fülle von Vorteilen:
Mustererkennung wird durch folgende Ausdrücke unterstützt:
is-Ausdruckswitch-Anweisungenswitch-AusdrückeDie folgenden Muster können zum Abgleich mit den Konstrukten verwendet werden:
Deklarations- und Typenmuster sind wesentliche Werkzeuge in C#, um die Kompatibilität von Ausführungszeit-Typen von Ausdrücken mit gegebenen Typen zu überprüfen. Mit Deklarationsmustern können Sie sowohl die Kompatibilität prüfen als auch gleichzeitig eine neue lokale Variable deklarieren. Beispiel: IronPDF rendert HTML zu einem PDF und speichert es.
object greeting = "Iron Software is Awesome!";
if (greeting is string message)
{
Console.WriteLine(message.ToLower()); // output: iron software is awesome!
}Dim greeting As Object = "Iron Software is Awesome!"
Dim tempVar As Boolean = TypeOf greeting Is String
Dim message As String = If(tempVar, DirectCast(greeting, String), Nothing)
If tempVar Then
Console.WriteLine(message.ToLower()) ' output: iron software is awesome!
End IfHier stellt das Deklarationsmuster sicher, dass, wenn der Ausdruck greeting mit dem Typ string übereinstimmt, er der Variablen message zugewiesen wird, was nachfolgende Operationen ermöglicht.
Wenn eine der folgenden Bedingungen zutrifft, hält das Deklarationsmuster stand:
T.T ab, implementiert das Interface T oder kann implizit in T konvertiert werden.T.T.Betrachten Sie das folgende Beispiel, das die oben genannten Bedingungen demonstriert:
int? nullableX = 8;
int y = 45;
object boxedy = y;
if (nullableX is int a && boxedy is int b)
{
Console.WriteLine(a + b); // output: 53
}Dim nullableX? As Integer = 8
Dim y As Integer = 45
Dim boxedy As Object = y
Dim tempVar As Boolean = TypeOf boxedy Is Integer
Dim b As Integer = If(tempVar, DirectCast(boxedy, Integer), Nothing)
Dim tempVar2 As Boolean = TypeOf nullableX Is Integer
Dim a As Integer = If(tempVar2, CInt(nullableX), Nothing)
If tempVar2 AndAlso tempVar Then
Console.WriteLine(a + b) ' output: 53
End IfHier stimmt nullableX mit dem Muster überein, weil es ein Nullable-Werttyp mit dem zugrunde liegenden Typ int ist, und boxedy stimmt überein, weil es in int entpackt werden kann.
Wenn Sie nur den Typ des Ausdrucks überprüfen müssen, ohne eine neue Variable zu deklarieren, können Sie den Discard _ verwenden, wie im folgenden Beispiel zu sehen ist:
public static decimal CalculateToll(Vehicle vehicle) => vehicle switch
{
Bus _ => 4.00m,
Motor _ => 8.50m,
null => throw new ArgumentNullException(nameof(vehicle)),
_ => throw new ArgumentException("Unknown type of a vehicle", nameof(vehicle)),
};'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'public static decimal CalculateToll(Vehicle vehicle) => vehicle switch
'{
' Bus _ => 4.00m,
' Motor _ => 8.50m,
' null => throw new ArgumentNullException(nameof(vehicle)),
' _ => throw new ArgumentException("Unknown type of a vehicle", nameof(vehicle)),
'};In diesem Ausschnitt dient der _ als Platzhalter für jeden Typ, der mit Vehicle übereinstimmt.
Sowohl Deklarations- als auch Typenmuster stellen sicher, dass Ausdrücke vor der Mustererkennung nicht null sind. Sie können auf Nicht-Null prüfen, indem Sie ein verneintes Nullkonstantenmuster verwenden, wie unten gezeigt:
if (inputVal is not null)
{
// ...
}If inputVal IsNot Nothing Then
' ...
End IfDiese Negation stellt sicher, dass inputVal nicht null ist, bevor mit weiteren Operationen fortgefahren wird.
Durch den Einsatz von Deklarations- und Typenmustern in Ihrem C#-Code können Sie die Lesbarkeit verbessern, Codezeilen reduzieren und Algorithmen effektiver ausdrücken. Diese Muster bieten eine prägnante und ausdrucksstarke Möglichkeit zur Handhabung typbasierter Logik und verbessern die Wartbarkeit Ihrer Codebasis.
Konstantenmuster dienen dazu, zu überprüfen, ob ein Ausdrucksergebnis einem bestimmten Konstantenwert entspricht. Beispiel: IronPDF rendert HTML zu einem PDF und speichert es.
public static decimal GetGroupTicketPrice(int visitorCount) => visitorCount switch
{
1 => 2.0m,
2 => 10.0m,
3 => 25.0m,
4 => 60.0m,
0 => 0.0m,
_ => throw new ArgumentException($"Not supported number of visitors: {visitorCount}", nameof(visitorCount)),
};Dim tempVar As Decimal
Select Case visitorCount
Case 1
tempVar = 2.0D
Case 2
tempVar = 10.0D
Case 3
tempVar = 25.0D
Case 4
tempVar = 60.0D
Case 0
tempVar = 0.0D
Case Else
'INSTANT VB TODO TASK: Throw expressions are not converted by Instant VB:
'ORIGINAL LINE: tempVar = throw new ArgumentException(string.Format("Not supported number of visitors: {0}", visitorCount), nameof(visitorCount));
tempVar = throw New ArgumentException($"Not supported number of visitors: {visitorCount}", NameOf(visitorCount))
End Select
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'public static decimal GetGroupTicketPrice(int visitorCount)
'{
' Return tempVar;
'}Hier überprüfen die konstanten Muster, ob visitorCount mit einem der angegebenen konstanten Werte übereinstimmt und geben entsprechende Ticketpreise zurück.
In einem Konstantenmuster können Sie verschiedene Arten von Konstantenausdrücken verwenden, wie:
true oder false).null.Ein Ausdruck des Typs Span<char> oder ReadOnlySpan<char> kann konstante Zeichenfolgen abgleichen.
Um null zu überprüfen, verwenden Sie ein konstantes Muster wie folgt:
if (inputVal is null)
{
return;
}If inputVal Is Nothing Then
Return
End IfHier stellt das Muster sicher, dass inputVal null ist, bevor mit weiteren Operationen fortgefahren wird.
Sie können auch ein verneintes Nullkonstantenmuster verwenden, um nicht-null Werte zu bestimmen:
if (inputVal is not null)
{
// ...
}If inputVal IsNot Nothing Then
' ...
End IfDieses Muster überprüft, dass inputVal nicht null ist, sodass nachfolgende Operationen sicher durchgeführt werden können.
Indem Sie Konstantenmuster in Ihren C#-Code integrieren, können Sie Szenarien effektiv verwalten, in denen bestimmte Konstantenwerte abgeglichen werden müssen, wodurch die Codeklarheit und Wartbarkeit verbessert wird.
Relationale Muster bieten eine Möglichkeit, Ausdrucksergebnisse mit Konstanten zu vergleichen. Beispiel: IronPDF rendert HTML zu einem PDF und speichert es.
Console.WriteLine(Classify(20)); // output: Too high
Console.WriteLine(Classify(double.NaN)); // output: Unknown
Console.WriteLine(Classify(4)); // output: Acceptable
static string Classify(double measurement) => measurement switch
{
< -4.0 => "Too low",
> 10.0 => "Too high",
double.NaN => "Unknown",
_ => "Acceptable",
};Console.WriteLine(Classify(20)) ' output: Too high
Console.WriteLine(Classify(Double.NaN)) ' output: Unknown
Console.WriteLine(Classify(4)) ' output: Acceptable
'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'static string Classify(double measurement) => measurement switch
'{
' < -4.0 => "Too low",
' > 10.0 => "Too high",
' double.NaN => "Unknown",
' _ => "Acceptable",
'};Hier vergleichen die relationalen Muster die measurement mit bestimmten Schwellenwerten, um die Klassifizierung zu bestimmen.
Der rechte Teil eines relationalen Musters muss ein konstanter Ausdruck sein, der ein ganzzahliger, Gleitkomma-, char- oder enum-Typ sein kann. Die Operatoren <, >, <=, >= können auf der linken Seite verwendet werden.
Um ein Ausdrucksergebnis innerhalb eines bestimmten Bereichs abzugleichen, verwenden Sie ein konjunktives "und"-Muster, wie unten illustriert:
Console.WriteLine(GetCalendarSeason(new DateTime(2024, 3, 12))); // output: spring
Console.WriteLine(GetCalendarSeason(new DateTime(2024, 7, 12))); // output: summer
Console.WriteLine(GetCalendarSeason(new DateTime(2024, 2, 12))); // output: winter
static string GetCalendarSeason(DateTime date) => date.Month switch
{
>= 3 and < 6 => "spring",
>= 6 and < 9 => "summer",
>= 9 and < 12 => "autumn",
12 or (>= 1 and <3) => "winter",
_ => throw new ArgumentOutOfRangeException(nameof(date), $"Date with unexpected month: {date.Month}."),
};Console.WriteLine(GetCalendarSeason(New DateTime(2024, 3, 12))) ' output: spring
Console.WriteLine(GetCalendarSeason(New DateTime(2024, 7, 12))) ' output: summer
Console.WriteLine(GetCalendarSeason(New DateTime(2024, 2, 12))) ' output: winter
'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'static string GetCalendarSeason(DateTime date) => date.Month switch
'{
' >= 3 and < 6 => "spring",
' >= 6 and < 9 => "summer",
' >= 9 and < 12 => "autumn",
' 12 or (>= 1 and <3) => "winter",
' _ => throw new ArgumentOutOfRangeException(nameof(date), $"Date with unexpected month: {date.Month}."),
'};Dieser Abschnitt beschreibt, wie das konjunktive "und"-Muster genutzt wird, um die Kalenderjahreszeit basierend auf dem innerhalb bestimmter Bereiche liegenden Monat zu bestimmen. Es wird auch erwähnt, dass relationale Muster eine prägnante und ausdrucksstarke Mittel bieten, um Ausdrucksergebnisse gegen Konstanten zu vergleichen, wodurch die Codeklarheit und Wartbarkeit verbessert wird.
Das Discard-Muster, das durch _ bezeichnet ist, dient dazu, jeden Ausdruck, einschließlich null, abzugleichen. Betrachten Sie das folgende Beispiel:
Console.WriteLine(GetDiscountInPercent(DayOfWeek.Friday)); // output: 5.0
Console.WriteLine(GetDiscountInPercent(null)); // output: 0.0
Console.WriteLine(GetDiscountInPercent((DayOfWeek)10)); // output: 0.0
static decimal GetDiscountInPercent(DayOfWeek? dayOfWeek) => dayOfWeek switch
{
DayOfWeek.Monday => 0.5m,
DayOfWeek.Tuesday => 12.5m,
DayOfWeek.Wednesday => 7.5m,
DayOfWeek.Thursday => 12.5m,
DayOfWeek.Friday => 5.0m,
DayOfWeek.Saturday => 2.5m,
DayOfWeek.Sunday => 2.0m,
_ => 0.0m,
};Console.WriteLine(GetDiscountInPercent(DayOfWeek.Friday)) ' output: 5.0
Console.WriteLine(GetDiscountInPercent(Nothing)) ' output: 0.0
Console.WriteLine(GetDiscountInPercent(CType(10, DayOfWeek))) ' output: 0.0
Dim tempVar As Decimal
Select Case dayOfWeek
Case DayOfWeek.Monday
tempVar = 0.5D
Case DayOfWeek.Tuesday
tempVar = 12.5D
Case DayOfWeek.Wednesday
tempVar = 7.5D
Case DayOfWeek.Thursday
tempVar = 12.5D
Case DayOfWeek.Friday
tempVar = 5.0D
Case DayOfWeek.Saturday
tempVar = 2.5D
Case DayOfWeek.Sunday
tempVar = 2.0D
Case Else
tempVar = 0.0D
End Select
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'static decimal GetDiscountInPercent(System.Nullable(Of DayOfWeek) dayOfWeek)
'{
' Return tempVar;
'}Im oberen Discard-Musterbeispiel werden alle möglichen Eingabewerte behandelt. Alle Wochentage werden verwaltet, und ein Standardwert wird bereitgestellt. Damit werden alle möglichen Werte verarbeitet. Das Discard-Muster kann nicht als Muster in einem is-Ausdruck oder einer switch-Anweisung verwendet werden. In solchen Fällen kann ein var-Muster mit einem Discard wie var _ verwendet werden, um jeden Ausdruck abzugleichen. Ein Discard-Muster ist jedoch in einem switch-Ausdruck zulässig. Für weitere Details beachten Sie bitte den Discard-Musterabschnitt des Feature-Vorschlags.
Logische Muster in C# bieten leistungsstarke Werkzeuge zur Mustererkennung, einschließlich Negation, Konjunktion und Disjunktion, die flexiblere und ausdrucksstärkere Vergleichsbedingungen ermöglichen.
not-Muster)Das Negationsmuster, dargestellt durch not, passt auf einen Ausdruck, wenn das negierte Muster nicht mit dem Ausdruck übereinstimmt. Dies ist besonders nützlich, um zu überprüfen, ob ein Ausdruck nicht null ist, wie unten demonstriert:
if (input is not null)
{
// ...
}If input IsNot Nothing Then
' ...
End IfHier wird der Codeblock ausgeführt, wenn input nicht null ist.
and-Muster)Das konjunktive Muster, das das Schlüsselwort and verwendet, passt auf einen Ausdruck, wenn beide Muster mit dem Ausdruck übereinstimmen. Dies ermöglicht das Kombinieren mehrerer Bedingungen, wie im folgenden Beispiel illustriert:
Console.WriteLine(Classify(13)); // output: High
Console.WriteLine(Classify(-100)); // output: Too low
Console.WriteLine(Classify(5.7)); // output: Acceptable
static string Classify(double measurement) => measurement switch
{
< -40.0 => "Too low",
>= -40.0 and < 0 => "Low",
>= 0 and < 10.0 => "Acceptable",
>= 10.0 and < 20.0 => "High",
>= 20.0 => "Too high",
double.NaN => "Unknown",
};Console.WriteLine(Classify(13)) ' output: High
Console.WriteLine(Classify(-100)) ' output: Too low
Console.WriteLine(Classify(5.7)) ' output: Acceptable
'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'static string Classify(double measurement) => measurement switch
'{
' < -40.0 => "Too low",
' >= -40.0 and < 0 => "Low",
' >= 0 and < 10.0 => "Acceptable",
' >= 10.0 and < 20.0 => "High",
' >= 20.0 => "Too high",
' double.NaN => "Unknown",
'};In diesem Beispiel wird measurement basierend auf seinem Wertebereich klassifiziert.
or-Muster)Das disjunktive Muster, das das Schlüsselwort or verwendet, passt auf einen Ausdruck, wenn eines der Muster mit dem Ausdruck übereinstimmt. Dies ermöglicht das Verarbeiten mehrerer möglicher Bedingungen, wie unten gezeigt:
Console.WriteLine(GetCalendarSeason(new DateTime(2021, 1, 19))); // output: winter
Console.WriteLine(GetCalendarSeason(new DateTime(2021, 10, 9))); // output: autumn
Console.WriteLine(GetCalendarSeason(new DateTime(2021, 5, 11))); // output: spring
static string GetCalendarSeason(DateTime date) => date.Month switch
{
3 or 4 or 5 => "spring",
6 or 7 or 8 => "summer",
9 or 10 or 11 => "autumn",
12 or 1 or 2 => "winter",
_ => throw new ArgumentOutOfRangeException(nameof(date), $"Date with unexpected month: {date.Month}."),
};Console.WriteLine(GetCalendarSeason(New DateTime(2021, 1, 19))) ' output: winter
Console.WriteLine(GetCalendarSeason(New DateTime(2021, 10, 9))) ' output: autumn
Console.WriteLine(GetCalendarSeason(New DateTime(2021, 5, 11))) ' output: spring
Dim tempVar As String
Select Case [date].Month
Case 3, 4, 5
tempVar = "spring"
Case 6, 7, 8
tempVar = "summer"
Case 9, 10, 11
tempVar = "autumn"
Case 12, 1, 2
tempVar = "winter"
Case Else
'INSTANT VB TODO TASK: Throw expressions are not converted by Instant VB:
'ORIGINAL LINE: tempVar = throw new ArgumentOutOfRangeException(nameof(date), string.Format("Date with unexpected month: {0}.", date.Month));
tempVar = throw New ArgumentOutOfRangeException(NameOf([date]), $"Date with unexpected month: {[date].Month}.")
End Select
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'static string GetCalendarSeason(DateTime @date)
'{
' Return tempVar;
'}Hier wird die Kalenderjahreszeit basierend auf dem Monat des angegebenen Datums bestimmt.
Diese Musterkombinatoren können wiederholt verwendet werden, um komplexere und präzisere Vergleichsbedingungen zu erstellen, wodurch die Flexibilität und Lesbarkeit Ihres Codes verbessert wird.
Das Property-Muster ermöglicht den Vergleich der Eigenschaften oder Felder eines Ausdrucks mit verschachtelten Mustern. Ein Beispiel dafür sehen Sie im folgenden Code-Schnipsel:
static bool IsConferenceDay(DateTime date) => date is { Year: 2020, Month: 5, Day: 19 or 20 or 21 };Shared Function IsConferenceDay(ByVal [date] As DateTime) As Boolean
'INSTANT VB TODO TASK: The following 'is' operator pattern is not converted by Instant VB:
Return [date] is { Year: 2020, Month: 5, Day: 19 [or] 20 [or] 21 }
End FunctionHier stellt das Property-Muster sicher, dass das angegebene Datum einem der angegebenen Konferenztage entspricht.
Sie können auch eine Laufzeit Typenüberprüfung und Deklaration einer Variablen innerhalb eines Property-Musters einbauen, wie unten gezeigt:
static string TakeFive(object input) => input switch
{
string { Length: >= 5 } s => s.Substring(0, 5),
string s => s,
ICollection<char> { Count: >= 5 } symbols => new string(symbols.Take(5).ToArray()),
ICollection<char> symbols => new string(symbols.ToArray()),
null => throw new ArgumentNullException(nameof(input)),
_ => throw new ArgumentException("Unsupported input type."),
};'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'static string TakeFive(object input) => input switch
'{
' string { Length: >= 5 } s => s.Substring(0, 5),
' string s => s,
' ICollection<char> { Count: >= 5 } symbols => new string(symbols.Take(5).ToArray()),
' ICollection<char> symbols => new string(symbols.ToArray()),
' null => throw new ArgumentNullException(nameof(input)),
' _ => throw new ArgumentException("Unsupported input type."),
'};Hier wird das Property-Muster verwendet, um Zeichenfolgen und Zeichensammlungen zu behandeln, um eine ordnungsgemäße Handhabung basierend auf ihren Eigenschaften zu gewährleisten.
In C# ermöglicht das Positionsmuster das Zerlegen eines Ausdrucksergebnisses und den Abgleich der resultierenden Werte mit entsprechenden verschachtelten Mustern. Zum Beispiel:
public readonly struct Point
{
public int X { get; }
public int Y { get; }
public Point(int x, int y) => (X, Y) = (x, y);
public void Deconstruct(out int x, out int y) => (x, y) = (X, Y);
}
static string Classify(Point point) => point switch
{
(0, 0) => "Origin",
(1, 0) => "Positive X basis end",
(0, 1) => "Positive Y basis end",
_ => "Just a point",
};'INSTANT VB WARNING: VB has no equivalent to the C# readonly struct:
'ORIGINAL LINE: public readonly struct Point
Public Structure Point
Public ReadOnly Property X() As Integer
Public ReadOnly Property Y() As Integer
Public Sub New(ByVal x As Integer, ByVal y As Integer)
'INSTANT VB TODO TASK: VB has no equivalent to the C# deconstruction assignments:
(X, Y) = (x, y)
End Sub
Public Sub Deconstruct(<System.Runtime.InteropServices.Out()> ByRef x As Integer, <System.Runtime.InteropServices.Out()> ByRef y As Integer)
'INSTANT VB TODO TASK: VB has no equivalent to the C# deconstruction assignments:
(x, y) = (X, Y)
End Sub
End Structure
'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'static string Classify(Point point) => point switch
'{
' (0, 0) => "Origin",
' (1, 0) => "Positive X basis end",
' (0, 1) => "Positive Y basis end",
' _ => "Just a point",
'};In diesem Beispiel wird das Positionsmuster verwendet, um Punkte basierend auf ihren Koordinaten zu klassifizieren.
Darüber hinaus können Sie innerhalb eines Property-Musters auf verschachtelte Eigenschaften oder Felder verweisen, das als erweitertes Property-Muster bekannt ist, das in C# 10 eingeführt wurde:
static bool IsAnyEndOnXAxis(Segment segment) =>
segment is { Start.Y: 0 } or { End.Y: 0 };Shared Function IsAnyEndOnXAxis(ByVal segment As Segment) As Boolean
'INSTANT VB TODO TASK: The following 'is' operator pattern is not converted by Instant VB:
Return segment is { Start.Y: 0 } [or] { [End].Y: 0 }
End FunctionDieses Feature verbessert die Flexibilität der Property-Muster, indem es den direkten Zugriff auf verschachtelte Eigenschaften ermöglicht.
Diese Muster bieten mächtige Mechanismen zum Umgang mit komplexen Datenstrukturen und zur Verbesserung der Lesbarkeit und Ausdruckskraft Ihres Codes.
Var-Muster ermöglicht es, einen beliebigen Typ abzugleichen. Dies kann besonders nützlich sein, um Zwischenresultate innerhalb von Booleschen Ausdrücken zu erfassen oder wenn in Schutzwächtern von Switch-Anweisungen mehrere Prüfungen erforderlich sind.
Hier ist ein Beispiel, das die Verwendung des Var-Musters in einem Booleschen Ausdruck demonstriert:
static bool IsAcceptable(int id, int absLimit) =>
SimulateDataFetch(id) is var results
&& results.Min() >= -absLimit
&& results.Max() <= absLimit;
static int [] SimulateDataFetch(int id)
{
var rand = new Random();
return Enumerable
.Range(start: 0, count: 5)
.Select(s => rand.Next(minValue: -10, maxValue: 11))
.ToArray();
}Shared Function IsAcceptable(ByVal id As Integer, ByVal absLimit As Integer) As Boolean
Dim tempVar As Boolean = TypeOf SimulateDataFetch(id) Is var
Dim results = If(tempVar, CType(SimulateDataFetch(id), var), Nothing)
Return tempVar AndAlso results.Min() >= -absLimit AndAlso results.Max() <= absLimit
End Function
Shared Function SimulateDataFetch(ByVal id As Integer) As Integer()
Dim rand = New Random()
Return Enumerable.Range(start:= 0, count:= 5).Select(Function(s) rand.Next(minValue:= -10, maxValue:= 11)).ToArray()
End FunctionIn diesem Beispiel gibt SimulateDataFetch ein Array von Ganzzahlen zurück, und das is var-Muster erfasst das Ergebnis in der results-Variablen, was nachfolgende Berechnungen basierend auf seinen Eigenschaften ermöglicht.
Darüber hinaus können Var-Muster in Switch-Ausdrücken oder -Anweisungen für prägnanteren Code verwendet werden. Beispiel für die Verwendung von Var-Mustern in Switch-Fall-Schutzwächtern:
public record Point(int X, int Y);
static Point Transform(Point point) => point switch
{
var (x, y) when x < y => new Point(-x, y),
var (x, y) when x > y => new Point(x, -y),
var (x, y) => new Point(x, y),
};
static void TestTransform()
{
Console.WriteLine(Transform(new Point(1, 2))); // output: Point { X = -1, Y = 2 }
Console.WriteLine(Transform(new Point(5, 2))); // output: Point { X = 5, Y = -2 }
}'INSTANT VB TODO TASK: C# 'records' are not converted by Instant VB:
'public record Point(int X, int Y)
'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'static Point Transform(Point point) => point switch
'{
' var (x, y) when x < y => new Point(-x, y),
' var (x, y) when x > y => new Point(x, -y),
' var (x, y) => new Point(x, y),
'};
Shared Sub TestTransform()
Console.WriteLine(Transform(New Point(1, 2))) ' output: Point { X = -1, Y = 2 }
Console.WriteLine(Transform(New Point(5, 2))) ' output: Point { X = 5, Y = -2 }
End SubIn diesem Beispiel erfasst das var-Muster (x, y) die Koordinaten des Punktes, was verschiedene Transformationen basierend auf deren Werten ermöglicht.
In einem Var-Muster wird der Typ der deklarierten Variable aus dem Kompilierungszeit-Typ des Ausdrucks, der mit dem Muster abgeglichen wird, abgeleitet.
Das Var-Muster bietet eine bequeme Möglichkeit, verschiedene Szenarien zu bewältigen, in denen der spezifische Ausdruckstyp nicht im Voraus bekannt ist, und verbessert so die Codeklarheit und Flexibilität.
IronPDF-Dokumenten-Rendering ist eine Bibliothek von Iron Software, die sich auf die Erstellung von PDF-Dokumenten spezialisiert hat. Um loszulegen, muss die Bibliothek zunächst aus dem NuGet-Paketmanager oder aus dem Visual Studio Paket-Manager installiert werden.
# To install from the NuGet Package Manager Console
Install-Package IronPdfDas folgende Bild zeigt, wie man aus dem Visual Studio Installationshandbuch installiert.
Im nachfolgenden Code sehen wir, wie man ein einfaches PDF-Dokument erstellt:
using IronPdf;
namespace IronPatterns
{
class Program
{
static void Main()
{
Console.WriteLine("-----------Iron Software-------------");
var renderer = new ChromePdfRenderer(); // var pattern
var content = " <h1> Iron Software is Awesome </h1> Made with IronPDF!";
// Declaration Pattern
int? nullableX = 8;
int y = 45;
object boxedy = y;
content += "<p>Declaration Pattern</p>";
if (nullableX is int a && boxedy is int b)
{
Console.WriteLine(a + b); // output: 53
content += $"<p>Output: {(a + b)}</p>";
}
// Relational patterns
content += "<p>Relational patterns</p>";
var season1 = GetCalendarSeason(new DateTime(2024, 2, 25));
Console.WriteLine(season1);
content += $"<p>2024, 2, 25: {season1}</p>";
var season2 = GetCalendarSeason(new DateTime(2024, 5, 25));
Console.WriteLine(season2);
content += $"<p>2024, 5, 25: {season2}</p>";
var season3 = GetCalendarSeason(new DateTime(2024, 7, 25));
Console.WriteLine(season3);
content += $"<p>2024, 7, 25: {season3}</p>";
var pdf = renderer.RenderHtmlAsPdf(content);
pdf.SaveAs("output.pdf"); // Saves our PdfDocument object as a PDF
}
static string GetCalendarSeason(DateTime date) => date.Month switch
{
>= 3 and < 6 => "spring",
>= 6 and < 9 => "summer",
>= 9 and < 12 => "autumn",
12 or (>= 1 and < 3) => "winter",
_ => throw new ArgumentOutOfRangeException(nameof(date), $"Date with unexpected month: {date.Month}."),
};
}
}Imports IronPdf
Namespace IronPatterns
Friend Class Program
Shared Sub Main()
Console.WriteLine("-----------Iron Software-------------")
Dim renderer = New ChromePdfRenderer() ' var pattern
Dim content = " <h1> Iron Software is Awesome </h1> Made with IronPDF!"
' Declaration Pattern
Dim nullableX? As Integer = 8
Dim y As Integer = 45
Dim boxedy As Object = y
content &= "<p>Declaration Pattern</p>"
Dim tempVar As Boolean = TypeOf boxedy Is Integer
Dim b As Integer = If(tempVar, DirectCast(boxedy, Integer), Nothing)
Dim tempVar2 As Boolean = TypeOf nullableX Is Integer
Dim a As Integer = If(tempVar2, CInt(nullableX), Nothing)
If tempVar2 AndAlso tempVar Then
Console.WriteLine(a + b) ' output: 53
content &= $"<p>Output: {(a + b)}</p>"
End If
' Relational patterns
content &= "<p>Relational patterns</p>"
Dim season1 = GetCalendarSeason(New DateTime(2024, 2, 25))
Console.WriteLine(season1)
content &= $"<p>2024, 2, 25: {season1}</p>"
Dim season2 = GetCalendarSeason(New DateTime(2024, 5, 25))
Console.WriteLine(season2)
content &= $"<p>2024, 5, 25: {season2}</p>"
Dim season3 = GetCalendarSeason(New DateTime(2024, 7, 25))
Console.WriteLine(season3)
content &= $"<p>2024, 7, 25: {season3}</p>"
Dim pdf = renderer.RenderHtmlAsPdf(content)
pdf.SaveAs("output.pdf") ' Saves our PdfDocument object as a PDF
End Sub
'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
' static string GetCalendarSeason(DateTime date) => date.Month switch
' {
' >= 3 and < 6 => "spring",
' >= 6 and < 9 => "summer",
' >= 9 and < 12 => "autumn",
' 12 or (>= 1 and < 3) => "winter",
' _ => throw new ArgumentOutOfRangeException(nameof(date), $"Date with unexpected month: {date.Month}."),
' };
End Class
End Namespace
Hier verwenden wir die IronPDF-Klasse ChromePdfRenderer, um die HTML-Zeichenfolge in ein PDF-Dokument zu speichern. Das Ausgabedokument wird im Dokument "output.pdf" gespeichert.
IronPDF kann mit einer Testlizenz verwendet werden, die von der IronPDF-Lizenzseite bezogen werden kann. Geben Sie eine E-Mail-Adresse an, um einen Lizenzschlüssel zu generieren, der an Ihre E-Mail-Adresse gesendet wird.
"IronPdf.LicenseKey": "<Your Key>""IronPdf.LicenseKey" = "<Your Key>"Platzieren Sie den Lizenzschlüssel in der Datei appsettings.json, wie oben gezeigt.
Mustererkennungsausdrücke in C# bieten eine leistungsstarke und flexible Möglichkeit, bedingte Anweisungen, Typüberprüfungen und Objektdestruktionen auf prägnante und lesbare Weise zu schreiben. Durch die Nutzung der Mustererkennung können Entwickler die Klarheit und Wartbarkeit ihres Codes verbessern, während Boilerplate und Redundanz reduziert werden. Ob Typübermittlung, Switch-Anweisungen oder Destruktion, Mustererkennungsausdrücke bieten ein vielseitiges Werkzeugset zur Bewältigung einer Vielzahl von Programmieraufgaben in C#.
Abschließend kann das Meistern von Mustererkennungsausdrücken Ihre C#-Programmierfähigkeiten erheblich verbessern, sodass Sie saubereren, ausdrucksstärkeren Code schreiben können, der einfacher zu verstehen und zu pflegen ist. Wir haben auch die HTML-zu-PDF-Generierungsfähigkeiten von IronPDF behandelt, die zur Erstellung von PDF-Dokumenten genutzt werden können.
Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO Cameron Rimington in ein Unternehmen mit mehr als 50 Mitarbeitern verwandelt, das die NASA, Tesla und globale Regierungsbehörden beliefert.
IronPDF ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Wenn Ihr PDF wie HTML aussehen soll, schnell.
