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

Bases de l'opérateur as

Le mot-clé d'opérateur as en C# est un opérateur binaire utilisé pour effectuer certaines conversions entre des types de référence compatibles ou des types nullables. Le code suivant 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 objet (le type de base pour tous les types en C#). Nous ne connaissons pas son type sous-jacent au moment de la compilation. L'opérateur as est utilisé pour tenter de traiter myObj comme une chaîne. En cas de succès, myStr contiendra la valeur de la chaîne. Dans le cas contraire, elle aura une valeur null.

Quelle est la différence avec le Cast Explicite?

Bien que l'opérateur as et le cast explicite aient des fonctions similaires, il existe une distinction essentielle. Si une conversion explicite échoue, une exception est levée. En revanche, si la tentative de conversion d'un type à un autre de l'opérateur as échoue, l'opérateur renvoie une valeur null au lieu de soulever 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.

Il est évident que l'utilisation de l'opérateur as est souvent plus sûre, car elle permet d'éviter les erreurs d'exécution potentielles.

Conversions de types de valeurs nulles

L'un des cas particuliers où l'opérateur as est inestimable est celui des types de valeur nullables. Les types de valeurs (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 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 une string.

Quand comme ne s'applique pas

N'oubliez pas que l'opérateur as ne peut pas être utilisé avec des types de valeur (sauf s'il s'agit de types de valeur 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. Cela est possible parce que chaque type de valeur hérite implicitement d'un objet. Lorsque vous mettez en boîte un type de valeur, vous l'intégrez dans un objet.

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, la intValue est encadrée dans un objet.

L'unboxing est le processus inverse du boxing, c'est-à-dire l'extraction du type de valeur de l'objet. L'opérateur as peut être utilisé pour décompresser des valeurs en toute sécurité, en particulier lorsque vous n'êtes pas sûr que l'objet 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 objet est un type spécifique de tableau, puis l'utiliser. L'opérateur as peut également s'avérer utile.

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 sans risque essayer de le traiter comme un tableau de chaînes.

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 peut arriver que vous récupériez des objets de types mixtes dans une collection et que vous souhaitiez filtrer des types spécifiques. 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

C# AS (How It Works For Developers) Figure 1 - IronPDF for .NET : La bibliothèque PDF C#

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 qui s'apparente à la conversion de caractères, la traduire en un document PDF bien formaté.

IronXL

C# AS (How It Works For Developers) Figure 2 - IronXL for .NET : La bibliothèque Excel C#

La manipulation de fichiers Excel est une exigence fréquente dans de nombreuses applications logicielles. IronXL pour les opérations Excel offre aux développeurs la possibilité de lire, modifier et créer des feuilles de calcul Excel sans devoir recourir à Office Interop. Dans le contexte de notre discussion sur les conversions de types, considérez IronXL comme un outil qui vous permet de convertir des structures de données ou des entrées de base de données en C# dans des formats Excel de manière transparente.

IronOCR

C# AS (How It Works For Developers) Figure 3 - IronOCR for .NET : La bibliothèque OCR C#

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, il s'agit de convertir un objet (dans ce cas, une image) en un type plus spécifique (chaîne ou données textuelles) à l'aide de capacités de reconnaissance avancées.

IronBarcode

C# AS (How It Works For Developers) Figure 4 - IronBarcode for .NET : La bibliothèque BarCode C#

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