Casting vs à l'aide de l' " comme mot-clé dans la CLR

La réponse en dessous de la ligne a été écrit en 2008.

C# 7 a introduit la correspondance de modèle, qui a en grande partie remplacé le as opérateur, vous pouvez maintenant écrire:

if (randomObject is TargetType tt)
{
    //Use tt here
}

Noter que tt est toujours dans la portée, mais certainement pas attribué. (Il est certainement affectés au sein de l' if corps.) C'est un peu ennuyeux, dans certains cas, donc, si vous vous souciez vraiment de présentant le plus petit nombre de variables possibles dans chaque champ, vous pouvez toujours utiliser is suivie par un casting.

---

Je ne pense pas que les réponses jusqu'à présent (à l'époque, à partir de cette réponse!) ont vraiment expliqué où ça vaut le coup à l'aide de lequel.

• Ne pas faire ceci:

  //Bad code - checks type twice for no reason
  if (randomObject is TargetType)
  {
      TargetType foo = (TargetType) randomObject;
      //Do something with foo
  }

  Ce n'est pas seulement de vérifier deux fois, mais il est peut-être la vérification de choses différentes, si randomObject est un domaine plutôt qu'une variable locale. Il est possible que le "si" à passer, mais ensuite le casting à l'échec, si un autre thread modifie la valeur de randomObject entre les deux.

• Si randomObject vraiment devrait être une instance de TargetType, c'est à dire si elle ne l'est pas, cela signifie qu'il ya un bug, le casting, c'est la bonne solution. Qui lève une exception immédiatement, ce qui signifie que le travail est fait sous des hypothèses erronées, et à l'exception affiche correctement le type de bug.

  //This will throw an exception if randomObject is non-null and
  //refers to an object of an incompatible type. The cast is
  //the best code if that's the behaviour you want.
  TargetType convertedRandomObject = (TargetType) randomObject;

• Si randomObject pourrait être une instance de TargetType et TargetType est un type de référence, puis utiliser le code comme ceci:

  TargetType convertedRandomObject = randomObject as TargetType;
  if (convertedRandomObject != null)
  {
      //Do stuff with convertedRandomObject
  }

• Si randomObject pourrait être une instance de TargetType et TargetType est un type valeur, alors nous ne pouvons pas utiliser as avec TargetType lui-même, mais nous pouvons utiliser un type nullable:

  TargetType? convertedRandomObject = randomObject as TargetType?;
  if (convertedRandomObject != null)
  {
      //Do stuff with convertedRandomObject.Value
  }

  (Remarque: actuellement, c'est en fait plus lentement que est de + en fonte. Je pense que c'est plus élégant et cohérent, mais il nous continuons.)

• Si vous n'avez pas vraiment besoin de la valeur convertie, mais vous avez juste besoin de savoir si il est une instance de TargetType, puis le is opérateur est votre ami. Dans ce cas, il n'a pas d'importance si TargetType est un type de référence ou une valeur de type.

• Il peut y avoir d'autres cas impliquant des médicaments génériques où is est utile (parce que vous ne pouvez pas savoir si T est un type référence ou pas, de sorte que vous ne peut pas utiliser), mais ils sont relativement obscure.

• J'ai presque certainement utilisé is pour le type de la valeur de cas jusqu'à maintenant, n'ayant pas pensé à utiliser un type nullable et as ensemble 🙂

---

EDIT: Notez qu'aucune de ces pourparlers au sujet de la performance autre que la valeur de type de cas, où j'ai noté que unboxing à nullable type de valeur est en fait plus lente, mais constante.

Comme par naasking réponse, est-et de la fonte ou est-et-les aussi vite que comme-et-null-vérifier moderne, avec des équipes communes d'enquête, comme le montre le code ci-dessous:

