两个相同的值，参与类型转换结果完全不同

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Test
{
    public class Program
    {
        static void Main(string[] args)
        {
            new ClassA<Object>().run();
        }
    }

    public class ClassA<T> {
        public int _int = 10;
        public ClassA<T> val { get; set; }

        public void run()
        {
            this.val = this;
            Class<T>.Instance.setDga<T>(this.func);

            var type = typeof(ClassA<T>);
            var proInfo = type.GetProperty("val");
            var getVal = proInfo.GetGetMethod().Invoke(this, new object[] {});

            Console.WriteLine("call with getVal");
            Class<T>.Instance.Trans(getVal);
            Class<T>.Instance.Trans(getVal);

            Console.WriteLine("");

            Console.WriteLine("call with val");
            Class<T>.Instance.Trans(val);
            Class<T>.Instance.Trans(val);

            Console.WriteLine("");

            Console.WriteLine("compare val and getVal:  \r\n " +
                "==:{0} \r\n " +
                "equals:{1} \r\n " +
                "refEquals:{2} \r\n  " +
                "getVal{3} \r\n " +
                "val:{4} \r\n" +
                "type==:{5}", 
                getVal == val, val?.Equals(getVal), ReferenceEquals(getVal, val),
                ((ClassA<T>)getVal)._int, val._int,
                getVal.GetType() == val.GetType());
            
            Console.ReadKey();
        }

        public void func(T handler) { 
            Console.WriteLine("success call func! handler:{0}", handler);
        }
    }

    public class Class<T>
    {
        private static Class<T> _instance;
        public static Class<T> Instance { 
            get {
                if(_instance == null)
                    _instance = new Class<T>();
                return _instance; 
            } 
        }
        public delegate void Handler<Tm>(Tm message);
        private Delegate dga;

        public void setDga<Tm>(Handler<Tm> handler)
        {
            dga = handler;
        }

        public void Trans<Tm>(Tm obj)
        {
            var t1 = dga as Handler<Tm>;
            if (t1 != null) t1(obj);
            Console.WriteLine("result:{0}", t1);
        }
    }
}

下面是输出结果：

call with getVal
success call func! handler:Test.ClassA`1[System.Object]
result:Test.Class`1+Handler`1[System.Object,System.Object]
success call func! handler:Test.ClassA`1[System.Object]
result:Test.Class`1+Handler`1[System.Object,System.Object]

call with val
result:
result:

compare val and getVal:
 ==:True
 equals:True
 refEquals:True
  getVal10
 val:10
type==:True

我不能理解为什么：`Class<T>.Instance.Trans(val);`调用的`dga as Handler<Tm>;`会失败。

因为classA的实例val和classA的属性val返回的是两个不同的对象，即使它们的值相同，在.net框架内都是两个不同的对象，因此Class.Instance.Trans(val);用val作为参数传入，而Class.Instance.Trans(getVal);用getVal作为参数传入，分别根据调用类型转换函数转换成不同的类型，所以结果完全不同。