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

La programmation en C# implique souvent de travailler avec différents types de données. Parfois, nous devons vérifier si un objet est d'un certain type ou tenter de le convertir à ce type. C'est là que le mot-clé opérateur as devient utile. Avec son proche parent, l'opérateur is aide aux tests de type et aux conversions. Dans ce tutoriel, nous allons explorer les subtilités de cet opérateur et ses cas d'utilisation.

Comprendre l'opérateur as

Notions de base de l'opérateur as

Le mot-clé 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 annulables. Le code suivant fournit une simple démonstration :

object myObj = "Hello, World!";
string myStr = myObj as string;

object myObj = "Hello, World!";
string myStr = myObj as string;

Dim myObj As Object = "Hello, World!"
Dim myStr As String = TryCast(myObj, String)

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

Quelle est la différence avec le casting explicite ?

Bien que l'opérateur as et le cast explicite servent des objectifs similaires, il existe une distinction clé. Si un cast explicite échoue, il lève une exception. D'autre part, si la tentative de conversion d'un type à un autre par l'opérateur as échoue, l'opérateur retourne une valeur nulle au lieu de déclencher une exception. Comprenons-le à l'aide de l'exemple de code suivant :

object someValue = 12345;

// Using explicit cast
string castResult;
try {
    castResult = (string)someValue; // This will throw an exception since the cast fails.
}
catch(Exception ex) {
    castResult = null;
}

// Using the as operator
string asResult = someValue as string; // No exception, but asResult will be null since the cast fails.

object someValue = 12345;

// Using explicit cast
string castResult;
try {
    castResult = (string)someValue; // This will throw an exception since the cast fails.
}
catch(Exception ex) {
    castResult = null;
}

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

' Using explicit cast
Dim castResult As String
Try
	castResult = DirectCast(someValue, String) ' This will throw an exception since the cast fails.
Catch ex As Exception
	castResult = Nothing
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 cela est évident, utiliser l'opérateur as peut souvent être plus sûr car vous évitez des erreurs d'exécution potentielles.

La connexion avec l'opérateur is

Souvent, l'opérateur as est utilisé conjointement avec l'opérateur is pour tester le type avant d'essayer une conversion. L'opérateur is vérifie si l'objet fourni est du type donné et renvoie true si c'est le cas, sinon, il renvoie false.

L'exemple de code suivant l'illustre :

object testObject = "This is a string";

if(testObject is string) {
    string result = testObject as string;
    Console.WriteLine(result);
} else {
    Console.WriteLine("Not a string");
}

object testObject = "This is a string";

if(testObject is string) {
    string result = testObject as string;
    Console.WriteLine(result);
} else {
    Console.WriteLine("Not a string");
}

Dim testObject As Object = "This is a string"

If TypeOf testObject Is String Then
	Dim result As String = TryCast(testObject, String)
	Console.WriteLine(result)
Else
	Console.WriteLine("Not a string")
End If

Avec l'introduction du pattern matching dans les versions ultérieures de C#, l'opérateur is peut également effectuer certaines actions si le test de type est réussi. Cela réduit souvent le besoin d'utiliser l'opérateur as.

Pour aller plus loin Cas particuliers et considérations

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 se voir attribuer une valeur null. Cependant, en les rendant nullables, vous pouvez leur assigner null. L'opérateur as peut être utilisé pour tenter une conversion vers un type de valeur nullable :

int? nullableInt = 10;
object objInt = nullableInt;
int? resultInt = objInt as int?;

int? nullableInt = 10;
object objInt = nullableInt;
int? resultInt = objInt as int?;

Dim nullableInt? As Integer = 10
Dim objInt As Object = nullableInt
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 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 {
    public static implicit operator string(Sample s) {
        return "Converted to String";
    }
}

Sample sampleObject = new Sample();
string conversionResult = sampleObject as string;

class Sample {
    public static implicit operator string(Sample s) {
        return "Converted to String";
    }
}

Sample sampleObject = new Sample();
string conversionResult = sampleObject as string;

Friend Class Sample
	Public Shared Widening Operator CType(ByVal s As Sample) As String
		Return "Converted to String"
	End Operator
End Class