using System;
using System.Diagnostics;
using System.Linq;
class Test
{
const int Size = 30000000;
static void Main()
{
object[] values = new object[Size];
for (int i = 0; i < Size - 2; i += 3)
{
values[i] = null;
values[i + 1] = "x";
values[i + 2] = new object();
}
FindLengthWithIsAndCast(values);
FindLengthWithIsAndAs(values);
FindLengthWithAsAndNullCheck(values);
}
static void FindLengthWithIsAndCast(object[] values)        
{
Stopwatch sw = Stopwatch.StartNew();
int len = 0;
foreach (object o in values)
{
if (o is string)
{
string a = (string) o;
len += a.Length;
}
}
sw.Stop();
Console.WriteLine("Is and Cast: {0} : {1}", len,
(long)sw.ElapsedMilliseconds);
}
static void FindLengthWithIsAndAs(object[] values)        
{
Stopwatch sw = Stopwatch.StartNew();
int len = 0;
foreach (object o in values)
{
if (o is string)
{
string a = o as string;
len += a.Length;
}
}
sw.Stop();
Console.WriteLine("Is and As: {0} : {1}", len,
(long)sw.ElapsedMilliseconds);
}
static void FindLengthWithAsAndNullCheck(object[] values)        
{
Stopwatch sw = Stopwatch.StartNew();
int len = 0;
foreach (object o in values)
{
string a = o as string;
if (a != null)
{
len += a.Length;
}
}
sw.Stop();
Console.WriteLine("As and null check: {0} : {1}", len,
(long)sw.ElapsedMilliseconds);
}
}

Sur mon ordinateur portable, ces toutes exécuter dans à propos de 60ms. Deux choses à noter:

• Il n'y a pas de différence significative entre eux. (En fait, il existe des situations dans lesquelles la plus-null-vérifier certainement est plus lent. Le code ci-dessus fait la vérification de type facile parce que c'est pour une classe scellée; si vous êtes de vérifier qu'une interface, la balance penche légèrement en faveur des plus-null-case.)
• Ils sont tous incroyablement rapide. Il suffit de ne être le goulot d'étranglement dans votre code, sauf si vous avez vraiment ne vont pas faire rien avec les valeurs par la suite.

Afin de ne pas laisser s'inquiéter de la performance. Nous allons vous soucier de l'exactitude et de la cohérence.

Que je maintiens, c'est-à-et-cast (ou est-et-as) sont à la fois dangereux lorsqu'ils traitent avec des variables, comme le type de la valeur qu'il désigne peut changer en raison d'un autre thread entre le test et la fonte. Qui serait assez rare de la situation - mais je préfère avoir une convention qui je peux utiliser de manière cohérente.

J'ai aussi maintenir que l'as-puis-null-vérifier donne une meilleure séparation des préoccupations. Nous avons une déclaration qui tente une conversion, puis une instruction qui utilise le résultat. L'est-et de la fonte ou est-et comme on l'effectue un test et puis une autre tentative pour convertir la valeur.

Pour le dire d'une autre façon, quelqu'un aurait-il jamais écrire:

int value;
if (int.TryParse(text, out value))
{
value = int.Parse(text);
//Use value
}

C'est en quelque sorte de ce qui est-et-cast est en train de faire - bien que, évidemment, dans un lieu beaucoup moins cher.

Voici une autre réponse, avec quelques IL de comparaison. Considérons la classe:

public class MyClass
{
public static void Main()
{
//Call the 2 methods
}
public void DirectCast(Object obj)
{
if ( obj is MyClass)
{ 
MyClass myclass = (MyClass) obj; 
Console.WriteLine(obj);
} 
} 
public void UsesAs(object obj) 
{ 
MyClass myclass = obj as MyClass; 
if (myclass != null) 
{ 
Console.WriteLine(obj);
} 
}
}

Maintenant, regardez le IL chaque méthode produit. Même si l'op codes ne signifient rien pour vous, vous pouvez voir une différence majeure: isinst est appelée, suivi par castclass dans le DirectCast méthode. Donc, de deux appels au lieu d'un gros.

.method public hidebysig instance void  DirectCast(object obj) cil managed
{
//Code size       22 (0x16)
.maxstack  8
IL_0000:  ldarg.1
IL_0001:  isinst     MyClass
IL_0006:  brfalse.s  IL_0015
IL_0008:  ldarg.1
IL_0009:  castclass  MyClass
IL_000e:  pop
IL_000f:  ldarg.1
IL_0010:  call       void [mscorlib]System.Console::WriteLine(object)
IL_0015:  ret
} //end of method MyClass::DirectCast
.method public hidebysig instance void  UsesAs(object obj) cil managed
{
//Code size       17 (0x11)
.maxstack  1
.locals init (class MyClass V_0)
IL_0000:  ldarg.1
IL_0001:  isinst     MyClass
IL_0006:  stloc.0
IL_0007:  ldloc.0
IL_0008:  brfalse.s  IL_0010
IL_000a:  ldarg.1
IL_000b:  call       void [mscorlib]System.Console::WriteLine(object)
IL_0010:  ret
} //end of method MyClass::UsesAs

