C #: 'è' parola chiave e verifica la presenza di Not

Questa è una domanda stupida, ma puoi usare questo codice per verificare se qualcosa è un tipo particolare ...

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

Esiste un modo più elegante per verificare l'istanza "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) { 

Sì, sì ... domanda stupida ....

Perché c'è qualche domanda su come appare il codice, è solo un semplice ritorno all'inizio di un metodo.

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

if(!(child is IContainer))

è l'unico operatore ad andare (non c'è nessun IsNotoperatore).

È possibile creare un metodo di estensione che lo faccia:

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

e poi usalo per:

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

E potresti seguire il tuo tema:

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

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

Aggiornamento (considerando lo snippet di codice del PO):

Dal momento che stai effettivamente lanciando il valore in seguito, puoi semplicemente usare asinvece:

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...

Puoi farlo in questo modo:

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

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

Perché non usare semplicemente l'altro?

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

È pulito, familiare e semplice?

Il modo in cui lo avete va bene, ma si potrebbe creare una serie di metodi di estensione per fare "un modo più elegante per verificare la 'NON E' istanza."

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

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

Quindi potresti scrivere:

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

Questo non è stato ancora menzionato. Funziona e penso che appaia meglio dell'uso!(child is IContainer)

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

issintassi expr is constant :, dove expr è l'espressione da valutare e costante è il valore da verificare.

Brutta? Non sono d'accordo. L'unico altro modo (penso personalmente che sia "più brutto"):

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

L' isoperatore valuta un risultato booleano, quindi puoi fare tutto ciò che altrimenti potresti fare su un booleano. Per negarlo usa l' !operatore. Perché vorresti avere un operatore diverso solo per questo?

Il metodo di estensione IsNot<T>è un buon modo per estendere la sintassi. Tieni a mente

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

si comporta meglio di fare qualcosa di simile

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

Nel tuo caso, non importa come stai tornando dal metodo. In altre parole, fare attenzione a non eseguire sia la verifica del tipo che la conversione del tipo immediatamente dopo.

Sebbene ciò non eviti il ​​problema delle parentesi, per il bene delle persone che arrivano qui tramite Google, va menzionato che esiste una sintassi più recente (a partire da C # 7) per rendere il resto del codice un po 'più pulito:

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

Ciò evita il doppio cast, il controllo null e la disponibilità di una variabile in ambiti in cui potrebbe essere null.

Mentre l'operatore IS è normalmente il modo migliore, esiste un'alternativa che è possibile utilizzare in alcune circostanze. È possibile utilizzare l'operatore as e testare null.

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

C # 9 (per essere rilasciato con .NET 5) includerà i modelli logici and, ore not, che ci permette di scrivere questo più elegante:

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

Allo stesso modo, questo modello può essere utilizzato per verificare la presenza di null:

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

Puoi trovare maggiori dettagli sul problema di Github che tiene traccia di questa modifica.

if (child is IContainer ? false : true)