Quand devez-vous utiliser comme mot-clé en C#

Utilisation as quand il est valide pour un objet de ne pas être du type que vous voulez, et vous voulez agir différemment si elle est. Par exemple, dans un pseudo-code:

foreach (Control control in foo)
{
    //Do something with every control...

    ContainerControl container = control as ContainerControl;
    if (container != null)
    {
        ApplyToChildren(container);
    }
}

Ou d'optimisation dans LINQ to Objects (beaucoup d'exemples de ce genre):

public static int Count<T>(this IEnumerable<T> source)
{
    IList list = source as IList;
    if (list != null)
    {
        return list.Count;
    }
    IList<T> genericList = source as IList<T>;
    if (genericList != null)
    {
        return genericList.Count;
    }

    //Okay, we'll do things the slow way...
    int result = 0;
    using (var iterator = source.GetEnumerator())
    {
        while (iterator.MoveNext())
        {
            result++;
        }
    }
    return result;
}

Donc à l'aide d' as est comme un is + un casting. C'est presque toujours utilisé avec une nullité vérifiez par la suite, selon les exemples ci-dessus.

OriginalL'auteur Jon Skeet

Est utilisé pour éviter la coulée double logique comme dans:

if (x is MyClass)
{
  MyClass y = (MyClass)x;
}

À l'aide de

MyClass y = x as MyClass;
if (y == null)
{
}

Pour info, IL a généré pour le cas n ° 1:

  //if (x is MyClass)
  IL_0008:  isinst     MyClass
  IL_000d:  ldnull
  IL_000e:  cgt.un
  IL_0010:  ldc.i4.0
  IL_0011:  ceq
  IL_0013:  stloc.2
  IL_0014:  ldloc.2
  IL_0015:  brtrue.s   IL_0020
  IL_0017:  nop
  //MyClass y = (MyClass)x;
  IL_0018:  ldloc.0
  IL_0019:  castclass  MyClass
  IL_001e:  stloc.1

et pour le cas n ° 2:

  //MyClass y = x as MyClass;
  IL_0008:  isinst     MyClass
  IL_000d:  stloc.1
  //if (y == null)
  IL_000e:  ldloc.1
  IL_000f:  ldnull
  IL_0010:  ceq
  IL_0012:  stloc.2
  IL_0013:  ldloc.2
  IL_0014:  brtrue.s   IL_0018

OriginalL'auteur vc 74

La mise en œuvre de l' .Count() dans l'Énumération qu'il utilise pour faire Count() pour la collecte plus rapide

La mise en œuvre est comme:

        ICollection<TSource> collection = source as ICollection<TSource>;
        if (collection != null)
        {
            return collection.Count;
        }
        ICollection collection2 = source as ICollection;
        if (collection2 != null)
        {
            return collection2.Count;
        }

Qui essaie de jeter la source, soit ICollection ou ICollection les deux ont une propriété Count.
Si cela échoue Count() parcourt l'ensemble de la source.
Donc, si vous avez un doute sur le type et le besoin de l'objet du type de la suite (comme dans l'exemple ci-dessus), vous devez utiliser as.

Si vous ne souhaitez tester si l'objet est d'un type donné d'utiliser is et si vous êtes sûr que l'objet est d'un type donné (ou dérive de/met en œuvre ce type), alors vous pouvez lancer

OriginalL'auteur Rune FS

Ici est un extrait de http://blog.nerdbank.net/2008/06/when-not-to-use-c-keyword.html

class SomeType {
    int someField;
    //The numeric suffixes on these methods are only added for reference later
    public override bool Equals1(object obj) {
        SomeType other = obj as SomeType;
        if (other == null) return false;
        return someField == other.SomeField;
    }
    public override bool Equals2(object obj) {
        if (obj == null) return false;
        //protect against an InvalidCastException
        if (!(obj is SomeType)) return false;
        SomeType other = (SomeType)obj;
        return someField == other.SomeField;
    }
}

La Equals1 méthode ci-dessus est plus efficace (et plus facile à lire) que Equals2, bien qu'ils obtiennent le même travail est fait. Alors que Equals1 compile à IL effectue la vérification du type et de la fonte exactement une fois, Equals2 compile de faire un type de comparaison d'abord pour le "est" de l'opérateur, et puis un type de comparaison et jetés ensemble en tant que partie de la () de l'opérateur. Donc, à l'aide de "que" dans ce cas est en fait plus efficace. Le fait qu'il est plus facile à lire est un bonus.

En conclusion, n'utilisez que le C# "comme" mot-clé, où vous vous attendez à de l'incantation à l'échec dans un non-cas exceptionnel. Si vous comptez sur un casting pour réussir et ne sont pas préparés à recevoir n'importe quel objet qui serait un échec, vous devez utiliser la (les) opérateur de cast, de sorte que des mesures appropriées et utiles exception est levée.

OriginalL'auteur Alex KeySmith