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

Question

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 la quot &; NOT " esempio?

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

Poiché esiste una 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...

Answer 1

if(!(child is IContainer))

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

Puoi 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 as invece:

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

Answer 2

Puoi farlo in questo modo:

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

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

Answer 3

Perché non usare semplicemente l'altro?

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

È pulito, familiare e semplice?

Answer 4

Il modo in cui lo hai va bene ma potresti creare una serie di metodi di estensione per rendere " un modo più elegante per verificare l'istanza '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);
}

Quindi potresti scrivere:

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

Answer 5

Ugly? Non sono d'accordo. L'unico altro modo (penso personalmente che sia & Quot; uglier & Quot;):

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

Answer 6

L'operatore is 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?

Answer 7

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
}

funziona meglio che fare qualcosa del genere

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, fai attenzione a non eseguire sia il controllo del tipo che la conversione del tipo immediatamente dopo.

Answer 8

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

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

Answer 9

Anche se questo non evita il problema delle parentesi, per il bene delle persone che arrivano qui tramite Google, va detto 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.

Answer 10

Questo non è stato ancora menzionato. Funziona e penso che abbia un aspetto migliore rispetto all'utilizzo di !(child is IContainer)

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

Answer 11

if (child is IContainer ? false : true)