您还可以使用以下命令：

MyControl myControl = someControlOfTypeMyControl as MyControl

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

如果使用"as"，. NET Framework将检查控件是否来自该类型，如果可以强制转换，. NET Framework将强制转换并返回类型MyControl，否则将返回null。
所以基本上，它和以前的答案一样，但更干净（imho，你可以想不同的）

有：

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

这将对类型层次结构的任何部分起作用。如果变量本身是基类型，下面的检查将不起作用：

MyBaseControl myControl = null;

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

}

但是，听起来您需要重写方法或属性的行为。在正常情况下，您将重写Visible：

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

然而，只有当基类没有被密封，并且您想要覆盖的成员是abstract或virtual时，才需要这样做。如果不是这种情况，那么我会坚持强制转换为派生类型......虽然不理想，但选项不多。
听起来还像是您试图隐藏基成员，如下所示：

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

这只在你有一个对类型本身的引用时有效，如果你有一个对基类型的引用，成员隐藏就不起作用了，它不知道成员在派生类型中是隐藏的：

MyBaseControl c = new MyDerivedControl();

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

(In如果Visible被重写，则它将来自派生类）。

• • 更新：**要在运行时执行任何操作，只要知道要反映的内容的名称，就可以执行以下操作：

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

Control control = (control)someControlOfTypeMyControl;

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

public class Animal

{

    public void Speak()
    {
        Console.WriteLine("Animal is Speak");
    }

    public void Move()
    {
        Console.WriteLine("Animal is Move");
    }
    public void Eat()
    {
        Console.WriteLine("Animal is Eat");
    }
}
public class HumingBird:Animal

{

    public void Fly()
    {
        Console.WriteLine("Huming Bird is Fly");
    }
}

class Program

{
    static void Main(string[] args)
    {
    
        Animal animal = new HumingBird();

     
        HumingBird humingBird = (HumingBird)animal;
        humingBird.Fly();

    }
}

向上转换是将对象放置在引用基类的子类中

Animal animal = new HumingBird(); // Upcasting

向下强制转换是通过在子类的引用中放置对基类的引用来进行显式强制转换

HumingBird humingBird = (HumingBird)animal;

humingBird.Fly();