GetType () pode mentir?

Com base na seguinte pergunta feita há poucos dias no SO: GetType () e polimorfismo e lendo a resposta de Eric Lippert , comecei a pensar se fazer GetType()não ser virtual realmente garante que um objeto não possa mentir sobre ele Type.

Especificamente, a resposta de Eric afirma o seguinte:

Os designers do framework não irão adicionar um recurso incrivelmente perigoso, como permitir que um objeto minta sobre seu tipo apenas para torná-lo consistente com três outros métodos do mesmo tipo.

Agora a pergunta é: Eu posso fazer um objeto que faz mentira sobre seu tipo, sem que seja imediatamente óbvio? Posso estar profundamente errado aqui e adoraria um esclarecimento se for esse o caso, mas considere o seguinte código:

public interface IFoo
{
    Type GetType();
}

E as seguintes duas implementações da referida interface:

public class BadFoo : IFoo
{
    Type IFoo.GetType()
    {
        return typeof(int);
    }
}

public class NiceFoo : IFoo
{
}

Então, se você executar o seguinte programa simples:

static void Main(string[] args)
{
    IFoo badFoo = new BadFoo();
    IFoo niceFoo = new NiceFoo();
    Console.WriteLine("BadFoo says he's a '{0}'", badFoo.GetType().ToString());
    Console.WriteLine("NiceFoo says he's a '{0}'", niceFoo.GetType().ToString());
    Console.ReadLine();
}

Com certeza badFooproduz um erro Type.

Agora, eu não sei se isso tem alguma implicação séria com base na descrição de Eric desse comportamento como um " recurso incrivelmente perigoso ", mas esse padrão poderia representar uma ameaça confiável?

Boa pergunta! A meu ver, você só poderia realmente enganar um colega desenvolvedor se GetType fosse virtual no objeto, o que não é.

O que você fez é semelhante a sombreado GetType, assim:

public class BadFoo
{
    public new Type GetType()
    {
        return typeof(int);
    }
}

com esta classe (e usando o código de amostra do MSDN para o método GetType () ) você realmente poderia ter:

int n1 = 12;
BadFoo foo = new BadFoo();

Console.WriteLine("n1 and n2 are the same type: {0}",
                  Object.ReferenceEquals(n1.GetType(), foo.GetType())); 
// output: 
// n1 and n2 are the same type: True

então, caramba, você mentiu com sucesso, certo? Bem, sim e não ... Considere que usar isso como um exploit significaria usar sua instância BadFoo como um argumento para um método em algum lugar, que espera provavelmente um objectou um tipo de base comum para uma hierarquia de objetos. Algo assim:

public void CheckIfInt(object ob)
{
    if(ob.GetType() == typeof(int))
    {
        Console.WriteLine("got an int! Initiate destruction of Universe!");
    }
    else
    {
        Console.WriteLine("not an int");
    }
}

mas CheckIfInt(foo)imprime "não é um int".

Então, basicamente (de volta ao seu exemplo), você só poderia realmente explorar seu "tipo mentiroso" com código que alguém escreveu em sua IFoointerface, o que é muito explícito sobre o fato de ter um GetType()método "personalizado" .

Apenas se GetType () fosse virtual no objeto, você seria capaz de criar um tipo "mentiroso" que poderia ser usado com métodos como o CheckIfIntacima para criar confusão em bibliotecas escritas por outra pessoa.

Existem duas maneiras de ter certeza sobre o tipo:

1. Use typeofno tipo que não pode ser sobrecarregado

   IFoo badFoo = new BadFoo();
   IFoo niceFoo = new NiceFoo();
   
   Console.WriteLine("BadFoo says he's a '{0}'", badFoo.GetType().ToString());
   Console.WriteLine("NiceFoo says he's a '{0}'", niceFoo.GetType().ToString());
   
   Console.WriteLine("BadFoo really is a '{0}'", typeof(BadFoo));
   Console.WriteLine("NiceFoo really is a '{0}'", typeof(NiceFoo));
   Console.ReadLine();
   

2. Lance a instância para um objecte chame o GetType()Método

   IFoo badFoo = new BadFoo();
   IFoo niceFoo = new NiceFoo();
   
   Console.WriteLine("BadFoo says he's a '{0}'", badFoo.GetType().ToString());
   Console.WriteLine("NiceFoo says he's a '{0}'", niceFoo.GetType().ToString());
   
   Console.WriteLine("BadFoo really is a '{0}'", ((object)badFoo).GetType());
   Console.WriteLine("NiceFoo really is a '{0}'", ((object)niceFoo).GetType());
   Console.ReadLine();
   

Não, você não pode fazer GetType mentir. Você está apenas introduzindo um novo método. Apenas o código que conhece esse método o chamará.

Você não pode, por exemplo, fazer com que o código de terceiros ou de estrutura chame seu novo método GetType em vez do real, uma vez que esse código não sabe que seu método existe e, portanto, nunca o chamará.

