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.

' Declare an object that holds a string
Dim myObj As Object = "Hello, World!"

' Use the 'as' operator to attempt to convert 'myObj' to a string
Dim myStr As String = TryCast(myObj, 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 vom Typ object (der Basistyp für alle Typen in C#). Wir sind uns seines zugrunde liegenden Typs zur Compile-Zeit unsicher. Der as-Operator wird verwendet, um zu versuchen, myObj als string zu behandeln. Wenn erfolgreich, wird myStr den String-Wert halten. Andernfalls wird es einen null-Wert halten.

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, scheitert, 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.

Dim someValue As Object = 12345
Dim castResult As String

' Using explicit cast
Try
	castResult = DirectCast(someValue, String) ' This will throw an exception since the cast fails.
Catch ex As Exception
	castResult = Nothing ' The result is set to null if an exception is caught.
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 ersichtlich, kann die Verwendung des as-Operators oft sicherer sein, da Sie potenzielle Laufzeitfehler vermeiden.

Nullbare Werttyp-Konvertierungen

Einer der Sonderfälle, in denen der as-Operator von unschätzbarem Wert ist, betrifft 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 die Konvertierung in einen 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?;

' Declare a nullable integer
Dim nullableInt? As Integer = 10

' Box the nullable int
Dim objInt As Object = nullableInt

' Attempt to unbox using 'as' to a nullable int type
Dim resultInt? As Integer = CType(objInt, Integer?)

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"

Friend Class Sample
	' Define an implicit conversion from Sample to string
	Public Shared Widening Operator CType(ByVal s As Sample) As String
		Return "Converted to String"
	End Operator
End Class

Private sampleObject As New Sample()

' Use 'as' to convert 'sampleObject' to string
Private conversionResult As String = TryCast(sampleObject, String)

' conversionResult will hold "Converted to String"

Hier erlaubt die benutzerdefinierte Konvertierungsmethode, ein Objekt vom Typ Sample als string zu behandeln.

Wenn as nicht zutrifft

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

Boxing und Unboxing mit as

Boxing ist der Prozess der Umwandlung einer Werttypinstanz in eine Objekt-Referenz. Dies ist möglich, weil jeder Werttyp implizit von einem object erbt. Wenn Sie einen Wertetyp boxen, binden Sie ihn in ein 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;

Dim intValue As Integer = 42

' Box the value type to an object
Dim boxedValue As Object = intValue

Hier wird der intValue in ein object geboxed.

Unboxing ist der umgekehrte Prozess des Boxing, d.h. das Extrahieren des Wertetyps aus dem object. Der as-Operator kann verwendet werden, um Werte sicher zu unboxen, insbesondere wenn Sie sich nicht sicher sind, ob das object den von Ihnen erwarteten Wertetyp enthält. 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?;

Dim obj As Object = 42

' Attempt to unbox using 'as' to a nullable int type
Dim result? As Integer = CType(obj, Integer?)

Arbeiten mit Arrays

Arrays sind Referenztypen in C#. Manchmal müssen Sie möglicherweise feststellen, ob ein object ein bestimmter Array-Typ 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

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

' Attempt to cast to a string array using 'as'
Dim stringArray() As String = TryCast(arrayObject, String())

' stringArray will hold the array of strings if successful

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

Kombinieren von as mit LINQ

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 können Sie Objekte gemischter Typen in einer Sammlung abrufen und möchten spezifische Typen filtern. Hier kann der as-Operator sehr praktisch sein.

Zum Beispiel, betrachten Sie eine Liste von Objekten, die sowohl Strings als auch Ganzzahlen enthält. Wenn Sie nur die Strings abrufen wollten, könnten Sie den as-Operator in Verbindung 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"

Dim mixedList = New List(Of Object) From {"Hello", 42, "World", 100}

' Use LINQ to select only strings from mixedList
Dim stringValues = mixedList.Select(Function(item) TryCast(item, String)).Where(Function(item) item IsNot Nothing).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, in einer Art und Weise, die der Typkonvertierung ähnelt, sie 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, denken Sie an IronXL als ein Tool, das es Ihnen ermöglicht, Datenstrukturen oder Datenbankeinträge in C# nahtlos in Excel-Formate zu konvertieren.

IronOCR

Optical Character Recognition mit IronOCR ist ein Tool zur optischen Zeichenerkennung, das es Entwicklern ermöglicht, Text aus Bildern zu lesen und zu interpretieren. Um dies mit unserem Tutorial zu verbinden, ist es ähnlich der Konvertierung eines object (in diesem Fall ein Bild) 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 hilft Entwicklern bei der Erzeugung, dem Lesen und dem Dekodieren von Barcodes in C#-Anwendungen. In Bezug auf unsere Diskussion über Typkonvertierungen kann IronBarcode als ein Tool angesehen werden, das visuelle Barcode-Daten (eine Form von object) in spezifischere, nutzbare Datentypen, wie Strings oder Produktdetails, übersetzt.