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

Les bases de l'opérateur as

Le mot-clé de l'opérateur as en C# est un opérateur binaire utilisé pour effectuer certaines conversions entre types de référence compatibles ou types nullable. 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.

Dans le code ci-dessus, myObj est un objet de type object (le type de base pour tous les types en C#). Nous sommes incertains de son type sous-jacent lors de la compilation. L'opérateur as est utilisé pour tenter de traiter myObj comme un string. Si c'est réussi, myStr contiendra la valeur de la chaîne de caractères. Sinon, il contiendra une valeur null.

Quelle est la différence avec le Cast Explicite?

Bien que les opérateurs as et de cast explicite servent des objectifs similaires, il y a une différence clé. Si une conversion explicite échoue, une exception est levée. D'un autre côté, si la tentative de conversion de l'opérateur as d'un type à un autre échoue, l'opérateur retourne 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.

Comme cela est évident, utiliser l'opérateur as peut souvent être plus sûr car vous évitez des erreurs potentiellement fatales lors de l'exécution.

Conversions de types de valeurs nulles

Un des cas particuliers où l'opérateur as est inestimable est avec les types de valeur nullable. Les types de valeur (comme int, double, etc.) ne peuvent pas être assignés à 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?;

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

L'opérateur as supporte à la fois les conversions de référence (entre types de référence lié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"

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

Quand comme ne s'applique pas

Rappelez-vous que l'opérateur as ne peut pas être utilisé avec les types de valeur (sauf s'il s'agit de types de valeur nullable) 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 car chaque type de valeur hérite implicitement d'un object. Lorsque vous encapsulez un type de valeur, vous l'enroulez 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;

Ici, le intValue est encapsulé dans un object.

Le désencapsulation est le processus inverse de l'encapsulation, c'est-à-dire extraire le type de valeur du object. L'opérateur as peut être utilisé pour désencapsuler en toute sécurité des valeurs, particulièrement lorsque vous n'êtes pas sûr si le object contient 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?;

Travailler avec des tableaux

Les tableaux sont des types de référence en C#. Parfois, vous pourriez avoir besoin de déterminer si un object est un type spécifique de tableau, puis de travailler avec lui. L'opérateur as peut aussi aider 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

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.

Combiner 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. Parfois, vous pourriez récupérer des objets de types mixtes dans une collection et vouloir filtrer des types spécifiques. Ici, l'opérateur as peut être très utile.

Prenons l'exemple d'une liste d'objets contenant à la fois des chaînes de caractères et des nombres entiers. Si vous souhaitiez ne récupérer que les chaînes de caractères, vous pourriez utiliser l'opérateur as conjointement 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"

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, de façon 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 offre aux développeurs la possibilité de lire, éditer et créer des feuilles de calcul Excel sans avoir besoin de s'appuyer sur l'Interop Office. Dans le contexte de notre discussion sur les conversions de types, pensez à 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# vers des formats Excel de manière transparente.

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. En reliant cela à notre tutoriel, c'est similaire à la conversion d'un object (dans ce cas, une image) en un type plus spécifique (string ou des données textuelles) en utilisant des 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 des applications C#. En lien avec notre discussion sur les conversions de types, IronBarcode peut être vu comme un outil qui traduit les données visuelles des codes-barres (une forme de object) en des types de données plus spécifiques et utilisables, tels que des chaînes de caractères ou des détails de produits.