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

Compréhension de l'opérateur as

Les bases 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 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.

' 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 sommes pas certains de son type sous-jacent à la compilation. L'opérateur as est utilisé pour tenter de traiter myObj comme un string. Si cela réussit, 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 la conversion explicite servent à des fins similaires, il y a une différence clé. Si une conversion explicite échoue, une exception est levée. D'autre part, si la tentative de conversion de l'opérateur as d'un type à un autre é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.

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 cela est évident, utiliser l'opérateur as peut souvent être plus sûr car vous évitez les erreurs potentielles à l'exécution.

La connexion avec l'opérateur is

Souvent, l'opérateur as est utilisé en conjonction avec l'opérateur is pour tester le type avant de tenter une conversion. L'opérateur is vérifie si l'objet fourni est du type donné et renvoie true s'il l'est, sinon, il renvoie false.

L'exemple de code suivant en est l'illustration :

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

Avec l'introduction de la correspondance de motifs dans les versions ultérieures de C#, l'opérateur is peut également effectuer certaines actions si le test de type réussit. Cela réduit souvent le besoin d'utiliser l'opérateur as.

Approfondissement : 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 nullables. Les types de 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 en 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?)

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

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 de traiter un objet de type Sample 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 en cas de traitement de types de valeur nullables) ou avec des conversions définies par l'utilisateur qui impliquent une méthode explicite.

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

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 rendu possible parce que chaque type de valeur hérite implicitement d'un object. Lorsque vous encadrez un type de 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

Dim intValue As Integer = 42

' Box the value type to an object
Dim boxedValue As Object = intValue

Ici, intValue est encadré dans un object.

Le désemboîtement est le processus inverse de l'emboîtement, c'est-à-dire l'extraction du type de valeur du object. L'opérateur as peut être utilisé pour désemboxer en toute sécurité les valeurs, en particulier lorsque vous n'êtes pas sûr que le 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?)

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 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 également 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

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

Dans le code ci-dessus, arrayObject est un tableau d'objets mais contient en fait des chaînes. En utilisant l'opérateur as, vous pouvez tenter en toute sécurité 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. Parfois, vous pourriez récupérer des objets de types mixtes dans une collection et vouloir filtrer les 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 vouliez récupérer uniquement les chaînes, vous pourriez 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"

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"

Intégration avec Iron Suite

Les solutions Iron Suite pour les développeurs C# sont une suite d'outils de haute qualité qui permettent aux développeurs C# d'intégrer de manière transparente des fonctionnalités telles que la manipulation de PDF, le traitement d'Excel, la reconnaissance optique de caractères (OCR), ainsi que 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 création 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 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 semblable à 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 fournit aux développeurs la capacité de lire, modifier et créer des feuilles de calcul Excel sans avoir besoin de s'appuyer sur 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# en 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 le texte à partir d'images. Relier 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 les applications C#. En relation 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 types de données plus spécifiques et utilisables, tels que des chaînes ou des détails de produit.

Conclusion

Chaque produit de la Offres de la Suite Iron témoigne de la flexibilité et de la puissance qu'offre le langage C#, en particulier lorsqu'il est lié à notre discussion sur les conversions de type et la vérification de type. Ces outils, comme les opérateurs as et is, fournissent 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 à noter que chaque licence de produit commence à partir de $999 et que chaque produit offre une 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 pour le prix de seulement deux produits.