Преобразование типов в ограниченных обобщенных классах

class Base 
{
    public int Num { get; set; } 
}
class Derived : Base { }

class Generic<T> where T : Base
{
    public Method(T obj)
    {
        Derived d = (Derived)obj; // Ошибка: Невозможно преобразовать T в Derived
 
        Console.WriteLine(obj.Num);
    }
}

class A {}
class B : A {}
class C : A {}
 
C c = new C();
B b = (B)c; // Та же самая ошибка.

using System;
 
class Base
{
    public void ShowClassName()
    {
        Console.WriteLine("Base");
    }
}
class Derived : Base
{
    public new void ShowClassName()
    {
        Console.WriteLine("Derived");
    }
}
class Generic<T> where T : Base
{
    public void Method(T obj)
    {
        obj.ShowClassName();
    }
}
 
class Program
{
    static void Main(string[] args)
    {   
        Derived d = new Derived();
        Generic<Derived> gDerived = new Generic<Derived>();
 
        gDerived.Method(d);      //Base!!!
    }
}

        class Base
        {
            public void Foo()
            {
                Console.WriteLine("Base");
            }
        }
        class Derived : Base
        {
            public void Qwerty()
            {
                Console.WriteLine("Derived");
            }
        }
        class Generic<T> where T : Base
        {
            public void Method(T obj)
            {
                obj.Foo();
            }
        }
 
        private static void Main(string[] args)
        {
            Derived d = new Derived();
            Generic<Derived> gDerived = new Generic<Derived>();
 
            gDerived.Method(d);      //Base!!!
        }

class Program
    {
        class Base
        {
            public virtual void ShowClassName()
            {
                Console.WriteLine( "Base" );
            }
        }
        class Derived : Base
        {
            public override void ShowClassName()
            {
                Console.WriteLine( "Derived" );
            }
        }
        class Generic<T> where T : Base
        {
            public void Method( T obj )
            {
                obj.ShowClassName();
            }
        }
 
        static void Main( string[] args )
        {
            Derived d = new Derived();
            Generic<Derived> gDerived = new Generic<Derived>();
            gDerived.Method( d );      //?????????????????
            Console.ReadKey();
        }
    }

    class A 
    { 
        public void MethodA()
        {
 
        }
    }
 
    class B : A 
    { 
        public void MethodB()
        {
 
        }
    }
 
    class C : A { };
 
....
 
        void Method(A a)
        {
            //Compile but runtime error if a is not in fact B
            //Unable to cast object of type 'A' to type 'B'."
            var b = (B)a;
        }

    class Generic<T> where T : A
    {
        public void Method(T a)
        {
            //var b = (B)a; //compile error
 
            var o = (B)(object)a; //unsafe but compile
 
            //safe
            if (a is B b)
            {
                b.MethodB();
            }
  
        }
    }

public void Method(T a)
{
    Console.WriteLine(typeof(T).Name); // Не путать с a.GetType()!
}

    class Generic<T> where T : A
    {
        public void Method(T a)
        {
            //compile time, a is A
            a.MethodA(); //A
 
            //runtime, d is B
            dynamic d = a;
            d.MethodA(); //new B
        }
    }

   class A 
    { 
        public int MethodA()
        {
            return 0;
        }
    }
 
    class B : A 
    {
        public new string MethodA()
        {
            return "new B";
        }
    }