Notez également que vous ne pouvez utiliser le mot-clé as qu'avec un type de 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.

Voici un bon moyen de se souvenir du processus que chacun d'eux suit et que j'utilise pour essayer de décider ce qui convient le mieux à 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 convertie, une exception est levée dans le second cas, si la valeur ne peut pas être convertie, i est défini sur null.

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

C'est comme la différence entre Parse et TryParse. Vous utilisez TryParse lorsque vous vous attendez à ce qu'il échoue, mais lorsque vous avez la certitude qu'il n'échouera pas, vous utilisez Parse.

Tout cela s'applique aux types de référence, les types de valeur ne peuvent pas utiliser le mot-clé as 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 en cas de succès, il est beaucoup plus lent d'échouer.

La meilleure pratique consiste à utiliser as lorsque 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 que someObject est une instance de SomeClass, utilisez cast.

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