C# AS (jak to działa dla programistów)

Podstawy operatora as

Słowo kluczowe operatora as w języku C# jest operatorem binarnym służącym do wykonywania określonych konwersji między kompatybilnymi typami referencyjnymi lub typami nullable. Poniższy kod przedstawia prostą demonstrację:

// 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.

W powyższym kodzie myObj jest obiektem typu object (typ bazowy dla wszystkich typów w języku C#). Nie mamy pewności co do jego typu bazowego w czasie kompilacji. Operator as służy do próby traktowania myObj jako string. W przypadku powodzenia myStr będzie zawierać wartość ciągu znaków. W przeciwnym razie będzie miała wartość null.

Czym różni się od Explicit Cast?

Chociaż zarówno operator as, jak i jawne rzutowanie służą podobnym celom, istnieje między nimi zasadnicza różnica. Jeśli jawne rzutowanie nie powiedzie się, zgłasza wyjątek. Z drugiej strony, jeśli próba konwersji z jednego typu na inny przez operator as zakończy się niepowodzeniem, operator zwraca wartość null zamiast zgłaszać wyjątek. Zrozumiemy to na podstawie poniższego przykładu kodu:

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.

Jak widać, użycie operatora as często może być bezpieczniejsze, ponieważ pozwala uniknąć potencjalnych błędów wykonania.

Konwersje typów wartości nullable

Jednym ze szczególnych przypadków, w których operator as jest nieoceniony, są typy wartości, które mogą przyjmować wartość null. Typom wartości (takim jak int, double itp.) nie można przypisać wartości null. Jednak dzięki ustawieniu ich jako nullable można przypisać do nich wartość null. Operator as może służyć do próby konwersji na typ wartości, który może przyjmować wartość null:

// 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?)

Konwersje referencyjne i konwersje zdefiniowane przez użytkownika

Operator as obsługuje zarówno konwersje referencji (między powiązanymi typami referencji), jak i konwersje zdefiniowane przez użytkownika. Konwersje zdefiniowane przez użytkownika to konwersje zdefiniowane przy użyciu specjalnych metod konwersji w klasach.

Rozważmy następujący kod konwersji zdefiniowanej przez użytkownika:

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"

W tym przypadku metoda konwersji zdefiniowana przez użytkownika pozwala na traktowanie obiektu typu Sample jako string.

Kiedy nie ma zastosowania

Należy pamiętać, że operator as nie może być używany z typami wartości (chyba że chodzi o typy wartości, które mogą przyjmować wartość null) ani z konwersjami zdefiniowanymi przez użytkownika, które obejmują metodę jawną.

Pakowanie i rozpakowywanie za pomocą as

Boxing to proces przekształcania instancji typu wartościowego w odwołanie do obiektu. Jest to możliwe, ponieważ każdy typ wartości dziedziczy niejawnie po object. Kiedy umieszczasz typ wartości w ramce, otaczasz go tagiem object.

Rozważmy następujący kod służący do konwersji typów:

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

W tym przypadku intValue jest umieszczone w ramce object.

Rozpakowywanie jest procesem odwrotnym do pakowania, tj. wyodrębnianiem typu wartości z object. Operator as może być używany do bezpiecznego rozpakowywania wartości, szczególnie gdy nie masz pewności, czy object zawiera typ wartości, którego oczekujesz. Jeśli rozpakowanie nie powiedzie się, wynik wyrażenia będzie wynosił null.

Rozważmy następujący przykład konwersji związanych z rozpakowywaniem:

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?)

Praca z tablicami

Tablice są typami referencyjnymi w języku C#. Czasami może zaistnieć potrzeba ustalenia, czy object jest konkretnym typem tablicy, a następnie pracy z nią. Operator as może być tutaj pomocny.

Rozważmy następujący kod:

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

W powyższym kodzie arrayObject jest tablicą obiektów, ale w rzeczywistości zawiera ciągi znaków. Używając operatora as, można bezpiecznie potraktować to jako tablicę ciągów znaków.

Łączenie as z LINQ

Language Integrated Query (LINQ — dokumentacja Microsoft) to potężna funkcja języka C#, która umożliwia przeszukiwanie kolekcji w sposób podobny do języka SQL. Czasami może się zdarzyć, że w kolekcji znajdują się obiekty różnych typów i chcesz odfiltrować konkretne typy. W takiej sytuacji bardzo przydatny może być operator as.

Weźmy na przykład listę obiektów zawierającą zarówno ciągi znaków, jak i liczby całkowite. Jeśli chcesz pobrać tylko ciągi znaków, możesz użyć operatora as w połączeniu z LINQ:

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 pozwala programistom generować, modyfikować i odczytywać pliki PDF w ramach ich aplikacji napisanych w języku C#. Biorąc pod uwagę związek z naszym tematem, załóżmy, że masz typ referencyjny zawierający pewne dane i chcesz przekształcić te dane w raport lub dokument. IronPDF może pobrać dane wyjściowe aplikacji i, w sposób podobny do konwersji typów, przetłumaczyć je na dobrze sformatowany dokument PDF.

IronXL

Obsługa plików Excel jest częstym wymaganiem w wielu aplikacjach. IronXL for Excel Operations zapewnia programistom możliwość odczytu, edycji i tworzenia arkuszy kalkulacyjnych Excel bez konieczności korzystania z Office Interop. W kontekście naszej dyskusji na temat konwersji typów, potraktuj IronXL jako narzędzie, które pozwala na płynną konwersję struktur danych lub wpisów baz danych w C# do formatów Excel.

IronOCR

Optical Character Recognition with IronOCR to narzędzie do optycznego rozpoznawania znaków, które pozwala programistom odczytywać i interpretować tekst z obrazów. W nawiązaniu do naszego samouczka jest to podobne do konwersji object (w tym przypadku obrazu) na bardziej konkretny typ (string lub dane tekstowe) przy użyciu zaawansowanych funkcji rozpoznawania.

IronBarcode

W wielu aplikacjach komercyjnych obsługa BarCodes jest niezbędna. IronBarcode Tool for Barcode Processing pomaga programistom w generowaniu, odczytywaniu i dekodowaniu BARCODE-ów w aplikacjach napisanych w języku C#. W nawiązaniu do naszej dyskusji na temat konwersji typów, IronBarcode można postrzegać jako narzędzie, które przekształca wizualne dane BarCode (formę object) na bardziej konkretne, użyteczne typy danych, takie jak ciągi znaków lub szczegóły produktu.