C #: palabra clave 'is' y buscando Not

Question

Esta es una pregunta tonta, pero puede usar este código para verificar si algo es un tipo particular ...

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

¿Hay alguna forma más elegante de verificar si " NOT " instancia?

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í ... pregunta tonta ...

Debido a que hay alguna pregunta sobre cómo se ve el código, es solo un simple retorno al comienzo de un 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))

es el único operador que va (no hay IsNot operador).

Puede crear un método de extensión que lo haga:

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

y luego úselo para:

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

Y puedes seguir tu tema:

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

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

---

Actualización (considerando el fragmento de código del OP):

Dado que en realidad está emitiendo el valor después, podría usar as en su lugar:

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

Puedes hacerlo de esta manera:

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

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

Answer 3

¿Por qué no usar el else?

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

¿Está bien, es familiar y simple?

Answer 4

La forma en que lo tiene está bien, pero podría crear un conjunto de métodos de extensión para hacer " una forma más elegante de verificar la instancia '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);
}

Entonces podrías escribir:

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

Answer 5

¿Feo? Estoy en desacuerdo. La única otra forma (personalmente creo que esto es & Quot; uglier & Quot;):

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

Answer 6

El operador is se evalúa como un resultado booleano, por lo que puede hacer cualquier cosa que de otro modo podría hacer en un bool. Para negarlo, use el operador !. ¿Por qué querrías tener un operador diferente solo para esto?

Answer 7

El método de extensión IsNot<T> es una buena manera de extender la sintaxis. Ten en cuenta

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

funciona mejor que hacer algo como

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

En su caso, no importa ya que regresa del método. En otras palabras, tenga cuidado de no hacer tanto la verificación de tipo como la conversión de tipo inmediatamente después.

Answer 8

Si bien el operador IS normalmente es la mejor manera, existe una alternativa que puede usar en algunas circunstancias. Puede usar el operador as y probar nulo.

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

Answer 9

Si bien esto no evita el problema de los paréntesis, por el bien de las personas que llegan aquí a través de Google, debe mencionarse que existe una sintaxis más nueva (a partir de C # 7) para que el resto de su código sea un poco más limpio:

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

Esto evita la doble conversión, la verificación nula y tener una variable disponible en ámbitos donde podría ser nula.

Answer 10

Esto aún no se ha mencionado. Funciona y creo que se ve mejor que usar !(child is IContainer)

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

Answer 11

if (child is IContainer ? false : true)