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

Bei der Programmierung in C# wird häufig mit verschiedenen Datentypen gearbeitet. Manchmal müssen wir prüfen, ob ein "Objekt" von einem bestimmten Typ ist, oder versuchen, es in diesen Typ zu konvertieren. Das ist der Punkt, an dem die schlüsselwort "als" Operator ist sehr nützlich. Zusammen mit seinem nahen Verwandten, dem "is"-Operator, hilft er bei Typprüfungen und Konvertierungen. In diesem Tutorium werden wir die Feinheiten dieses Operators und seine Anwendungsfälle untersuchen.

Das Verständnis des as-Operators

Grundlagen des "as"-Operators

Das "as"-Operator-Schlüsselwort in C# ist ein binärer Operator, der zur Durchführung bestimmter Konvertierungen zwischen kompatiblen Referenztypen oder nullbaren Typen verwendet wird. Der folgende Code bietet eine einfache Demonstration

object myObj = "Hello, World!";
string myStr = myObj as string;

object myObj = "Hello, World!";
string myStr = myObj as string;

Dim myObj As Object = "Hello, World!"
Dim myStr As String = TryCast(myObj, String)

Im obigen Code ist myObj ein Objekt des Typs object (der Basistyp für alle Typen in C#). Wir wissen nicht, welcher Typ ihm zur Kompilierungszeit zugrunde liegt. Der "as"-Operator wird verwendet, um zu versuchen, "myObj" als "String" zu behandeln. Bei Erfolg enthält myStr den Wert der Zeichenkette. Andernfalls enthält es einen "Nullwert".

Wie unterscheidet sie sich von der expliziten Besetzung?

Obwohl die Als-Operator- und die explizite Besetzung ähnlichen Zwecken dienen, gibt es einen wichtigen Unterschied. Wenn ein expliziter Cast fehlschlägt, wird eine Ausnahme ausgelöst. Wenn der Versuch des "as"-Operators, von einem Typ in einen anderen umzuwandeln, fehlschlägt, gibt der Operator einen "Nullwert" zurück, anstatt eine Ausnahme auszulösen. Dies soll anhand des folgenden Codebeispiels erläutert werden:

object someValue = 12345;

// Using explicit cast
string castResult;
try {
    castResult = (string)someValue; // This will throw an exception since the cast fails.
}
catch(Exception ex) {
    castResult = null;
}

// Using the as operator
string asResult = someValue as string; // No exception, but asResult will be null since the cast fails.

object someValue = 12345;

// Using explicit cast
string castResult;
try {
    castResult = (string)someValue; // This will throw an exception since the cast fails.
}
catch(Exception ex) {
    castResult = null;
}

// Using the as operator
string asResult = someValue as string; // No exception, but asResult will be null since the cast fails.

Dim someValue As Object = 12345

' Using explicit cast
Dim castResult As String
Try
	castResult = DirectCast(someValue, String) ' This will throw an exception since the cast fails.
Catch ex As Exception
	castResult = Nothing
End Try

' Using the as operator
Dim asResult As String = TryCast(someValue, String) ' No exception, but asResult will be null since the cast fails.

Wie Sie sehen, ist die Verwendung des "as"-Operators oft sicherer, da Sie mögliche Laufzeitfehler vermeiden.

Die Verbindung mit dem is operator

Häufig wird der "as"-Operator in Verbindung mit dem "is"-Operator zur Typprüfung vor einer Konvertierung verwendet. Der "is"-Operator prüft, ob das angegebene Objekt vom angegebenen Typ ist, und gibt true zurück, wenn ja, andernfalls false.

Das folgende Codebeispiel veranschaulicht dies:

object testObject = "This is a string";

if(testObject is string) {
    string result = testObject as string;
    Console.WriteLine(result);
} else {
    Console.WriteLine("Not a string");
}

object testObject = "This is a string";

if(testObject is string) {
    string result = testObject as string;
    Console.WriteLine(result);
} else {
    Console.WriteLine("Not a string");
}

Dim testObject As Object = "This is a string"

If TypeOf testObject Is String Then
	Dim result As String = TryCast(testObject, String)
	Console.WriteLine(result)
Else
	Console.WriteLine("Not a string")
End If

Mit der Einführung des Musterabgleichs in späteren Versionen von C# kann der "is"-Operator auch bestimmte Aktionen ausführen, wenn der Typentest erfolgreich ist. Dadurch wird die Verwendung des "as"-Operators oft überflüssig.

Tiefer gehende Sonderfälle und Überlegungen

Konvertierung von nullbaren Werttypen

Einer der Sonderfälle, in denen der "as"-Operator von unschätzbarem Wert ist, sind nichtigbare Werttypen. Wertetypen (wie int, double, etc.) kann kein Nullwert zugewiesen werden. Indem Sie sie jedoch nullbar machen, können Sie ihnen null zuweisen. Der "as"-Operator kann verwendet werden, um die Umwandlung in einen nullbaren Werttyp zu versuchen:

int? nullableInt = 10;
object objInt = nullableInt;
int? resultInt = objInt as int?;

int? nullableInt = 10;
object objInt = nullableInt;
int? resultInt = objInt as int?;

Dim nullableInt? As Integer = 10
Dim objInt As Object = nullableInt
Dim resultInt? As Integer = CType(objInt, Integer?)

Referenzkonvertierungen und benutzerdefinierte Konvertierungen

Der "as"-Operator unterstützt beide Referenzkonvertierungen (zwischen verwandten Referenztypen) und benutzerdefinierte Konvertierungen. Benutzerdefinierte Konvertierungen sind die Konvertierungen, die mit speziellen Konvertierungsmethoden in Ihren Klassen definiert werden.

Betrachten Sie den folgenden Code für eine benutzerdefinierte Konvertierung:

class Sample {
    public static implicit operator string(Sample s) {
        return "Converted to String";
    }
}

Sample sampleObject = new Sample();
string conversionResult = sampleObject as string;

class Sample {
    public static implicit operator string(Sample s) {
        return "Converted to String";
    }
}

Sample sampleObject = new Sample();
string conversionResult = sampleObject as string;

Friend Class Sample
	Public Shared Widening Operator CType(ByVal s As Sample) As String
		Return "Converted to String"
	End Operator
End Class

Private sampleObject As New Sample()
Private conversionResult As String = TryCast(sampleObject, String)

Hier ermöglicht die benutzerdefinierte Konvertierungsmethode, dass ein Objekt vom Typ "Sample" als "String" behandelt wird.

Wenn as nicht zutrifft

Beachten Sie, dass der "as"-Operator nicht mit Werttypen verwendet werden kann (es sei denn, es handelt sich um nullbare Werttypen) oder mit benutzerdefinierten Konvertierungen, die eine explizite Methode beinhalten.

Erweiterte Szenarien mit dem as-Operator

Boxen und Unboxing mit as

Boxing ist der Prozess der Umwandlung einer Instanz vom Typ Wert in eine Objektreferenz. Dies ist möglich, weil jeder Werttyp implizit von einem "Objekt" erbt. Wenn Sie einen Werttyp boxen, verpacken Sie ihn in ein "Objekt".

Betrachten Sie den folgenden Code für die Umwandlung von Boxen:

int intValue = 42;
object boxedValue = intValue;

int intValue = 42;
object boxedValue = intValue;

Dim intValue As Integer = 42
Dim boxedValue As Object = intValue

Hier wird der intValue in ein Objekt gepackt.

Unboxing ist der umgekehrte Prozess des Boxing, d.h. das Extrahieren des Werttyps aus dem "Objekt". Der "as"-Operator kann verwendet werden, um Werte sicher zu entpacken, insbesondere wenn Sie nicht sicher sind, ob das "Objekt" den Werttyp enthält, den Sie erwarten. Wenn das Unboxing nicht erfolgreich ist, ist das Ergebnis des Ausdrucks null.

Betrachten Sie das folgende Beispiel für Unboxing-Umwandlungen:

object obj = 42;
int? result = obj as int?;

object obj = 42;
int? result = obj as int?;

Dim obj As Object = 42
Dim result? As Integer = CType(obj, Integer?)

Arbeiten mit Arrays

Arrays sind in C# Referenztypen. Manchmal muss man feststellen, ob es sich bei einem "Objekt" um einen bestimmten Typ von Array handelt und dann damit arbeiten. Auch hier kann der "as"-Operator helfen.

Betrachten Sie den folgenden Code:

    object [] arrayObject = new string [] { "one", "two", "three" };
    string [] stringArray = arrayObject as string [];

    object [] arrayObject = new string [] { "one", "two", "three" };
    string [] stringArray = arrayObject as string [];

Dim arrayObject() As Object = New String () { "one", "two", "three" }
	Dim stringArray() As String = TryCast(arrayObject, String())

Im obigen Code ist arrayObject ein Array von Objekten, enthält aber eigentlich Zeichenketten. Mit dem "as"-Operator können Sie sicher versuchen, es als ein Array von Zeichenketten zu behandeln.

Kombinieren" als "mit LINQ

Sprache Integrierte Abfrage (LINQ) ist eine leistungsstarke Funktion in C#, mit der Sie Sammlungen in einer SQL-ähnlichen Weise abfragen können. Manchmal kann es vorkommen, dass Sie Objekte gemischter Typen in einer Sammlung abrufen und bestimmte Typen herausfiltern wollen. Hier kann der "as"-Operator sehr nützlich sein.

Nehmen wir zum Beispiel eine Liste von Objekten, die sowohl Zeichenketten als auch ganze Zahlen enthält. Wenn Sie nur die Zeichenketten abrufen wollten, könnten Sie den Operator "as" in Verbindung mit LINQ verwenden:

var mixedList = new List<object> { "Hello", 42, "World", 100 };
var stringValues = mixedList
    .Select(item => item as string)
    .Where(item => item != null)
    .ToList();

var mixedList = new List<object> { "Hello", 42, "World", 100 };
var stringValues = mixedList
    .Select(item => item as string)
    .Where(item => item != null)
    .ToList();

Dim mixedList = New List(Of Object) From {"Hello", 42, "World", 100}
Dim stringValues = mixedList.Select(Function(item) TryCast(item, String)).Where(Function(item) item IsNot Nothing).ToList()

Integration mit Iron Suite

Iron Suite ist eine Suite hochwertiger Werkzeuge, mit denen C#-Entwickler Funktionen wie PDF-Bearbeitung, Excel-Bearbeitung und optische Zeichenerkennung nahtlos integrieren können (OCR)sowie die Erstellung und das Lesen von Barcodes. Diese Werkzeuge, wie auch unsere frühere Diskussion über die as- und is-Operatoren, sind von zentraler Bedeutung für die Steigerung der Effizienz eines Entwicklers bei der Erstellung robuster Anwendungen.

IronPDF

IronPDF ermöglicht es Entwicklern, PDF-Dateien in ihren C#-Anwendungen zu erzeugen, zu bearbeiten und zu lesen. Nehmen wir einmal an, Sie hätten einen Referenztyp, der Daten enthält, und wollten diese Daten in einen Bericht oder ein Dokument umwandeln. ironPDF" kann die Ausgabe Ihrer Anwendung in ein gut formatiertes PDF-Dokument übersetzen, ähnlich wie bei einer Typkonvertierung.

IronXL

Der Umgang mit Excel-Dateien ist eine häufige Anforderung in vielen Softwareanwendungen. ironXL bietet Entwicklern die Möglichkeit, Excel-Tabellen zu lesen, zu bearbeiten und zu erstellen, ohne sich auf Office Interop verlassen zu müssen. Im Zusammenhang mit unserer Diskussion über Typkonvertierungen können Sie sich IronXL als ein Tool vorstellen, mit dem Sie Datenstrukturen oder Datenbankeinträge in C# nahtlos in Excel-Formate konvertieren können.

IronOCR

ironOCR ist ein Werkzeug zur optischen Zeichenerkennung, mit dem Entwickler Text aus Bildern lesen und interpretieren können. Um dies mit unserem Tutorial zu verbinden, ist es ähnlich wie die Konvertierung eines "Objekts" (in diesem Fall, ein Bild) zu einem spezifischeren Typ (zeichenkette" oder textuelle Daten) mit erweiterten Erkennungsfunktionen.

IronBarcode

In vielen kommerziellen Anwendungen ist die Handhabung von Barcodes unverzichtbar. ironBarcode unterstützt Entwickler beim Erzeugen, Lesen und Dekodieren von Barcodes in C#-Anwendungen. Im Zusammenhang mit unserer Diskussion über Typkonvertierungen kann IronBarcode als ein Werkzeug betrachtet werden, das visuelle Barcodedaten übersetzt (eine Form von Objekt) in spezifischere, brauchbare Datentypen, wie Zeichenketten oder Produktdetails.

Schlussfolgerung

Jedes Produkt innerhalb der Iron Suite ist ein Beweis für die Flexibilität und Leistungsfähigkeit von C#, insbesondere in Verbindung mit unserer Diskussion über Typkonvertierungen und Typüberprüfung. Diese Werkzeuge, wie die as- und is-Operatoren, bieten Entwicklern die Möglichkeit, Daten effizient zu konvertieren und zu verarbeiten.

Wenn Sie in Erwägung ziehen, eines dieser Tools in Ihre Projekte zu integrieren, sollten Sie beachten, dass jede Produktlizenz bei $749 beginnt und jedes Produkt eine kostenloser Test. Für diejenigen, die eine umfassende Lösung suchen, bietet Iron Suite" ein verlockendes Angebot: Sie können die gesamte Suite erwerben für den Preis von nur zwei Produkten.