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 dans ce type. C'est là que lemot-clé de l'opérateur `as s'avère très utile. Avec son proche parent, l'opérateur is facilite les tests de type et les 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 sur 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 :

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 connaissons pas son type sous-jacent au moment de la compilation. L'opérateur as est utilisé pour essayer de traiter myObj comme une chaîne. En cas de succès, myStr contiendra la valeur de la chaîne. Sinon, il contiendra une valeur nulle.

Quelle est la différence avec le casting explicite ?

Bien que la distribution en tant qu'opérateur et la distribution explicite aient des objectifs similaires, il existe une distinction essentielle. Si un cast explicite échoue, il lève une exception. En revanche, si la tentative de conversion d'un type vers un autre par l'opérateur as échoue, l'opérateur renvoie une valeur null au lieu de soulever 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 on peut le constater, l'utilisation de l'opérateur as est souvent plus sûre, car elle permet d'éviter les erreurs d'exécution potentielles.

La connexion avec l'opérateur is

Souvent, l'opérateur as' est utilisé en conjonction avec l'opérateuris' 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 vrai si c'est le cas, sinon il renvoie faux.

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 de la recherche 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 la nécessité d'utiliser l'opérateur as.

Pour aller plus loin Cas particuliers et considérations

Conversions de types de valeurs nulles

L'un des cas particuliers où l'opérateur as est inestimable est celui des types de valeurs nullables. Types de valeurs(comme int, double, etc.) ne peut pas se voir attribuer une valeur nulle. 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 les deux conversions de référence(entre des types de référence apparentés) et des 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 de traiter un objet de type Sample comme une chaîne.

Quand as ne s'applique pas

Rappelez-vous que l'opérateur as ne peut pas être utilisé avec les types de valeurs(sauf s'il s'agit d'un type de valeur nullable) ou avec des conversions définies par l'utilisateur qui impliquent 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. Ceci est possible car chaque type de valeur hérite implicitement d'un objet. Lorsque vous encadrez un type de valeur, vous l'enveloppez dans un objet.

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 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;
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 devrez déterminer si un objet est un type spécifique de tableau et ensuite travailler avec lui. L'opérateur as peut également s'avérer utile.

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 fait 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 de caractères.

Combiner as avec LINQ

Langue Requête intégrée(LINQ - Documentation Microsoft) est une fonctionnalité puissante de C# qui vous permet d'interroger des collections à la manière de SQL. Il peut arriver que vous récupériez des objets de types différents 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 vouliez récupérer uniquement les chaînes de caractères, vous pourriez 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 permet aux développeurs C# d'intégrer de manière transparente des fonctionnalités telles que la manipulation de PDF, d'Excel, la reconnaissance optique de caractères, etc(OCR)ainsi que la génération et la lecture de codes-barres. Ces outils, tout 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, d'une manière qui s'apparente à une 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 pour les opérations sur Excel offre aux développeurs la possibilité de lire, d'éditer et de créer des feuilles de calcul Excel sans avoir besoin de 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

Reconnaissance optique des 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. Pour faire le lien avec notre tutoriel, il s'agit de convertir un objet en(dans ce cas, une image) à un type plus spécifique(string 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 les applications C#. En relation avec notre discussion sur les conversions de types, IronBarcode peut être considéré comme un outil qui traduit les données visuelles d'un code-barres(une forme de 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.

Conclusion

Chaque produit de la gammeLes offres d'Iron Suite témoigne de la flexibilité et de la puissance de C#, en particulier lorsqu'elle est liée à notre discussion sur les conversions de type et la vérification de type. Ces outils, comme les opérateurs as et is, permettent aux développeurs de convertir et de traiter efficacement les données.

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