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

Grundlagen des as Operators

Der Operator as in C# ist ein binärer Operator, der zur Durchführung bestimmter Konvertierungen zwischen kompatiblen Referenztypen oder Nullable-Typen verwendet wird. Der folgende Code veranschaulicht dies:

// 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 über den zugrundeliegenden Typ zur Kompilierzeit nicht im Klaren. Der Operator as wird verwendet, um zu versuchen, myObj als string zu behandeln. Im Erfolgsfall enthält myStr den Zeichenkettenwert. Andernfalls enthält es den Wert null.

Unterscheidet sich von Explicit Cast?

Obwohl sowohl der Operator as als auch die explizite Typumwandlung ähnliche Zwecke erfüllen, gibt es einen wichtigen Unterschied. Wenn ein expliziter Cast fehlschlägt, wird eine Ausnahme ausgelöst. Wenn der Versuch des Operators as, von einem Typ in einen anderen zu konvertieren, fehlschlägt, gibt der Operator einen Wert vom Typ null 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, ist die Verwendung des Operators as oft sicherer, da man so potenzielle Laufzeitfehler vermeidet.

Nullbare Werttyp-Konvertierungen

Einer der Sonderfälle, in denen der Operator as von unschätzbarem Wert ist, betrifft Werttypen, die Nullwerte zulassen. Werttypen (wie int, double usw.) können keinen Wert vom Typ null zugewiesen bekommen. Indem Sie sie jedoch nullable machen, können Sie ihnen null zuweisen. Der Operator as kann verwendet werden, um zu versuchen, in einen Nullable-Werttyp zu konvertieren:

// 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 Operator as 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 ermöglicht die benutzerdefinierte Konvertierungsmethode, dass ein Objekt vom Typ Sample als string behandelt wird.

Wenn as nicht zutrifft

Beachten Sie, dass der Operator as nicht mit Werttypen (außer bei Nullable-Werttypen) oder mit benutzerdefinierten Konvertierungen, die eine explizite Methode beinhalten, 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 Werttyp in eine Box einbetten, umschließen Sie ihn mit 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 einen object eingeschlossen.

Unboxing ist der umgekehrte Prozess des Boxings, d. h. das Extrahieren des Werttyps aus dem object. Der Operator as kann verwendet werden, um Werte sicher zu entpacken, insbesondere wenn Sie sich nicht sicher sind, ob der Wert object den erwarteten Werttyp 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 es sich bei einem object um einen bestimmten Array-Typ handelt und dann damit arbeiten. Der Operator as kann hier ebenfalls 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, enthält aber tatsächlich Zeichenketten. Mit dem Operator as können Sie versuchen, es gefahrlos als ein Array von Zeichenketten zu behandeln.

Kombination 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 ruft man Objekte unterschiedlicher Typen in einer Sammlung ab und möchte bestimmte Typen herausfiltern. Hier kann der Operator as sehr hilfreich sein.

Zum Beispiel, betrachten Sie eine Liste von Objekten, die sowohl Strings als auch Ganzzahlen enthält. Wenn Sie nur die Zeichenketten abrufen möchten, können Sie den Operator as 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 entgegennehmen und sie, ähnlich einer Typkonvertierung, in ein gut formatiertes PDF-Dokument umwandeln.

IronXL

Der Umgang mit Excel-Dateien ist in vielen Softwareanwendungen eine häufige Anforderung. IronXL for Excel Operations ermöglicht Entwicklern das Lesen, Bearbeiten und Erstellen von Excel-Tabellen, ohne auf Office Interop angewiesen zu sein. Im Kontext unserer Diskussion über Typkonvertierungen können Sie sich IronXL als ein Werkzeug vorstellen, mit dem Sie Datenstrukturen oder Datenbankeinträge in C# nahtlos in Excel-Formate konvertieren können.

IronOCR

Optical Character Recognition with IronOCR ist ein optisches Zeichenerkennungstool, das es Entwicklern ermöglicht, Text aus Bildern zu lesen und zu interpretieren. Um die Verbindung zu unserem Tutorial herzustellen: Es ist ähnlich wie die Umwandlung eines object (in diesem Fall ein Bild) in einen spezifischeren Typ (string oder Textdaten) mithilfe erweiterter Erkennungsfunktionen.

IronBarcode

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