C #: mot-clé 'is' et vérification de Not

C'est une question stupide, mais vous pouvez utiliser ce code pour vérifier si quelque chose est d'un type particulier ...

if (child is IContainer) { //....

Existe-t-il un moyen plus élégant de vérifier l'instance "NOT"?

if (!(child is IContainer)) { //A little ugly... silly, yes I know...

//these don't work :)
if (child !is IContainer) {
if (child isnt IContainer) { 
if (child aint IContainer) { 
if (child isnotafreaking IContainer) { 

Oui, oui ... question idiote ....

Parce qu'il y a une question sur l'apparence du code, c'est juste un simple retour au début d'une méthode.

public void Update(DocumentPart part) {
    part.Update();
    if (!(DocumentPart is IContainer)) { return; }
    foreach(DocumentPart child in ((IContainer)part).Children) {
       //...etc...

if(!(child is IContainer))

est le seul opérateur à aller (il n'y a pas d' IsNotopérateur).

Vous pouvez créer une méthode d'extension qui le fait:

public static bool IsA<T>(this object obj) {
    return obj is T;
}

puis l'utiliser pour:

if (!child.IsA<IContainer>())

Et vous pouvez suivre votre thème:

public static bool IsNotAFreaking<T>(this object obj) {
    return !(obj is T);
}

if (child.IsNotAFreaking<IContainer>()) { // ...

Mise à jour (compte tenu de l'extrait de code de l'OP):

Puisque vous effectuez en fait un cast après la valeur, vous pouvez simplement utiliser à la asplace:

public void Update(DocumentPart part) {
    part.Update();
    IContainer containerPart = part as IContainer;
    if(containerPart == null) return;
    foreach(DocumentPart child in containerPart.Children) { // omit the cast.
       //...etc...

Vous pouvez le faire de cette façon:

object a = new StreamWriter("c:\\temp\\test.txt");

if (a is TextReader == false)
{
   Console.WriteLine("failed");
}

Pourquoi ne pas simplement utiliser le reste?

if (child is IContainer)
{
  //
}
else
{
  // Do what you want here
}

Son propre familier et simple?

La façon dont vous l'avez est très bien, mais vous pouvez créer un ensemble de méthodes d'extension pour créer "un moyen plus élégant de vérifier l'instance" NOT "".

public static bool Is<T>(this object myObject)
{
    return (myObject is T);
}

public static bool IsNot<T>(this object myObject)
{
    return !(myObject is T);
}

Ensuite, vous pourriez écrire:

if (child.IsNot<IContainer>())
{
    // child is not an IContainer
}

Cela n'a pas encore été mentionné. Ça marche et je pense que ça a l'air mieux que d'utiliser!(child is IContainer)

if (part is IContainer is false)
{
    return;
}

issyntaxe expr is constant :, où expr est l'expression à évaluer et constante est la valeur à tester.

Laid? Je ne suis pas d'accord. La seule autre façon (je pense personnellement que c'est "plus laid"):

var obj = child as IContainer;
if(obj == null)
{
   //child "aint" IContainer
}

L' isopérateur évalue à un résultat booléen, vous pouvez donc faire tout ce que vous pourriez autrement faire sur un booléen. Pour le nier, utilisez l' !opérateur. Pourquoi voudriez-vous avoir un opérateur différent juste pour cela?

La méthode d'extension IsNot<T>est un bon moyen d'étendre la syntaxe. Gardez à l'esprit

var container = child as IContainer;
if(container != null)
{
  // do something w/ contianer
}

fonctionne mieux que de faire quelque chose comme

if(child is IContainer)
{
  var container = child as IContainer;
  // do something w/ container
}

Dans votre cas, peu importe que vous reveniez de la méthode. En d'autres termes, veillez à ne pas effectuer à la fois la vérification de type et la conversion de type immédiatement après.

Bien que cela n'évite pas le problème des parenthèses, pour le bien des gens qui arrivent ici via Google, il convient de mentionner qu'une syntaxe plus récente existe (à partir de C # 7) pour rendre le reste de votre code un peu plus propre:

if (!(DocumentPart is IContainer container)) { return; }
foreach(DocumentPart child in container.Children) {
    ...

Cela évite la double conversion, la vérification nulle et la disponibilité d'une variable dans les étendues où elle pourrait être nulle.

Bien que l'opérateur IS soit normalement le meilleur moyen, il existe une alternative que vous pouvez utiliser dans certaines circonstances. Vous pouvez utiliser l'opérateur as et tester null.

MyClass mc = foo as MyClass;
if ( mc == null ) { }
else {}

C # 9 (à paraître avec .NET 5) inclura les modèles logiques and, oret not, ce qui nous permet d'écrire ceci plus élégamment:

if (child is not IContainer) { ... }

De même, ce modèle peut être utilisé pour vérifier la valeur null:

if (child is not null) { ... }

Vous pouvez trouver plus de détails sur le problème de Github qui suit ce changement.

if (child is IContainer ? false : true)