GetType () puede mentir?

Basado en la siguiente pregunta hecha hace unos días en SO: GetType () y polimorfismo y leyendo la respuesta de Eric Lippert , comencé a pensar si hacer GetType()no ser virtual realmente garantizaba que un objeto no pudiera mentir sobre su Type.

Específicamente, la respuesta de Eric dice lo siguiente:

Los diseñadores de frameworks no van a agregar una característica increíblemente peligrosa como permitir que un objeto mienta sobre su tipo simplemente para que sea consistente con otros tres métodos del mismo tipo.

Ahora la pregunta es: ¿Puedo hacer un objeto que hace mentira acerca de su tipo, sin que sea inmediatamente obvio? Puede que esté profundamente equivocado aquí y me encantaría una aclaración si ese es el caso, pero considere el siguiente código:

public interface IFoo
{
    Type GetType();
}

Y las siguientes dos implementaciones de dicha interfaz:

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

public class NiceFoo : IFoo
{
}

Entonces, si ejecuta el siguiente programa simple:

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();
}

Efectivamente, badFoogenera un error Type.

Ahora bien, no sé si esto tiene implicaciones serias basándome en que Eric describió este comportamiento como una " característica increíblemente peligrosa ", pero ¿podría este patrón representar una amenaza creíble?

¡Buena pregunta! A mi modo de ver, solo se podría engañar a un compañero desarrollador si GetType fuera virtual en el objeto, que no lo es.

Lo que hizo es similar a sombrear GetType, así:

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

con esta clase (y usando el código de muestra de MSDN para el método GetType () ) podría tener:

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

entonces, ¡ay, has mentido con éxito, verdad? Bueno, sí y no ... Considere que usar esto como un exploit significaría usar su instancia BadFoo como un argumento para un método en algún lugar, que espera probablemente un objecttipo base común o uno para una jerarquía de objetos. Algo como esto:

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");
    }
}

pero CheckIfInt(foo)imprime "no un int".

Entonces, básicamente (volviendo a su ejemplo), en realidad solo podría explotar su "tipo mentiroso" con el código que alguien escribió en su IFoointerfaz, que es muy explícito sobre el hecho de que tiene un GetType()método "personalizado" .

Solo si GetType () fuera virtual en el objeto, podría crear un tipo "mentiroso" que podría usarse con métodos como el CheckIfIntanterior para crear estragos en las bibliotecas escritas por otra persona.

Hay dos formas de estar seguro sobre el tipo:

1. Usar typeofen el tipo que no se puede sobrecargar

   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. Transmita la instancia a un objecty llame al 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();

No, no puedes hacer que GetType mienta. Solo está introduciendo un nuevo método. Solo el código que conoce este método lo llamará.

Por ejemplo, no puede hacer que un código de marco o de terceros llame a su nuevo método GetType en lugar del real, ya que ese código no sabe que su método existe y, por lo tanto, nunca lo llamará.

Sin embargo, puede confundir a sus propios desarrolladores con tal declaración. Cualquier código que se compile con su declaración y que use parámetros o variables escritos como IFoo o cualquier tipo derivado de eso usará su nuevo método en su lugar. Pero dado que eso solo afecta a su propio código, realmente no impone una "amenaza".

Si desea proporcionar una descripción de tipo personalizado para una clase esto debe hacerse utilizando un descriptor de tipo personalizado , tal vez mediante la anotación de su clase con un TypeDescriptionProviderAttribute . Esto puede resultar útil en algunas situaciones.

Bueno, en realidad ya existe un tipo que puede estar en GetType: cualquier tipo anulable.

Este código :

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

salidas True.

En realidad, no int?es quién miente, solo el elenco implícito se objectconvierte int?en una caja int. Sin embargo, no se puede distinguir int?desde el intprincipio GetType().

No creo que lo haga, ya que cada código de biblioteca que llame a GetType declarará la variable como 'Objeto' o como un tipo genérico 'T'

El siguiente 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());
    }

huellas dactilares:

Object BadFoo dice que es un 'TypeConcept.BadFoo'

Object NiceFoo dice que es un 'TypeConcept.NiceFoo'

Tipo genérico BadFoo dice que es un 'TypeConcept.BadFoo'

El tipo genérico NiceFoo dice que es un 'TypeConcept.NiceFoo'

La única vez que este tipo de código dará como resultado un mal escenario es en su propio código, donde declara el 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 dice que es un 'System.Int32'

IFoo NiceFoo dice que es un 'TypeConcept.NiceFoo'

Lo peor que puede suceder hasta donde yo sé es engañar a los programadores inocentes que utilizan la clase envenenada, por ejemplo:

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";
}

Si myInstancees una instancia de una clase como la que describe en la pregunta, simplemente se tratará como de tipo desconocido.

Entonces mi respuesta es no, no veo ninguna amenaza real aquí.

Tienes algunas opciones si quieres jugar seguro contra ese tipo de piratería:

Enviar al objeto primero

Puede llamar al GetType()método original al convertir primero la instancia en un object:

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

resulta en:

BadFoo says he's a 'ConsoleApplication.BadFoo'

Usar método de plantilla

El uso de este método de plantilla también le dará el tipo real:

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

GetType(badFoo);

Hay una diferencia entre object.GetTypey IFoo.GetType. GetTypese llama en tiempo de compilación en objetos no conocidos, no en interfaces. En su ejemplo, con la salida badFoo.GetTypese espera un comportamiento, porque sobrecarga el método. Lo único es que otros programadores pueden confundirse con este comportamiento.

Pero si lo usa typeof(), dará como resultado que el tipo es el mismo y no puede sobrescribir typeof().

Además, el programador puede ver en tiempo de compilación qué método GetTypeinvoca.

Entonces, a su pregunta: este patrón no puede representar una amenaza creíble, pero tampoco es el mejor estilo de codificación.