La isinst mot-clé par rapport à la castclass

Ce blog a une bonne comparaison entre les deux façons de le faire. Son résumé est:

• Dans une comparaison directe, isinst est plus rapide que castclass (bien que légèrement)
• Pour effectuer des vérifications pour s'assurer que la conversion a été un succès, isinst était significativement plus rapide que castclass
• Une combinaison de isinst et castclass ne doit pas être utilisé comme cela a été beaucoup plus lent que le moyen le plus rapide "de sécurité", conversion (plus de 12% plus lent)

Personnellement, j'ai toujours l'utiliser Comme, parce que c'est facile à lire et est recommandé par le .NET de l'équipe de développement ou de Jeffrey Richter, de toute façon)

comme jamais déclenche une exception si elle ne peut pas effectuer la conversion de retour null à la place (comme fonctionne sur les types de référence uniquement). Donc, en utilisant comme est essentiellement équivalent à

_myCls2 = _myObj is MyClass ? (MyClass)_myObj : null;

C-style de moulages, d'autre part, de lancer une exception si aucune conversion n'est possible.

S'il vous plaît ignorer Jon Skeet conseils, re:éviter les tester et en fonte motif, c'est à dire.:

if (randomObject is TargetType)
{
TargetType foo = randomObject as TargetType;
//Do something with foo
}

À l'idée que cela coûte plus cher qu'un casting et une valeur null est un test MYTHE:

TargetType convertedRandomObject = randomObject as TargetType;
if (convertedRandomObject != null)
{
    //Do stuff with convertedRandomObject
}

C'est un micro-optimisation qui ne fonctionne pas. J'ai couru certains des tests réels, et de tester-et-cast est effectivement plus rapide que la distribution-et-null-comparaison, et c'est aussi plus sûr parce que vous n'avez pas la possibilité d'avoir une référence null dans le champ d'application à l'extérieur de la si faut le casting échouer.

Si vous voulez une bonne raison de tester-et-cast est plus rapide, ou au moins pas plus lent, il y a un simple et complexe à la raison.

Simple: même naïf compilateurs fusionner deux opérations similaires, comme test-et-cast, dans un seul test et de la direction générale. distribution-et-null-test peut forcer deux essais et une branche, un pour le type de test et de la conversion à null en cas d'échec, l'un pour les nuls vérifier lui-même. À tout le moins, ils seront à la fois de les optimiser en un seul test et de la branche, afin de tester et de fonte n'est ni lent ni rapide que cast-et-null-test.

Complexe: pourquoi tester et de fonte est plus rapide: cast-et-null-test introduit une autre variable à l'extérieur de la portée, le compilateur doit suivre pour liveness, et il peut ne pas être en mesure d'optimiser loin que variable selon la complexité de votre flux de contrôle est. À l'inverse, test-et-cast introduit une nouvelle variable que dans délimité dans le champ d'application de sorte que le compilateur sait que la variable est mort après que le champ d'application des sorties, et peut donc optimiser l'allocation des registres de mieux.

De sorte s'il vous plaît, s'il vous PLAÎT laissez ce "cast-et-null-est le meilleur test que test-et-cast" les conseils de MOURIR. S'il vous PLAÎT. test-et-cast est à la fois plus sûr et plus rapide.

Ce n'est pas une réponse à la question mais les commentaires à la question de l'exemple de code:

Habituellement, vous ne devriez pas avoir à jeter un Objet, par exemple, le IMyInterface MyClass. La grande chose au sujet des interfaces est que si vous prenez un objet en entrée qui implémente une interface, que vous n'avez pas de soins de quel type d'objet que vous obtenez.

Si vous lancez IMyInterface MyClass, que vous avez déjà supposer que vous obtenez un objet de type Maclasse et il ne fait aucun sens d'utiliser IMyInterface, parce que si vous nourrissez votre code avec d'autres classes qui implémentent IMyInterface, il serait briser votre code...

Maintenant, mon conseil: si vos interfaces sont bien conçus, vous pouvez éviter beaucoup de typecasting.

Ma réponse est seulement une question de vitesse dans les cas où nous n'avons pas vérifier le type et nous n'avons pas de vérifier les valeurs null après la coulée. J'ai ajouté deux autres tests de Jon Skeet code:

