C＃：'is'关键字并检查Not-C#:'is'keywordandcheckingforNot

if(!(child is IContainer))

is the only operator to go (there's no IsNot operator).

是唯一的运营商(没有IsNot运营商)。

You can build an extension method that does it:

您可以构建一个执行它的扩展方法:

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

and then use it to:

然后用它来:

if (!child.IsA())

And you could follow on your theme:

你可以跟随你的主题:

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

if (child.IsNotAFreaking()) { // ...

Update (considering the OP's code snippet):

Since you're actually casting the value afterward, you could just use as instead:

由于您之后实际上正在构建值,因此您可以使用as:

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

You can do it this way:

你可以这样做:

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

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

Why not just use the else ?

为什么不使用其他?

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

Its neat it familiar and simple ?

它整洁而熟悉又简单?

The way you have it is fine but you could create a set of extension methods to make "a more elegant way to check for the 'NOT' instance."

你拥有它的方式很好,但你可以创建一组扩展方法,使“更优雅的方式来检查'NOT'实例。”

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

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

Then you could write:

然后你可以写:

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

Ugly? I disagree. The only other way (I personally think this is "uglier"):

丑陋?我不同意。唯一的另一种方式(我个人认为这是“丑陋的”):

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

The is operator evaluates to a boolean result, so you can do anything you would otherwise be able to do on a bool. To negate it use the ! operator. Why would you want to have a different operator just for this?

is运算符求值为布尔结果,因此您可以执行任何您在bool上可以执行的操作。否定它使用!运营商。你为什么要为此拥有一个不同的运算符?

While the IS operator is normally the best way, there is an alternative that you can use in some cirumstances. You can use the as operator and test for null.

虽然IS运营商通常是最好的方式,但有一种替代方案可以在某些情况下使用。您可以使用as运算符并测试null。

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

The extension method IsNot is a nice way to extend the syntax. Keep in mind

扩展方法IsNot 是一种扩展语法的好方法。记住

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

performs better than doing something like

比做某事更好

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

In your case, it doesn't matter as you are returning from the method. In other words, be careful to not do both the check for type and then the type conversion immediately after.

在您的情况下,从方法返回时无关紧要。换句话说,请注意不要同时检查类型,然后立即进行类型转换。

While this doesn't avoid the problem of parentheses, for the sake of people getting here via Google, it should be mentioned that newer syntax exists (as of C# 7) to make the rest of your code a little cleaner:

虽然这不能避免括号问题,但是为了让人们通过谷歌来到这里,应该提到的是存在更新的语法(从C#7开始),以使代码的其余部分更清晰:

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

This avoids the double-cast, the null-check, and having a variable available in scopes where it could be null.

这避免了双重转换,空检查,并且在范围中可以使用变量,它可以为null。

if (child is IContainer ? false : true)