Quelle est la différence entre lancer et utiliser «as» en C #?

S’il y a une différence, quelle est la différence entre les deux manières de faire la dissortingbution suivante?

Dans ce cas, e est un object GridViewRowEventArgs .

 GridView gv = (GridView)e.Row.FindControl("gv"); //first way GridView gv2 = e.Row.FindControl("gv") as GridView; //second way 

Les différences sont les suivantes:

  • Si une dissortingbution échoue, une InvalidCastException .
  • Si l’opérateur as échoue, il renvoie simplement une référence nulle.
  • Vous ne pouvez pas utiliser as avec des types de valeur non nullables (par exemple, vous ne pouvez pas faire ” o as int “).
  • L’opérateur de dissortingbution est également utilisé pour le déballage. ( as peut être utilisé pour désinstaller un type de valeur nullable.)
  • L’opérateur de dissortingbution peut également effectuer des conversions définies par l’utilisateur.

EDIT: J’ai écrit ailleurs quand je pense qu’il est approprié d’utiliser quel opérateur. Cela pourrait valoir le coup de lire …

Ce qui n’est pas mentionné dans les réponses ci-dessus est l’ intention – pourquoi effectuez-vous la conversion et (plus important) ce qui se passe sur les lignes après la conversion?

Par exemple, j’ai vu un code similaire à ce qui suit un certain nombre de fois:

if ((foo as SomeType).SomeMethod()) { /* ... */ }

Cela pourrait être comparé à la version utilisant la dissortingbution:

if (((SomeType) foo).SomeMethod()) { /* ... */ }

Alors, lequel d’entre eux est le meilleur?

Le casting est.

L’utilisation de as entraînera une NullReferenceException si la conversion échoue.

L’utilisation d’une dissortingbution entraînera une InvalidCastException si la conversion échoue.

Maintenant dites-moi, quelle est une exception plus utile pour le débogage? Une NullReferenceException , qui pourrait être produite par presque n’importe quoi, ou une InvalidCastException , qui vous permet de savoir ce qui a réellement mal tourné?

Ainsi, n’utilisez as si la conversion était en fait facultative (ce qui signifie qu’il doit y avoir une vérification null avant d’utiliser la variable). Sinon, utilisez une dissortingbution, rendant ainsi vos intentions plus explicites.

En général, la différence entre un cast statique et “as” est que le cast lancera une exception s’il échoue, alors que “as” définira simplement la variable sur null.

L’instruction “as” tente essentiellement de convertir la variable et renvoie null si elle échoue plutôt que de lancer une exception. En tant que telle, la valeur à laquelle vous avez ajouté doit être nullable – un type de référence ou une primitive nullable. Dans votre exemple, vous devrez faire:

 int? i2 = o as int; 

ou il ne comstackra pas.

Le casting sûr comme

 variable as type 

fait la même chose que

 (variable is type) ? (type)variable : (type)null 

et ne fonctionnera pas pour les types de valeur.

Si toutefois vous utilisiez un type de référence, dites Table: le premier relèverait InvalidCastException au cas où o ne serait pas assignable à Table et le second renverrait simplement null.

Mis à part le problème que Jon a souligné, le mot-clé as est SomeClass comme SomeClass . Si o n’est pas dérivé de SomeClass il renvoie null . Alors qu’un simple casting lancerait une exception.

 SomeClass i2 = o as SomeClass; 

devient

 SomeClass i2; if (o is SomeClass) i2 = (SomeClass)o; else i2 = null; 

Je peux être en train de dire l’évidence ici, mais une chose que vous obtenez avec la dissortingbution «comme», c’est que vous avez la garantie de vous retrouver avec un object du type que vous avez demandé. Cela est pratique dans certaines situations.