using System;
using System.Diagnostics;
class Test
{
const int Size = 30000000;
static void Main()
{
object[] values = new object[Size];
for (int i = 0; i < Size; i++)
{
values[i] = "x";
}
FindLengthWithIsAndCast(values);
FindLengthWithIsAndAs(values);
FindLengthWithAsAndNullCheck(values);
FindLengthWithCast(values);
FindLengthWithAs(values);
Console.ReadLine();
}
static void FindLengthWithIsAndCast(object[] values)
{
Stopwatch sw = Stopwatch.StartNew();
int len = 0;
foreach (object o in values)
{
if (o is string)
{
string a = (string)o;
len += a.Length;
}
}
sw.Stop();
Console.WriteLine("Is and Cast: {0} : {1}", len,
(long)sw.ElapsedMilliseconds);
}
static void FindLengthWithIsAndAs(object[] values)
{
Stopwatch sw = Stopwatch.StartNew();
int len = 0;
foreach (object o in values)
{
if (o is string)
{
string a = o as string;
len += a.Length;
}
}
sw.Stop();
Console.WriteLine("Is and As: {0} : {1}", len,
(long)sw.ElapsedMilliseconds);
}
static void FindLengthWithAsAndNullCheck(object[] values)
{
Stopwatch sw = Stopwatch.StartNew();
int len = 0;
foreach (object o in values)
{
string a = o as string;
if (a != null)
{
len += a.Length;
}
}
sw.Stop();
Console.WriteLine("As and null check: {0} : {1}", len,
(long)sw.ElapsedMilliseconds);
}
static void FindLengthWithCast(object[] values)
{
Stopwatch sw = Stopwatch.StartNew();
int len = 0;
foreach (object o in values)
{
string a = (string)o;
len += a.Length;
}
sw.Stop();
Console.WriteLine("Cast: {0} : {1}", len,
(long)sw.ElapsedMilliseconds);
}
static void FindLengthWithAs(object[] values)
{
Stopwatch sw = Stopwatch.StartNew();
int len = 0;
foreach (object o in values)
{
string a = o as string;
len += a.Length;
}
sw.Stop();
Console.WriteLine("As: {0} : {1}", len,
(long)sw.ElapsedMilliseconds);
}
}

Résultat:

Is and Cast: 30000000 : 88
Is and As: 30000000 : 93
As and null check: 30000000 : 56
Cast: 30000000 : 66
As: 30000000 : 46

Ne pas essayer de se concentrer sur la vitesse (comme je l'ai fait), parce que c'est très très rapide.

Si vous utilisez le Bureau Pia ciblage de l' .NET Framework 4.X, vous devez utiliser le comme de mots clés, sinon il ne sera pas compilé.

Microsoft.Office.Interop.Outlook.Application o = new Microsoft.Office.Interop.Outlook.Application();
Microsoft.Office.Interop.Outlook.MailItem m = o.CreateItem(Microsoft.Office.Interop.Outlook.OlItemType.olMailItem) as Microsoft.Office.Interop.Outlook.MailItem;

Casting est OK, alors que le ciblage .NET 2.0 si:

Microsoft.Office.Interop.Outlook.MailItem m = (Microsoft.Office.Interop.Outlook.MailItem)o.CreateItem(Microsoft.Office.Interop.Outlook.OlItemType.olMailItem);

Lors du ciblage .NET 4.X les erreurs sont:

erreur CS0656: Manquant compilateur nécessaire membre " de Microsoft.CSharp.RuntimeBinder.Classeur.Convertir'

erreur CS0656: Manquant compilateur nécessaire membre " de Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo.Créer des"

Ce que vous choisissez dépend fortement de ce qui est demandé.
Je préfère une conversion explicite

IMyInterface = (IMyInterface)someobj;

parce que si l'objet doit par de IMyInterface type et il n'est pas - il est certainement un problème.
Il est préférable d'obtenir d'erreur dès que possible, parce que l'erreur exacte sera fixée à la place de la fixation de ses effets secondaires.

Mais si vous traitez avec des méthodes qui accepte object en paramètre, alors vous devez vérifier son type exact avant d'exécuter tout code. Dans de tels cas as serait utile de sorte que vous pouvez éviter InvalidCastException.

Jetez un oeil à ces liens:

• http://gen5.info/q/2008/06/13/prefix-casting-versus-as-casting-in-c/
• http://www.codeproject.com/Articles/8052/Type-casting-impact-over-execution-performance-in

ils vous montrer quelques détails et de tests de performance.