No entanto, você pode confundir seus próprios desenvolvedores com tal declaração. Qualquer código que seja compilado com sua declaração e que use parâmetros ou variáveis ​​digitadas como IFoo ou qualquer tipo derivado disso, de fato, usará seu novo método. Mas, uma vez que isso afeta apenas o seu próprio código, não impõe realmente uma "ameaça".

Se você deseja fornecer uma descrição de tipo personalizado para uma classe, isso deve ser feito usando um Descritor de Tipo Personalizado , talvez anotando sua classe com um TypeDescriptionProviderAttribute . Isso pode ser útil em algumas situações.

Bem, na verdade não é já um tipo que pode estar em GetType: qualquer tipo anulável.

Este código :

int? x = 0; int y = 0;
Console.WriteLine(x.GetType() == y.GetType());

saídas True.

Na verdade, não int?é quem está mentindo, apenas o elenco implícito se objecttransforma int?em um boxe int. Mas, no entanto, você não pode dizer int?a partir de intcom GetType().

Eu não acho que vá, já que todo código de biblioteca que chama GetType irá declarar a variável como 'Objeto' ou como um tipo genérico 'T'

O seguinte código:

    public static void Main(string[] args)
    {
        IFoo badFoo = new BadFoo();
        IFoo niceFoo = new NiceFoo();
        PrintObjectType("BadFoo", badFoo);
        PrintObjectType("NiceFoo", niceFoo);
        PrintGenericType("BadFoo", badFoo);
        PrintGenericType("NiceFoo", niceFoo);
    }

    public static void PrintObjectType(string actualName, object instance)
    {
        Console.WriteLine("Object {0} says he's a '{1}'", actualName, instance.GetType());
    }

    public static void PrintGenericType<T>(string actualName, T instance)
    {
        Console.WriteLine("Generic Type {0} says he's a '{1}'", actualName, instance.GetType());
    }

estampas:

O objeto BadFoo diz que ele é um 'TypeConcept.BadFoo'

O objeto NiceFoo diz que é um 'TypeConcept.NiceFoo'

O tipo genérico BadFoo diz que ele é um 'TypeConcept.BadFoo'

O tipo genérico NiceFoo diz que ele é um 'TypeConcept.NiceFoo'

A única vez que este tipo de código resultará em cenários ruins é em seu próprio código, onde você declara o tipo de parâmetro como IFoo

    public static void Main(string[] args)
    {
        IFoo badFoo = new BadFoo();
        IFoo niceFoo = new NiceFoo();
        PrintIFoo("BadFoo", badFoo);
        PrintIFoo("NiceFoo", niceFoo);
    }

    public static void PrintIFoo(string actualName, IFoo instance)
    {
        Console.WriteLine("IFoo {0} says he's a '{1}'", actualName, instance.GetType());
    }

IFoo BadFoo diz que ele é um 'System.Int32'

IFoo NiceFoo diz que é um 'TypeConcept.NiceFoo'

O pior que pode acontecer, tanto quanto posso dizer, é enganar programadores inocentes que usam a classe envenenada, por exemplo:

Type type = myInstance.GetType();
string fullName = type.FullName;
string output;
if (fullName.Contains(".Web"))
{
    output = "this is webby";
}
else if (fullName.Contains(".Customer"))
{
    output = "this is customer related class";
}
else
{
    output = "unknown class";
}

Se myInstancefor uma instância de uma classe como a que você descreve na pergunta, ela será tratada apenas como tipo desconhecido.

Portanto, minha resposta é não, não consigo ver nenhuma ameaça real aqui.

Você tem algumas opções se quiser jogar pelo seguro contra esse tipo de hack:

Lançar para o objeto primeiro

Você pode chamar o GetType()método original primeiro convertendo a instância para um object:

 Console.WriteLine("BadFoo says he's a '{0}'", ((object)badFoo).GetType());

resulta em:

BadFoo says he's a 'ConsoleApplication.BadFoo'

Usar método de modelo

Usar este método de modelo também fornecerá o tipo real:

static Type GetType<T>(T obj)
{
    return obj.GetType();
}

GetType(badFoo);

Existe uma diferença entre object.GetTypee IFoo.GetType. GetTypeé chamado em tempo de compilação em objetos desconhecidos e não em interfaces. No seu exemplo, com saída badFoo.GetTypeé esperado bahaviour, porque você sobrecarrega o método. A única coisa é que outros programadores podem se confundir com esse comportamento.

Mas se você usá- typeof()lo, o tipo será o mesmo e você não poderá sobrescrever typeof().

Além disso, o programador pode ver em tempo de compilação, qual método GetTypeele invoca.

Então, para sua pergunta: este padrão não pode representar uma ameaça confiável, mas também não é o melhor estilo de codificação.