Will GetType() return the most derived type when called from the base class?

Will GetType() return the most derive开发者_运维知识库d type when called from the base class?

Example:

public abstract class A
{
    private Type GetInfo()
    {
         return System.Attribute.GetCustomAttributes(this.GetType());
    }
}

public class B : A
{
   //Fields here have some custom attributes added to them
}

Or should I just make an abstract method that the derived classes will have to implement like the following?

public abstract class A
{
    protected abstract Type GetSubType();

    private Type GetInfo()
    {
         return System.Attribute.GetCustomAttributes(GetSubType());
    }
}

public class B : A
{
   //Fields here have some custom attributes added to them

   protected Type GetSubType()
   {
       return GetType();
   }
}

GetType() will return the actual, instantiated type. In your case, if you call GetType() on an instance of B, it will return typeof(B), even if the variable in question is declared as a reference to an A.

There is no reason for your GetSubType() method.

GetType always returns the type that was actually instantiated. i.e. the most derived type. This means your GetSubType behaves just like GetType itself and thus is unnecessary.

To statically get the type information of some type you can use typeof(MyClass).

Your code has a mistake though: System.Attribute.GetCustomAttributes returns Attribute[] not Type.

GetType always returns the actual type.

The reason for it is deep in the .NET framework and CLR, as the JIT and CLR use the .GetType method to create a Type object in memory that holds the information on the object, and all access to the object and compilation are via this Type instance.

For more information, take a look in the book "CLR via C#" from Microsoft Press.

Output:

GetType:
        Parent: 'Playground.ParentClass'
        Child: 'Playground.ChildClass'
        Child as Parent: 'Playground.ChildClass'

GetParentType:
        Parent: 'Playground.ParentClass'
        Child: 'Playground.ParentClass'
        Child as Parent: 'Playground.ParentClass'

Program.cs:

using Playground;

var parent = new ParentClass();
var child = new ChildClass();
var childAsParent = child as ParentClass;

Console.WriteLine("GetType:\n" +
                  $"\tParent: '{parent.GetType()}'\n" +
                  $"\tChild: '{child.GetType()}'\n" +
                  $"\tChild as Parent: '{childAsParent.GetType()}'\n");

Console.WriteLine("GetParentType:\n" +
                  $"\tParent: '{parent.GetParentType()}'\n" +
                  $"\tChild: '{child.GetParentType()}'\n" +
                  $"\tChild as Parent: '{childAsParent.GetParentType()}'\n");

ChildClass.cs

namespace Playground
{
    public class ChildClass : ParentClass
    {
    }
}

ParentClass.cs

namespace Playground
{
    public class ParentClass
    {
        public Type GetParentType()
        {
            return typeof(ParentClass);
        }
    }
}