Avec: (NewType) par rapport à l'objet comme NewType

voix
79

Possible en double:
Coulée vs en utilisant le « comme » mot - clé dans le CLR

Ce qui est en fait la différence entre ces deux moulages?

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

Normalement, ils devraient tous deux être des conversions explicites au type spécifié?

Créé 05/08/2008 à 16:42
source utilisateur
Dans d'autres langues...                            


13 réponses

voix
82

L'ancien lèveront une exception si le type de source ne peut pas être jeté au type de cible. Ce dernier se traduira par sc2 étant une référence nulle, mais aucune exception.

[Modifier]

Ma réponse originale est certainement la différence la plus marquée, mais comme Eric Lippert souligne , ce n'est pas le seul. D' autres différences:

  • Vous ne pouvez pas utiliser l'opérateur « comme » jeter à un type qui n'accepte pas « nul » en tant que valeur
  • Vous ne pouvez pas utiliser « comme » pour convertir les choses, comme les numéros à une représentation différente (flotteur int, par exemple).

Et enfin, en utilisant « comme » par rapport à l'opérateur de distribution, vous aussi dire « Je ne suis pas sûr que cela réussira. »

Créé 05/08/2008 à 16:44
source utilisateur

voix
27

Notez également que vous ne pouvez utiliser le mot-clé comme avec un type de référence ou d'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.

Créé 05/08/2008 à 17:15
source utilisateur

voix
9

Transtypage en utilisant « comme » est bien sûr beaucoup plus rapide lorsque le sort échoue, car il évite les frais de lancer une exception.

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

La ligne de fond est la suivante:

  • Si vous attendez le casting pour réussir (à savoir un échec serait exceptionnel), utiliser un casting.

  • Si vous ne savez pas si elle réussira, utilisez le « comme » opérateur et tester le résultat NULL.

Créé 16/09/2008 à 20:21
source utilisateur

voix
5

Une différence entre les deux approches est que le premier ((SomeClass) obj) peut provoquer un convertisseur de type à appeler.

Créé 08/11/2008 à 00:46
source utilisateur

voix
4

Eh bien le « comme » opérateur « aide » vous enterrez votre problème moindre façon parce que quand il est prévu une instance incompatible elle renvoie null, peut - être vous passer que pour une méthode qui passera à une autre et ainsi de suite et enfin vous » ll obtenir un NullReferenceException qui rendra votre débogage plus difficile.

Ne pas abuser. L'opérateur coulé directe est mieux dans 99% des cas.

Créé 28/10/2010 à 10:21
source utilisateur

voix
4

Voici un bon moyen de se rappeler le processus que chacun d'entre eux suivent que j'utilise en essayant de décider ce qui est mieux pour ma situation.

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

et la prochaine 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 coulé à une exception est levée dans le deuxième cas, si la valeur ne peut pas être coulé, i a la valeur NULL.

Ainsi, dans le premier cas, un arrêt dur est fait si le casting échoue dans la deuxième coulée d'un arrêt progressif est fait et vous pouvez rencontrer un NullReferenceException plus tard.

Créé 05/08/2008 à 18:46
source utilisateur

voix
3

Pour développer le commentaire de Rytmis , vous ne pouvez pas utiliser le comme mot - clé pour struct (Types de valeur), car ils ont pas de valeur nulle.

Créé 07/09/2008 à 09:08
source utilisateur

voix
2

Tout cela vaut pour référence types, les types de valeurs ne peuvent pas utiliser le asmot - clé car ils ne peuvent pas être nulles.

//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 fonte est plus rapide, mais seulement en cas de succès, il est beaucoup plus lent à l'échec.

La meilleure pratique consiste à utiliser aslorsque 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
}

Toutefois , si vous êtes absolument sûr que someObjectest une instance d' SomeClassutiliser ensuite coulé.

Dans .Net 2 ou plus génériques signifie que vous avez besoin très rarement d'avoir une instance non typée d'une classe de référence, de sorte que celle-ci est moins souvent utilisé.

Créé 18/09/2008 à 12:10
source utilisateur

voix
1

Et pour être complet, Eric Lippert a un billet de blog sur la différence et quelques mises en garde.

Créé 09/10/2009 à 01:04
source utilisateur

voix
1

Pour ceux d'entre vous avec une expérience VB.NET, (type) est le même que DirectCast et « que le type » est le même que TryCast.

Créé 16/09/2008 à 22:55
source utilisateur

voix
1

Il est comme la différence entre Parse et TryParse. Vous utilisez TryParse quand vous attendez peut échouer, mais quand vous avez une assurance forte, il ne vous manquera pas d'utiliser Parse.

Créé 08/08/2008 à 13:00
source utilisateur

voix
1

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

Le mot-clé « comme » tente de lancer l'objet et si la distribution échoue, NULL est retourné en silence. Le () opérateur de cast lancera une exception immédiatement si la distribution échoue.

« Utilisez uniquement le C # « comme » mot-clé où vous attendez la distribution à l'échec dans un cas non exceptionnel. Si vous comptez sur un casting pour réussir et ne sont pas prêts à recevoir un objet qui ne parviendrait pas, vous devez utiliser le () jeter opérateur de sorte qu'une exception appropriée et utile est jeté « .

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

Créé 05/08/2008 à 16:49
source utilisateur

voix
1

Le casting lance une exception parenthétique si la tentative échoue coulé. Le « comme » cast renvoie null si la tentative échoue coulé.

Créé 05/08/2008 à 16:45
source utilisateur

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more