Private sampleObject As New Sample()
Private conversionResult As String = TryCast(sampleObject, 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 valeurs (sauf s'il s'agit de types valeurs nullable) ou avec des conversions définies par l'utilisateur impliquant une méthode explicite.

Scénarios avancés avec l'opérateur as

Boxe 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. C'est possible parce que chaque type de valeur hérite implicitement d'un object. Lorsque vous encadrez un type de valeur, vous l'enveloppez à l'intérieur d'un object.

Considérons le code suivant pour les conversions de boîtes :

int intValue = 42;
object boxedValue = intValue;

int intValue = 42;
object boxedValue = intValue;

Dim intValue As Integer = 42
Dim boxedValue As Object = intValue

Ici, la intValue est encapsulée dans un object.

Le déboîtage est le processus inverse de l'emboîtage, c'est-à-dire extraire le type de valeur de l'objet. L'opérateur as peut être utilisé pour désencapsuler les valeurs en toute sécurité, en particulier lorsque vous n'êtes pas sûr que l'objet contient le type de valeur attendu. Si l'unboxing échoue, le résultat de l'expression sera null.

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

object obj = 42;
int? result = obj as int?;

object obj = 42;
int? result = obj as int?;

Dim obj As Object = 42
Dim result? As Integer = CType(obj, Integer?)

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 travailler avec lui. L'opérateur as peut également aider ici.

Considérons le code suivant :

object[] arrayObject = new string[] { "one", "two", "three" };
string[] stringArray = arrayObject as string[];

object[] arrayObject = new string[] { "one", "two", "three" };
string[] stringArray = arrayObject as string[];

Dim arrayObject() As Object = New String() { "one", "two", "three" }
Dim stringArray() As String = TryCast(arrayObject, String())

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 essayer 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 - Documentation Microsoft) est une fonctionnalité puissante en C# qui vous permet de requêter des collections de manière similaire à 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 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, vous pouvez utiliser l'opérateur as en conjonction avec LINQ :

var mixedList = new List<object> { "Hello", 42, "World", 100 };
var stringValues = mixedList
    .Select(item => item as string)
    .Where(item => item != null)
    .ToList();

var mixedList = new List<object> { "Hello", 42, "World", 100 };
var stringValues = mixedList
    .Select(item => item as string)
    .Where(item => item != null)
    .ToList();

Dim mixedList = New List(Of Object) From {"Hello", 42, "World", 100}
Dim stringValues = mixedList.Select(Function(item) TryCast(item, String)).Where(Function(item) item IsNot Nothing).ToList()

Intégration avec Iron Suite

Solutions Iron Suite pour les développeurs C# est une suite d'outils de haute qualité qui permettent aux développeurs C# d'intégrer facilement des fonctionnalités telles que la manipulation de PDF, la gestion d'Excel, la reconnaissance optique de caractères (OCR), et la génération et la lecture de codes-barres. Ces outils, comme notre discussion précédente sur les opérateurs as et is, sont essentiels pour amplifier l'efficacité d'un développeur dans la construction d'applications robustes.

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 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 rapport ou en document. IronPDF peut prendre la sortie de votre application et, de 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 besoin de se fier à Office Interop. Dans le cadre 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# en formats Excel de manière transparente.

IronOCR

Reconnaissance Optique de Caractères avec 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. Relier cela à notre tutoriel, c'est similaire à la conversion d'un objet (dans ce cas, une image) en un type plus spécifique (chaîne ou données textuelles) en utilisant des capacités de reconnaissance avancées.

IronBarcode

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

Conclusion

Chaque produit de l'offre Iron Suite témoigne de la flexibilité et de la puissance que C# offre, surtout lorsqu'il est intégré dans notre discussion sur les conversions de types et la vérification de types. Ces outils, comme les opérateurs as et is, offrent aux développeurs la capacité de convertir et de traiter les données efficacement.

Si vous envisagez d'intégrer l'un de ces outils dans vos projets, il est important de noter que chaque licence de produit commence à partir de $749 et que chaque produit offre un essai gratuit des outils Iron Suite. Pour ceux qui recherchent une solution complète, Iron Suite propose une offre alléchante : vous pouvez acquérir la licence Iron Suite au prix de seulement deux produits.