Início / coding / Perguntas / 79311780
Accepted
acmoune
Asked: 2024-12-27 20:13:59 +0800 CST

Como verificar qual classe derivada está em uso?

  • 772

Digamos que eu tenha esta superclasse:

public class SuperClass { }

E essas subclasses:

public class SubClass1 : SuperClass { }
public class SubClass2 : SuperClass { }

Temos este código de cliente:

public void DoStuff(SuperClass arg)
{
    if (arg is instance of SubClass1, but not an instance of SubClass2) // How to check this ?
    {
        var data = (SubClass1) arg;
        // Do stuff
    } 
}

Como verificar se argé um SubClass1único ou um SubClass2único?

c#

5 respostas

  1. Best Answer

    Uma classe não pode ser SubClass1e SubClass2ao mesmo tempo. Irmãos em uma hierarquia de classes não são compatíveis com atribuições. Portanto, você precisa apenas de uma verificação:

    if (arg is SubClass1 data)
{
    // Do stuff with data which is typed as SubClass1 
}

    Note que estou usando correspondência de padrões aqui. O tipo do objeto é testado e, se corresponder, então é atribuído à variável data. Isso declara automaticamente datacomo SubClass1.

    Você também pode usar correspondência de padrões em uma instrução switch:

    switch (arg)
{
    SubClass1 sub1:
        DoStuff1(sub1);
        break;
    SubClass2 sub2:
        DoStuff2(sub2);
        break;
}

    Se você precisar retornar um valor, uma expressão switch é ainda mais fácil.

    string s = arg switch { SubClass1 => "Sub1", SubClass2 => "Sub2", _ "another one" };

    Tais usos de ifou switchsão frequentemente uma indicação de que uma abordagem mais orientada a objetos pode resolver melhor o problema. Como exemplo, vamos considerar minha instrução switch acima. Em vez de ligar o (sub-)tipo para decidir se DoStuff1ou DoStuff2deve ser executado, poderíamos declarar um método abstrato ou virtual DoStuffna classe base. As subclasses podem então substituir esse método e implementar suas coisas específicas de tipo. Então, podemos simplesmente chamar arg.DoStuff();.

    public abstract class SuperClass
{
    public abstract void DoStuff();
}

public class SubClass1 : SuperClass
{
    public override void DoStuff()
    {
        Console.WriteLine("Hello from SubClass1");
    }
}

public class SubClass2 : SuperClass
{
    public override void DoStuff()
    {
        Console.WriteLine("Hello from SubClass2");
    }
}

    Então

    public void DoStuffExample(SuperClass arg)
{
    arg.DoStuff(); // Will print a message according to the runtime type of arg.
}

    Dada a hierarquia de herança BaseClass--> SubClass--> SubSubClass, se obj is SubClass, então objpode ser a SubClassou a SubSubClass. Mas note que temos um relacionamento pai-filho aqui.

    Mas isso é aceitável na maioria dos casos, já que SubSubClassa atribuição é compatível com SubClasse pode fazer tudo o que sua classe pai pode fazer. Em POO você não deve se preocupar com o tipo real de um objeto. Exemplo: TextBox, Labele ComboBoxtodos derivam (direta ou indiretamente) de Control. Se você tem um Control c = Controls[0];, você pode escrever com segurança c.BackColor = Color.Yellow;.

    • 8

  2. Você pode usar a correspondência de padrões para fazer a verificação e a atribuição de uma só vez:

    if (arg is SubClass1 data)
{
    // Do stuffs, data has already been assigned
}

    Não há necessidade de fazer uma verificação separada SubClass2devido à maneira como as classes foram definidas.

    Se você quiser uma verificação separada para " NÃO é uma subclasse de nenhum tipo", você pode fazer uma comparação usando GetType(), como segue:

    if (arg.GetType() == typeof(SuperClass))
{
    Console.WriteLine("It is a SuperClass (and not a derived type)");
}
else if (arg is SubClass1 data)
{
    Console.WriteLine("It is a SubClass1");
}
else if (arg is SubClass2 data2)
{
    Console.WriteLine("It is a SubClass2");
}
else
{
    Console.WriteLine("Subclass type not supported");
}
    • 1

  3. Para a ÚNICA parte da sua pergunta, você precisaria fazer:

    arg.GetType()==typeof(SubClass1)

    • 1

  4. Experimente isto

    public void DoStuff(SuperClass arg)
{
    if (arg is SubClass1 && arg.GetType() == typeof(SubClass1))
    {
        var data = (SubClass1)arg;
        // Do stuff
    }
    else
    {
       // Do other stuff
    }
}
    • 0

  5. Embora a questão já tenha sido respondida (por correspondência de padrões ou outras opções), uma abordagem diferente poderia gerar resultados muito melhores (e sustentáveis):

    Se sua SuperClasse declara um método abstrato

    public class SuperClass {
    public abstract DoStuffMethod();
}

    Então sua SubClass1 e SubClass2 podem fazer coisas diferentes

    public class SubClass1
    public override DoStuffMethod() {
        //do subclass1 things here
    }
}

public class SubClass2
    public override DoStuffMethod() {
        //do subclass2 things here
    }
}

    isso fará com que as subclasses se preocupem com o que elas precisam fazer, em vez de uma classe completamente diferente ter sua lógica.

    seu código de cliente também pareceria muito mais simples

    public void DoStuff(SuperClass arg)
{
    arg.DoStuffMethod();
}
    • 0

relate perguntas