c# - name - ¿Por qué Object.GetType() no es virtual?

type.gettype c#

Question

muestra de código tomada de MSDN

public class Test {
public static void Main() {
  MyBaseClass myBase = new MyBaseClass();
  MyDerivedClass myDerived = new MyDerivedClass();
  object o = myDerived;
  MyBaseClass b = myDerived;

  Console.WriteLine("mybase: Type is {0}", myBase.GetType());
  Console.WriteLine("myDerived: Type is {0}", myDerived.GetType());
  Console.WriteLine("object o = myDerived: Type is {0}", o.GetType());
  Console.WriteLine("MyBaseClass b = myDerived: Type is {0}", b.GetType());   }}

/*
This code produces the following output.
mybase: Type is MyBaseClass
myDerived: Type is MyDerivedClass
object o = myDerived: Type is MyDerivedClass
MyBaseClass b = myDerived: Type is MyDerivedClass 
*/

Entonces, ¿sería lógico hacer GetType () virtual al menos funciona como virtual? ¿Alguien puede explicar eso? Y otra pregunta: ¿Hay algún otro método en NET Framework que tenga un comportamiento similar a GetType?

Answer 1

GetType devuelve el tipo real del objeto. Esto nos permite saber qué objeto realmente pasamos a ''nuestra'' función. Muchos métodos del marco necesitan esto para determinar su propia funcionalidad, en la mayoría de los casos para obtener los Atributos de esta clase. Si el Framework perdería la posibilidad de determinar el tipo real de un objeto, el objeto también perdería este tipo .

Si desea saber el tipo utilizado dentro del alcance de su método, el tipo que ha declarado o el compilador, puede agregar un método de extensión bastante simple:

public static Type GetCurrentType<T>(this T obj)
{
    return typeof(T);
}

public static void Main()
{
  MyBaseClass myBase = new MyBaseClass();
  MyDerivedClass myDerived = new MyDerivedClass();
  object o = myDerived;
  MyBaseClass b = myDerived;

  Console.WriteLine("mybase: Type is {0}", myBase.GetCurrentType());
  Console.WriteLine("myDerived: Type is {0}", myDerived.GetCurrentType());
  Console.WriteLine("object o = myDerived: Type is {0}", o.GetCurrentType());
  Console.WriteLine("MyBaseClass b = myDerived: Type is {0}", b.GetCurrentType());
}

/*
This code produces the following output.
mybase: Type is ValidatorTest.MyBaseClass
myDerived: Type is ValidatorTest.MyDerivedClass
object o = myDerived: Type is System.Object
MyBaseClass b = myDerived: Type is ValidatorTest.MyBaseClass
*/

Answer 2

porque .Net Framework no quiere que anule el método GetType () y la spoof acerca del tipo.

supongamos que puede anular el método, ¿qué otra cosa le gustaría que hiciera, aparte de devolver el tipo de la instancia? y cuando anula el método para que cada una de sus clases devuelva el tipo de instancia, ¿no violará DRY entonces?

Answer 3

Si GetType() era virtual, una clase llamada HumanBeing puede anularlo y devolver un objeto Type que represente a Robot que se denomina suplantación y evitar que esta sea una de las características principales de CLR llamada Type Safety.

Answer 4

Si bien es cierto que no puede anular el método object.GetType (), puede usar "new" para sobrecargarlo por completo, falsificando así otro tipo conocido. Esto es interesante, sin embargo, no he descubierto cómo crear una instancia del objeto "Tipo" desde cero, por lo que el siguiente ejemplo pretende ser de otro tipo.

public class NotAString
{
    private string m_RealString = string.Empty;
    public new Type GetType()
    {
        return m_RealString.GetType();
    }
}

Después de crear una instancia de esto, (nuevo NotAString ()). GetType (), de hecho devolverá el tipo para una cadena.

Answer 5

Modificando la respuesta de Dr Snooze, para "crear una instancia del objeto" Type "desde cero":

public class NotAString
{
    public new Type GetType()
    {
        return typeof(string);
    }
}