C #: palabra clave 'is' y buscando Not

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 la instancia "NO"?

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

if(!(child is IContainer))

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

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 úsalo 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):

Como en realidad está emitiendo el valor después, podría usar asen 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...

Puedes hacerlo de esta manera:

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

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

¿Por qué no solo usar el otro?

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

¿Está bien, es familiar y simple?

La forma en que la 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 'NO'".

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
}

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

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

issintaxis:, expr is constant donde expr es la expresión para evaluar, y constante es el valor para probar.

¿Feo? Estoy en desacuerdo. La única otra forma (personalmente creo que esto es "más feo"):

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

El isoperador evalúa a 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?

El método de extensión IsNot<T>es una buena manera de extender la sintaxis. Tenga 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.

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.

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

C # 9 (que se publicará con .NET 5) incluirá los patrones lógicos and, ory not, lo que nos permite escribir esto más elegante:

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

Del mismo modo, este patrón se puede utilizar para verificar nulo:

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

Puede encontrar más detalles sobre el problema de Github que rastrea este cambio.

if (child is IContainer ? false : true)