Programowanie w języku C# często wiąże się z pracą z różnymi typami danych. Czasami musimy sprawdzić, czy object jest określonego typu, lub spróbować go przekonwertować do tego typu. Właśnie wtedy przydaje się as słowo kluczowe operatora. Wraz z bliskim krewnym, is operator pomaga w testowaniu typów i konwersjach. W tym samouczku omówimy zawiłości tego operatora i jego zastosowania.

Zrozumienie operatora as

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.

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

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.

Związek z operatorem is

Często operator as jest używany w połączeniu z operatorem is do testowania typu przed podjęciem próby konwersji. Operator is sprawdza, czy podany obiekt jest określonego typu, i zwraca true, jeśli tak jest, w przeciwnym razie zwraca false.

Poniższy przykład kodu ilustruje to:

object testObject = "This is a string";

// Check if testObject is of type string
if (testObject is string) {
    // If true, convert testObject to string using 'as'
    string result = testObject as string;
    Console.WriteLine(result); // Outputs: This is a string
} else {
    Console.WriteLine("Not a string");
}

object testObject = "This is a string";

// Check if testObject is of type string
if (testObject is string) {
    // If true, convert testObject to string using 'as'
    string result = testObject as string;
    Console.WriteLine(result); // Outputs: This is a string
} else {
    Console.WriteLine("Not a string");
}

Dim testObject As Object = "This is a string"

' Check if testObject is of type string
If TypeOf testObject Is String Then
	' If true, convert testObject to string using 'as'
	Dim result As String = TryCast(testObject, String)
	Console.WriteLine(result) ' Outputs: This is a string
Else
	Console.WriteLine("Not a string")
End If

Dim testObject As Object = "This is a string"

' Check if testObject is of type string
If TypeOf testObject Is String Then
	' If true, convert testObject to string using 'as'
	Dim result As String = TryCast(testObject, String)
	Console.WriteLine(result) ' Outputs: This is a string
Else
	Console.WriteLine("Not a string")
End If

Wraz z wprowadzeniem dopasowania wzorców w późniejszych wersjach C#, operator is może również wykonywać pewne działania, jeśli test typu zakończy się powodzeniem. To często zmniejsza potrzebę używania operatora as.

Głębsza analiza: szczególne przypadki i kwestie do rozważenia

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

' 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"

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.

Zaawansowane scenariusze z operatorem as

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

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

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

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"

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"

Integracja z Iron Suite

Iron Suite Solutions for C# Developers to zestaw wysokiej jakości narzędzi, które umożliwiają programistom C# płynną integrację takich funkcji, jak obróbka plików PDF, obsługa arkuszy kalkulacyjnych Excel, optyczne rozpoznawanie znaków (OCR) oraz generowanie i odczytywanie kodów kreskowych (BarCode). Te narzędzia, jak nasza wcześniejsza dyskusja na temat operatorów as i is, są kluczowe w zwiększaniu efektywności programisty w budowaniu solidnych aplikacji.

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.

Wnioski

Każdy produkt w ramach oferty Iron Suite stanowi świadectwo elastyczności i mocy języka C#, zwłaszcza w kontekście naszej dyskusji na temat konwersji typów i sprawdzania typów. Te narzędzia, jak operatory as i is, zapewniają deweloperom możliwość efektywnego konwertowania i przetwarzania danych.

Jeśli zastanawiasz się nad zintegrowaniem któregoś z tych narzędzi w swoich projektach, warto zauważyć, że każda licencja produktu zaczyna się od $999 i każdy produkt oferuje bezpłatną wersję próbną narzędzi Iron Suite. Dla tych, którzy szukają kompleksowego rozwiązania, Iron Suite oferuje kuszącą ofertę: można nabyć licencję Iron Suite w cenie zaledwie dwóch produktów.