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

Grundlagen des as-Operators

Das as-Operator-Schlüsselwort in C# ist ein binärer Operator, der verwendet wird, um bestimmte Konvertierungen zwischen kompatiblen Referenztypen oder Nullable-Typen durchzuführen. Der folgende Code bietet eine einfache Demonstration:

// Declare an object that holds a string
object myObj = "Hello, World!";

// Use the 'as' operator to attempt to convert 'myObj' to a string
string myStr = myObj as string;

// myStr will hold the string value "Hello, World!" if the conversion is successful;
// otherwise, it will be null.

// Declare an object that holds a string
object myObj = "Hello, World!";

// Use the 'as' operator to attempt to convert 'myObj' to a string
string myStr = myObj as string;

// myStr will hold the string value "Hello, World!" if the conversion is successful;
// otherwise, it will be null.

Im obigen Code ist myObj ein Objekt des Typs object (der Basistyp für alle Typen in C#). Wir sind uns des zugrunde liegenden Typs zur Kompilierzeit unsicher. Der as-Operator wird verwendet, um zu versuchen, myObj als string zu behandeln. Wenn erfolgreich, wird myStr den Zeichenfolgenwert enthalten. Andernfalls wird es einen null-Wert enthalten.

Unterscheidet sich von Explicit Cast?

Während sowohl der as-Operator als auch der explizite Cast ähnliche Zwecke erfüllen, gibt es einen wesentlichen Unterschied. Wenn ein expliziter Cast fehlschlägt, wird eine Ausnahme ausgelöst. Andererseits, wenn der Versuch des as-Operators, von einem Typ zu einem anderen zu konvertieren, fehlschlägt, gibt der Operator einen null-Wert zurück, anstatt eine Ausnahme auszulösen. Lassen Sie uns das mit dem folgenden Codebeispiel verstehen:

object someValue = 12345;
string castResult;

// Using explicit cast
try {
    castResult = (string)someValue; // This will throw an exception since the cast fails.
}
catch(Exception ex) {
    castResult = null; // The result is set to null if an exception is caught.
}

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

object someValue = 12345;
string castResult;

// Using explicit cast
try {
    castResult = (string)someValue; // This will throw an exception since the cast fails.
}
catch(Exception ex) {
    castResult = null; // The result is set to null if an exception is caught.
}

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

Wie ersichtlich, kann die Verwendung des as-Operators oft sicherer sein, da Sie potenzielle Laufzeitfehler vermeiden.

Nullbare Werttyp-Konvertierungen

Einer der speziellen Fälle, in denen der as-Operator von unschätzbarem Wert ist, ist bei Nullable-Wertetypen. Wertetypen (wie int, double usw.) können keinen null-Wert zugewiesen bekommen. Indem Sie sie jedoch nullable machen, können Sie ihnen null zuweisen. Der as-Operator kann verwendet werden, um eine Konvertierung zu einem Nullable-Wertetyp zu versuchen:

// Declare a nullable integer
int? nullableInt = 10;

// Box the nullable int
object objInt = nullableInt;

// Attempt to unbox using 'as' to a nullable int type
int? resultInt = objInt as int?;

// Declare a nullable integer
int? nullableInt = 10;

// Box the nullable int
object objInt = nullableInt;

// Attempt to unbox using 'as' to a nullable int type
int? resultInt = objInt as int?;

Referenzkonversionen und benutzerdefinierte Konversionen

Der as-Operator unterstützt sowohl Referenzkonvertierungen (zwischen verwandten Referenztypen) als auch benutzerdefinierte Konvertierungen. Benutzerdefinierte Konvertierungen sind die Konvertierungen, die unter Verwendung spezieller Konvertierungsmethoden in Ihren Klassen definiert werden.

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

class Sample {
    // Define an implicit conversion from Sample to string
    public static implicit operator string(Sample s) {
        return "Converted to String";
    }
}

Sample sampleObject = new Sample();

// Use 'as' to convert 'sampleObject' to string
string conversionResult = sampleObject as string;

// conversionResult will hold "Converted to String"

class Sample {
    // Define an implicit conversion from Sample to string
    public static implicit operator string(Sample s) {
        return "Converted to String";
    }
}

Sample sampleObject = new Sample();

// Use 'as' to convert 'sampleObject' to string
string conversionResult = sampleObject as string;

// conversionResult will hold "Converted to String"

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

Wenn as nicht zutrifft

Denken Sie daran, dass der as-Operator nicht mit Wertetypen verwendet werden kann (es sei denn, es handelt sich um Nullable-Wertetypen) oder mit benutzerdefinierten Konvertierungen, die eine explizite Methode beinhalten.

Boxing und Unboxing mit as

Boxing ist der Prozess der Umwandlung einer Werttypinstanz in eine Objekt-Referenz. Dies ist möglich, weil jeder Wertetyp implizit von einem object erbt. Wenn Sie einen Wertetyp boxen, verpacken Sie ihn in einem object.

Betrachten Sie den folgenden Code für Boxing-Konvertierungen:

int intValue = 42;

// Box the value type to an object
object boxedValue = intValue;

int intValue = 42;

// Box the value type to an object
object boxedValue = intValue;

Hier wird der intValue in einen object ge-boxt.

Unboxing ist der umgekehrte Prozess des Boxens, d.h. das Extrahieren des Wertetyps aus dem object. Der as-Operator kann verwendet werden, um Werte sicher zu entboxen, insbesondere wenn Sie nicht sicher sind, ob der object den Wertetyp hält, den Sie erwarten. Wenn das Unboxing nicht erfolgreich ist, wird das Ergebnis des Ausdrucks null sein.

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

object obj = 42;

// Attempt to unbox using 'as' to a nullable int type
int? result = obj as int?;

object obj = 42;

// Attempt to unbox using 'as' to a nullable int type
int? result = obj as int?;

Arbeiten mit Arrays

Arrays sind Referenztypen in C#. Manchmal müssen Sie möglicherweise prüfen, ob ein object eine bestimmte Art von Array ist und dann damit arbeiten. Der as-Operator kann auch hier helfen.

Betrachten Sie den folgenden Code:

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

// Attempt to cast to a string array using 'as'
string[] stringArray = arrayObject as string[];

// stringArray will hold the array of strings if successful

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

// Attempt to cast to a string array using 'as'
string[] stringArray = arrayObject as string[];

// stringArray will hold the array of strings if successful

Im obigen Code ist arrayObject ein Array von Objekten, das tatsächlich Zeichenfolgen enthält. Mit dem as-Operator können Sie versuchen, es sicher als ein Array von Zeichenfolgen zu behandeln.

as mit LINQ kombinieren

Language Integrated Query (LINQ - Microsoft-Dokumentation) ist eine leistungsstarke Funktion in C#, die es Ihnen ermöglicht, Sammlungen in einer SQL-ähnlichen Weise abzufragen. Manchmal erhalten Sie Objekte gemischter Typen in einer Sammlung und möchten spezifische Typen herausfiltern. Hier kann der as-Operator sehr hilfreich sein.

Zum Beispiel, betrachten Sie eine Liste von Objekten, die sowohl Strings als auch Ganzzahlen enthält. Wenn Sie nur die Zeichenfolgen abrufen möchten, könnten Sie den as-Operator in Kombination mit LINQ verwenden:

var mixedList = new List<object> { "Hello", 42, "World", 100 };

// Use LINQ to select only strings from mixedList
var stringValues = mixedList
    .Select(item => item as string)
    .Where(item => item != null)
    .ToList();

// stringValues will contain "Hello" and "World"

var mixedList = new List<object> { "Hello", 42, "World", 100 };

// Use LINQ to select only strings from mixedList
var stringValues = mixedList
    .Select(item => item as string)
    .Where(item => item != null)
    .ToList();

// stringValues will contain "Hello" and "World"

IronPDF

IronPDF ermöglicht es Entwicklern, PDF-Dateien innerhalb ihrer C#-Anwendungen zu erzeugen, zu manipulieren und zu lesen. In Bezug auf unser Thema, nehmen wir an, Sie hatten einen Referenztyp, der einige Daten enthält, und Sie wollten diese Daten in einen Bericht oder ein Dokument umwandeln. IronPDF kann die Ausgabe Ihrer Anwendung nehmen und sie in ähnlicher Weise wie die Typkonvertierung in ein gut formatiertes PDF-Dokument übersetzen.

IronXL

Der Umgang mit Excel-Dateien ist in vielen Softwareanwendungen eine häufige Anforderung. IronXL for Excel Operations bietet Entwicklern die Möglichkeit, Excel-Tabellen zu lesen, zu bearbeiten und zu erstellen, ohne auf Office-Interop angewiesen zu sein. Im Kontext unserer Diskussion über Typkonvertierungen können Sie IronXL als Werkzeug verstehen, das es ermöglicht, Datenstrukturen oder Datenbankeinträge in C# nahtlos in Excel-Formate zu konvertieren.

IronOCR

Optical Character Recognition with IronOCR ist ein optisches Zeichenerkennungstool, das es Entwicklern ermöglicht, Text aus Bildern zu lesen und zu interpretieren. In Verbindung mit unserem Tutorial ist es vergleichbar mit der Konvertierung eines object (in diesem Fall eines Bildes) in einen spezifischeren Typ (string oder Textdaten) unter Verwendung fortschrittlicher Erkennungsmöglichkeiten.

IronBarcode

In vielen kommerziellen Anwendungen ist der Umgang mit Barcodes unerlässlich. IronBarcode Tool for Barcode Processing unterstützt Entwickler beim Erzeugen, Lesen und Dekodieren von Barcodes in C#-Anwendungen. Im Hinblick auf unsere Diskussion über Typkonvertierungen kann IronBarcode als ein Werkzeug betrachtet werden, das visuelle Barcode-Daten (eine Form von object) in spezifischere, brauchbare Datentypen wie Zeichenfolgen oder Produktdetails übersetzt.