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

Podstawy operatora as

Słowo kluczowe operatora as w C# to operator binarny używany do wykonywania pewnych konwersji między zgodnymi 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 podstawowy dla wszystkich typów w C#). Nie jesteśmy pewni jego podstawowego typu w czasie kompilacji. Operator as jest używany do próby traktowania myObj jako string. Jeśli się powiedzie, myStr będzie przechowywać wartość ciągu. W przeciwnym razie będzie przechowywać wartość null.

Czym różni się od Explicit Cast?

Chociaż zarówno operator as, jak i rzutowanie jawne służą podobnym celom, istnieje kluczowa różnica. Jeśli jawne rzutowanie nie powiedzie się, zgłasza wyjątek. Z drugiej strony, jeśli próba konwersji operatora as z jednego typu do drugiego się nie powiedzie, operator zwraca wartość null zamiast podnoszenia wyjątku. 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ć, korzystanie z operatora as może być często bezpieczniejsze, ponieważ unikasz potencjalnych błędów czasu wykonywania.

Konwersje typów wartości nullable

Jednym z wyjątkowych przypadków, w których operator as jest niezwykle cenny, są typy wartości nullable. Typy wartości (takie jak int, double, itp.) nie mogą być przypisane do wartości null. Jednak dzięki ustawieniu ich jako nullable można przypisać do nich wartość null. Operator as można użyć do próby konwersji do typu wartości nullable:

// 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 referencyjne (pomiędzy pokrewnymi typami referencyjnymi), 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"

Tutaj metoda konwersji zdefiniowana przez użytkownika pozwala traktować obiekt typu Sample jako string.

Kiedy nie ma zastosowania

Pamiętaj, że operator as nie może być używany z typami wartości (chyba że mamy do czynienia z typami wartości nullable) ani z konwersjami zdefiniowanymi przez użytkownika, które wymagają metody jawnej.

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 automatycznie dziedziczy po object. Kiedy pakujesz typ wartości, owijasz go w 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

Tutaj intValue jest pakowane do object.

Rozpakowywanie to proces odwrotny do pakowania, tj. wyodrębnianie 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 przechowuje typ wartości, którego się spodziewasz. 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 być konieczne ustalenie, czy object jest specyficznym typem tablicy, a następnie pracować z nią. Operator as może również pomóc w tej sytuacji.

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 faktycznie przechowuje ciągi. Za pomocą operatora as możesz bezpiecznie spróbować traktować to jako tablicę ciągów.

Kombinowanie 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żesz otrzymać obiekty różnych typów w kolekcji i chcieć wyodrębnić konkretne typy. Tutaj operator as może być bardzo przydatny.

Weźmy na przykład listę obiektów zawierającą zarówno ciągi znaków, jak i liczby całkowite. Jeśli chciałeś pobrać tylko ciągi, 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 wziąć dane wyjściowe twojej aplikacji i, w sposób podobny do konwersji typu, przełożyć je na dobrze sformatowany dokument PDF.

IronXL

Obsługa plików Excel jest częstym wymaganiem w wielu aplikacjach. IronXL for Excel Operations umożliwia deweloperom czytanie, edytowanie i tworzenie arkuszy Excel bez potrzeby polegania na Office Interop. W kontekście naszej dyskusji o konwersjach typu pomyśl o IronXL jako o narzędziu, które pozwala na płynne konwertowanie struktur danych lub wpisów do bazy danych w C# na formaty Excel.

IronOCR

Optical Character Recognition with IronOCR to narzędzie do rozpoznawania znaków optycznych, które pozwala deweloperom na odczyt i interpretację tekstu z obrazów. Łącząc to z naszym samouczkiem, jest to podobne do konwertowania object (w tym przypadku obrazu) na bardziej specyficzny typ (string lub dane tekstowe) za pomocą zaawansowanych możliwości rozpoznawania.

IronBarcode

W wielu aplikacjach komercyjnych obsługa BarCodes jest niezbędna. IronBarcode Tool for Barcode Processing pomaga deweloperom w generowaniu, odczytywaniu i dekodowaniu kodów kreskowych w aplikacjach C#. W odniesieniu do naszej dyskusji na temat konwersji typów, IronBarcode można postrzegać jako narzędzie, które przekształca wizualne dane kodu kreskowego (forma object) na bardziej specyficzne, użyteczne typy danych, takie jak ciągi lub szczegóły produktu.