tag - C#: 'é' palavra-chave e verificar se não




title tag e title heading (8)

A maneira como você o tem é boa, 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ê poderia escrever:

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

Esta é uma pergunta boba, mas você pode usar este código para verificar se algo é 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 ....

Porque há alguma pergunta sobre o que o código parece, é 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...

Embora isso não evite o problema de parênteses, para o bem das pessoas que chegam até aqui via Google, deve-se mencionar que existe uma nova sintaxe (a partir do C # 7) para tornar 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 lançamento duplo, a verificação nula e a disponibilidade de uma variável nos escopos, onde ela pode ser nula.


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

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

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

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

O operador is avaliado por um resultado booleano, portanto você pode fazer qualquer coisa que, de outra forma, seria capaz de fazer em um booleano. Para negar, use o ! operador. Por que você quer ter um operador diferente apenas para isso?


Por que não apenas usar o outro?

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

É puro, familiar e simples?


if (child is IContainer ? false : true)

if(!(child is IContainer))

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

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 depois usá-lo para:

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

E você pode seguir seu tema:

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

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

Atualizar (considerando o snippet de código do OP):

Já que você está realmente lançando o valor depois, você pode usar apenas 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...






keyword