C# AS (Comment ça fonctionne pour les développeurs)

Principes de base de l'opérateur as

L'opérateur as en C# est un opérateur binaire permettant d'effectuer certaines conversions entre types référence compatibles ou types nullables. Le code suivant en fournit une démonstration simple :

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

Dans le code ci-dessus, myObj est un objet de type object (le type de base pour tous les types en C#). Nous ne connaissons pas son type sous-jacent lors de la compilation. L'opérateur as est utilisé pour tenter de traiter myObj comme un string. En cas de succès, myStr contiendra la valeur de chaîne. Sinon, il contiendra une valeur null.

Quelle est la différence avec le Cast Explicite?

Bien que l'opérateur as et le cast explicite servent des objectifs similaires, il existe une distinction clé. Si une conversion explicite échoue, une exception est levée. En revanche, si la tentative de conversion d'un type à un autre par l'opérateur as échoue, l'opérateur renvoie une valeur null au lieu de lever une exception. Comprenons cela à l'aide de l'exemple de code suivant :

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.

Comme vous pouvez le constater, l'utilisation de l'opérateur as peut souvent être plus sûre car elle permet d'éviter les erreurs d'exécution potentielles.

Conversions de types de valeurs nullables

L'un des cas particuliers où l'opérateur as s'avère indispensable concerne les types valeur nullables. Les types valeur (comme int, double, etc.) ne peuvent pas se voir attribuer une valeur null. Toutefois, en les rendant nullables, vous pouvez leur attribuer null. L'opérateur as peut être utilisé pour tenter une conversion vers un type de valeur 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?)

Conversions de référence et conversions définies par l'utilisateur

L'opérateur as prend en charge à la fois les conversions de référence (entre types de référence apparentés) et les conversions définies par l'utilisateur. Les conversions définies par l'utilisateur sont celles qui sont définies à l'aide de méthodes de conversion spéciales dans vos classes.

Considérons le code suivant d'une conversion définie par l'utilisateur :

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"

Ici, la méthode de conversion définie par l'utilisateur permet à un objet de type Sample d'être traité comme un string.

Quand as ne s'applique pas

N'oubliez pas que l'opérateur as ne peut pas être utilisé avec des types de valeurs (sauf s'il s'agit de types de valeurs nullables) ou avec des conversions définies par l'utilisateur qui impliquent une méthode explicite.

Boxing et Unboxing avec as

La mise en boîte est le processus de conversion d'une instance de type valeur en une référence d'objet. Ceci est rendu possible car chaque type de valeur hérite implicitement d'un object. Lorsque vous encadrez un type valeur, vous l'enveloppez dans un object.

Considérez le code suivant pour les conversions de mise en boîte :

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

Ici, le intValue est encadré dans un object.

Le déballage est le processus inverse de l'emballage, c'est-à-dire l'extraction du type de valeur à partir du object. L'opérateur as peut être utilisé pour déballer en toute sécurité des valeurs, en particulier lorsque vous n'êtes pas sûr que object contienne le type de valeur que vous attendez. Si l'unboxing échoue, le résultat de l'expression sera null.

Prenons l'exemple suivant pour les conversions d'unboxing :

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

Travailler avec des tableaux

Les tableaux sont des types de référence en C#. Parfois, vous devrez déterminer si un object est un type de tableau spécifique et ensuite travailler avec celui-ci. L'opérateur as peut également être utile ici.

Considérons le code suivant :

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

Dans le code ci-dessus, arrayObject est un tableau d'objets mais contient en réalité des chaînes de caractères. En utilisant l'opérateur as, vous pouvez tenter en toute sécurité de le traiter comme un tableau de chaînes de caractères.

Combinaison de as avec LINQ

Language Integrated Query (LINQ - Microsoft Documentation) est une fonctionnalité puissante de C# qui permet d'interroger des collections à la manière de SQL. Il arrive parfois que l'on récupère des objets de types mixtes dans une collection et que l'on souhaite filtrer certains types. Dans ce cas, l'opérateur as peut s'avérer très pratique.

Prenons l'exemple d'une liste d'objets contenant à la fois des chaînes de caractères et des nombres entiers. Si vous souhaitez récupérer uniquement les chaînes de caractères, vous pouvez utiliser l'opérateur as en conjonction avec 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 permet aux développeurs de générer, manipuler et lire des fichiers PDF au sein de leurs applications C#. En ce qui concerne la pertinence de notre sujet, supposons que vous disposiez d'un type de référence contenant des données et que vous souhaitiez convertir ces données en un rapport ou un document. IronPDF peut prendre la sortie de votre application et, d'une manière similaire à la conversion de type, la traduire en un document PDF bien formaté.

IronXL

La manipulation de fichiers Excel est une exigence fréquente dans de nombreuses applications logicielles. IronXL for Excel Operations permet aux développeurs de lire, modifier et créer des feuilles de calcul Excel sans avoir recours à Office Interop. Dans le cadre de notre discussion sur les conversions de types, considérez IronXL comme un outil permettant de convertir facilement des structures de données ou des entrées de base de données C# en formats Excel.

IronOCR

Optical Character Recognition with IronOCR est un outil de reconnaissance optique de caractères qui permet aux développeurs de lire et d'interpréter du texte à partir d'images. Pour faire le lien avec notre tutoriel, c'est similaire à la conversion d'un object (dans ce cas, une image) en un type plus spécifique (string ou données textuelles) à l'aide de capacités de reconnaissance avancées.

IronBarcode

Dans de nombreuses applications commerciales, la manipulation des BarCodes est indispensable. IronBarcode Tool for Barcode Processing aide les développeurs à générer, lire et décoder des codes-barres dans les applications C#. En lien avec notre discussion sur les conversions de type, IronBarcode peut être considéré comme un outil qui traduit les données visuelles de code-barres (une forme de object) en types de données plus spécifiques et utilisables, tels que des chaînes de caractères ou des détails de produit.