C #: 'é' palavra-chave e verificação de Não

Question

Esta é uma pergunta boba, mas você pode usar este código para verificar se algo é um tipo particular ...

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

Existe uma maneira mais elegante para verificar se a instância do "NÃO"?

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

Porque há alguma questão sobre o que os olhares código como, é apenas um simples retorno 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...

Answer 1

if(!(child is IContainer))

é o único operador de ir (há nenhum operador IsNot).

Você pode construir um método de extensão que faz isso:

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

e, em seguida, usá-lo para:

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

E você pode seguir em seu tema:

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

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

---

Update (considerando trecho de código do OP):

Uma vez que você está realmente converter o valor mais tarde, você pode simplesmente usar as vez:

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

Você pode fazê-lo desta maneira:

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

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

Answer 3

Por que não usar a mais?

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

Seu puro-lo familiar e simples?

Answer 4

A maneira que você tem é bom, mas você poderia criar um conjunto de métodos de extensão para fazer "uma maneira mais elegante para verificar o 'não' exemplo".

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

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

Em seguida, você poderia escrever:

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

Answer 5

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

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

Answer 6

Os avalia operador is a um resultado boolean, assim você pode fazer o que de outra forma seria capaz de fazer em um bool. Para negar que usar o operador !. Por que você iria querer ter um operador diferente apenas para isso?

Answer 7

O método de extensão IsNot<T> é uma boa 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 a partir do método. Em outras palavras, ter o cuidado de não fazer as duas coisas a verificação de tipo e, em seguida, a conversão de tipo imediatamente depois.

Answer 8

Enquanto o operador IS é normalmente o melhor caminho, há uma alternativa que você pode usar em alguns cirumstances. Você pode usar o como operador e teste para nulo.

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

Answer 9

Enquanto isso não evitar o problema de parênteses, para o bem das pessoas recebendo aqui via Google, deve-se mencionar que existe mais nova sintaxe (a partir de C # 7) para fazer o resto do seu código um pouco mais limpo:

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

Isso evita o duplo-cast, o nulo-check, e ter um disponíveis variável em âmbitos onde poderia ser nulo.

Answer 10

Este ainda não foi mencionado. Ele funciona e eu acho que parece melhor do que usar !(child is IContainer)

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

Answer 11

if (child is IContainer ? false : true)