C #: 'is' palavra-chave e verificando Não

Esta é uma pergunta boba, mas você pode usar esse código para verificar se algo é de um tipo específico ...

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

Existe uma maneira mais elegante de verificar a instância "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) { 

Sim, sim ... pergunta boba ....

Como há alguma dúvida sobre a aparência do código, é apenas um retorno simples no início de um método.

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

if(!(child is IContainer))

é o único operador a ir (não há IsNot operador).

Você pode criar um método de extensão que faça isso:

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

e use-o para:

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

E você pode acompanhar o seu tema:

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

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

Atualização (considerando o snippet de código do OP):

Como você está realmente lançando o valor posteriormente, você pode usar 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...

Você pode fazer assim:

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

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

Por que não usar apenas o resto?

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

É puro familiar e simples?

O modo como você o faz é bom, mas você pode criar um conjunto de métodos de extensão para tornar "uma maneira mais elegante de verificar a instância '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);
}

Então você pode escrever:

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

Isso ainda não foi mencionado. Funciona e acho melhor do que usar!(child is IContainer)

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

issintaxe expr is constant :, em que expr é a expressão a ser avaliada e constante é o valor a ser testado.

Feio? Discordo. A única outra maneira (eu pessoalmente acho que isso é "mais feio"):

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

O isoperador avalia como resultado booleano, para que você possa fazer qualquer coisa que, de outra forma, seria capaz de fazer em um bool. Para negá-lo, use o !operador Por que você gostaria de ter um operador diferente apenas para isso?

O método de extensão IsNot<T>é uma ótima maneira de estender a sintaxe. Tenha em mente

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

executa melhor do que fazer algo como

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

No seu caso, não importa como você está retornando do método. Em outras palavras, tenha cuidado para não fazer a verificação do tipo e a conversão do tipo imediatamente após.

Embora isso não evite o problema de parênteses, para o bem das pessoas que chegam aqui pelo Google, deve-se mencionar que existe uma sintaxe mais nova (a partir do C # 7) para tornar o restante do seu código um pouco mais limpo:

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

Isso evita a conversão dupla, a verificação nula e a disponibilidade de uma variável nos escopos em que ela pode ser nula.

Enquanto o operador IS é normalmente o melhor caminho, há uma alternativa que você pode usar em algumas circunstâncias. Você pode usar o operador as e testar como nulo.

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

C # 9 (para ser lançado com .NET 5) incluirá os padrões lógicos and, ore not, o que nos permite escrever este mais elegante:

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

Da mesma forma, esse padrão pode ser usado para verificar se há nulo:

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

Você pode encontrar mais detalhes sobre o problema do Github que acompanha essa alteração.

if (child is IContainer ? false : true)