Upcast an object

Question

I am searching a way to get the possible types for upcasting an object. For example: I have a control of type MyControl which inherits Control. Now, when the object of type MyControl is downcasted to Control is there a way to find out, if it is the top object-type or when now to get the type(s) in which it can be upcasted (in this case MyControl)? I want it upcast to MyControl (with Reflection) and get a Property with reflection. But I don't know MyControl at the place where I have to do this.

MyControl is implement Visible with new. Now when I call control.Visible = true it will call the Visible of Control but I have to call the Visible of MyControl.

Thanks for your help.

Answer 1

There is:

if (myControl is MyControl)
{
    var m = (MyControl)myControl;
}

This will work on any part of the type hierarchy. The following check will not work if the variable itself is of a base type:

MyBaseControl myControl = null;

if (myControl.GetType() == typeof(MyControl))
{

}

However it sounds like you want the behaviour of overridden methods or properties. In the normal situation, you would override Visible:

public override bool Visible
{
    get { return true; } // Always visible in derived class.
}

However this is only if the base class is not sealed and the member you want to override is abstract or virtual. If this is not the case, then I'd stick with casting to the derived type... not ideal, but not many options.

It also sounds like you tried to hide the base member like this:

public new bool Visible
{
    get { return true; }
}

This only works if you have a reference to the type itself. If you have a reference to the base type, the member hiding does not work, it doesn't know the member is hidden in the derived type:

MyBaseControl c = new MyDerivedControl();

bool vis = c.Visible; // Comes from MyBaseControl even if hidden in derived control.

(In the above, if Visible were overridden, then it would come from the derived class).

Update: to do any of this at runtime, you can do the following so long as you know the names of the things you want to reflect:

class Program
    {
        static void Main(string[] args)
        {
            A a = new B();

            // Get the casted object.
            string fullName = a.GetType().FullName;
            object castedObject = Convert.ChangeType(a, Type.GetType(fullName));

            // Use reflection to get the type.
            var pi = castedObject.GetType().GetProperty("Visible");

            Console.WriteLine(a.Visible);
            Console.WriteLine((bool)pi.GetValue(castedObject, null));

            Console.Read();
        }
    }    

    class A
    {
        public bool Visible { get { return false; } }
    }

    class B : A
    {
        public new bool Visible { get { return true; } }
    }
}

Answer 2

You can also use this:

MyControl myControl = someControlOfTypeMyControl as MyControl

if(myControl != null)
{
   //your stuff
}

With "as" .net framework checks if the control is from that type and if it is possible to cast the .NET Framework will cast and return with type MyControl, otherwise it will return null.

So basically, its the same as previous answers, but more clean (imho, you can think different)

Answer 3

Control control = (control)someControlOfTypeMyControl;

if (control is MyControl) {
    var myControl = (MyControl)control;
    var propertyValue = myControl.SomeProperty;
}