C #: „is” słowo kluczowe i sprawdzanie, czy nie

To głupie pytanie, ale możesz użyć tego kodu, aby sprawdzić, czy coś jest określonego typu ...

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

Czy istnieje bardziej elegancki sposób sprawdzenia wystąpienia „NIE”?

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) { 

Tak, tak ... głupie pytanie ...

Ponieważ jest pewne pytanie , jak wygląda kod, jest to zwykły powrót na początku metody.

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

if(!(child is IContainer))

jest jedynym operatorem, który może przejść (nie ma IsNotoperatora).

Możesz zbudować metodę rozszerzenia, która to robi:

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

a następnie użyj go do:

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

I możesz śledzić swój temat:

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

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

Aktualizacja (z uwzględnieniem fragmentu kodu PO):

Ponieważ faktycznie rzutujesz wartość później, możesz po prostu użyć aszamiast tego:

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

Możesz to zrobić w ten sposób:

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

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

Dlaczego nie skorzystać z innego?

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

Czy to dobrze znane i proste?

Sposób, w jaki masz to jest w porządku, ale mógłby stworzyć zestaw metod rozszerzających, aby „bardziej elegancki sposób, aby sprawdzić, czy«nie», np.”

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

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

Następnie możesz napisać:

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

Nie zostało to jeszcze wspomniane. Działa i myślę, że wygląda lepiej niż używanie!(child is IContainer)

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

isskładnia expr is constant :, gdzie wyrażenie jest wyrażeniem do oceny, a stała jest wartością do sprawdzenia.

Brzydki? Nie zgadzam się. Jedyny inny sposób (osobiście uważam, że jest to „brzydsze”):

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

Do isocenia operatorowi logiczną wyniku, więc można zrobić coś byś inaczej być w stanie zrobić na bool. Aby to zanegować, użyj !operatora. Dlaczego miałbyś chcieć mieć do tego innego operatora?

Metoda rozszerzenia IsNot<T>jest dobrym sposobem na rozszerzenie składni. Pamiętać

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

działa lepiej niż coś takiego

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

W twoim przypadku nie ma to znaczenia, gdy wracasz z metody. Innymi słowy, należy uważać, aby nie sprawdzić zarówno typu, jak i konwersji bezpośrednio po nim.

Chociaż nie pozwala to uniknąć problemu w nawiasach, dla dobra ludzi przybywających tutaj przez Google, należy wspomnieć, że istnieje nowsza składnia (od C # 7), aby resztę kodu uczynić nieco czystszą:

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

Dzięki temu unika się podwójnego rzutowania, sprawdzania wartości zerowej i posiadania zmiennej dostępnej w zakresach, w których może ona być zerowa.

Chociaż operator IS jest zwykle najlepszym sposobem, istnieje alternatywa, z której można skorzystać w niektórych okolicznościach. Możesz użyć operatora as i przetestować na wartość NULL.

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

C # 9 (aby zostać zwolnione z .NET 5) obejmie logiczne wzory and, ori not, co pozwala nam napisać to bardziej elegancko:

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

Podobnie, tego wzoru można użyć do sprawdzenia wartości null:

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

Możesz znaleźć więcej szczegółów na temat problemu Github śledzącego tę zmianę.

if (child is IContainer ? false : true)