c# - Casting: (NewType) vs Object as NewType

Translate

Duplicata possible:
Diffusion vs utilisation du mot-clé "as" dans le CLR

Quelle est réellement la différence entre ces deux moulages?

SomeClass sc = (SomeClass)SomeObject;
SomeClass sc2 = SomeObject as SomeClass;

Normalement, ils devraient tous les deux être des transtypages explicites vers le type spécifié?

This question and all comments follow the "Attribution Required."

Toutes les réponses

Translate

Le premier lèvera une exception si le type source ne peut pas être converti en type cible. Ce dernier résultera en sc2 étant une référence nulle, mais sans exception.

[Éditer]

Ma réponse originale est certainement la différence la plus prononcée, mais comme Eric Lippertfait remarquer, ce n'est pas le seul. D'autres différences incluent:

  • Vous ne pouvez pas utiliser l'opérateur 'as' pour convertir en un type qui n'accepte pas 'null' comme valeur
  • Vous ne pouvez pas utiliser «comme» pourconvertirdes choses, comme des nombres à une représentation différente (float to int, par exemple).

Et enfin, en utilisant 'as' par rapport à l'opérateur de distribution, vous dites également "Je ne sais pas si cela réussira."

La source
Translate

Notez également que vous ne pouvez utiliser le mot clé as qu'avec un type référence ou un type Nullable

c'est à dire:

double d = 5.34;
int i = d as int;

ne compilera pas

double d = 5.34;
int i = (int)d;

compilera.

La source
Joe
Translate

La conversion de type en utilisant "comme" est bien sûr beaucoup plus rapide lorsque la distribution échoue, car elle évite les frais liés à la levée d'une exception.

Mais ce n'est pas plus rapide lorsque le casting réussit. Le graphique àhttp://www.codeproject.com/KB/cs/csharpcasts.aspxest trompeur car il n'explique pas ce qu'il mesure.

L'essentiel est:

  • Si vous vous attendez à ce que le casting réussisse (c'est-à-dire qu'un échec serait exceptionnel), utilisez un casting.

  • Si vous ne savez pas si cela réussira, utilisez l'opérateur "as" et testez le résultat pour null.

La source
Translate

Une différence entre les deux approches est que la première ((SomeClass) obj) peut provoquer unconvertisseur de typeêtre appelé.

La source
Translate

Voici un bon moyen de me souvenir du processus que chacun d'entre eux suit et que j'utilise lorsque j'essaie de décider ce qui est le mieux pour ma situation.

DateTime i = (DateTime)value;
// is like doing
DateTime i = value is DateTime ? value as DateTime : throw new Exception(...);

et le suivant devrait être facile de deviner ce qu'il fait

DateTime i = value as DateTime;

dans le premier cas, si la valeur ne peut pas être castée, une exception est levée dans le second cas si la valeur ne peut pas être castée, i est défini sur null.

Ainsi, dans le premier cas, un arrêt brutal est effectué si la distribution échoue dans le second casting, un arrêt progressif est effectué et vous pourriez rencontrer une exception NullReferenceException plus tard.

La source
Translate

bienl'opérateur "as" "vous aide" à enterrer votre problème bien plus bascar quand il est fourni une instance incompatible, il retournera null, peut-être que vous passerez cela à une méthode qui la passera à une autre et ainsi de suite et finalement vous obtiendrez une NullReferenceException qui rendra votre débogage plus difficile.

N'en abusez pas. L'opérateur de coulée directe est meilleur dans 99% des cas.

La source
Translate

Pour développerCommentaire de Rytmis, vous ne pouvez pas utiliser leasmot-clé pour les structures (types de valeur), car ils n'ont pas de valeur nulle.

La source
Translate

Tout cela s'applique aux types référence, les types valeur ne peuvent pas utiliser leasmot-clé car ils ne peuvent pas être nuls.

//if I know that SomeObject is an instance of SomeClass
SomeClass sc = (SomeClass) someObject;


//if SomeObject *might* be SomeClass
SomeClass sc2 = someObject as SomeClass;

La syntaxe de cast est plus rapide, mais seulement lorsqu'elle réussit, l'échec est beaucoup plus lent.

La meilleure pratique consiste à utiliserasquand vous ne connaissez pas le type:

//we need to know what someObject is
SomeClass sc;
SomeOtherClass soc;

//use as to find the right type
if( ( sc = someObject as SomeClass ) != null ) 
{
    //do something with sc
}
else if ( ( soc = someObject as SomeOtherClass ) != null ) 
{
    //do something with soc
}

Cependant, si vous êtes absolument sûr quesomeObjectest une instance deSomeClasspuis utilisez cast.

Dans .Net 2 ou supérieur, les génériques signifient que vous avez très rarement besoin d'une instance non typée d'une classe de référence, donc cette dernière est moins souvent utilisée.

La source
Cecilia Lee
Translate

La conversion entre parenthèses lève une exception si la tentative de conversion échoue. Le cast "as" renvoie null si la tentative de conversion échoue.

La source
Translate

Ils jetteront différentes exceptions.
(): NullReferenceException
comme: InvalidCastException
Ce qui pourrait aider au débogage.

Le mot clé "as" tente de convertir l'objet et si la conversion échoue, null est renvoyé silencieusement. L'opérateur de conversion () lèvera une exception immédiatement si la conversion échoue.

"N'utilisez le mot clé C #" as "que lorsque vous vous attendez à ce que la conversion échoue dans un cas non exceptionnel. Si vous comptez sur une distribution réussie et que vous n'êtes pas prêt à recevoir un objet qui échouerait, vous devez utiliser le () opérateur cast afin qu'une exception appropriée et utile soit levée. "

Pour des exemples de code et une explication supplémentaire:http://blog.nerdbank.net/2008/06/when-not-to-use-c-keyword.html

La source
ICR
Translate

C'est comme la différence entre Parse et TryParse. Vous utilisez TryParse lorsque vous pensez qu'il peut échouer, mais lorsque vous avez la certitude qu'il n'échouera pas, vous utilisez Parse.

La source
Translate

Pour ceux d'entre vous qui ont une expérience VB.NET, (type) est identique à DirectCast et "as type" est identique à TryCast.

La source