类型转换的通用方法

Question

我正在尝试编写转换类型的通用方法。我想写类似Cast.To<Type>(variable) 而不是(Type) variable。 我这个方法的错误版本：

public class Cast
{
    public static T To<T>(object o)
    {
        return (T) o;
    }
}

这是一个简单的测试：

public class A
{
    public static explicit operator B(A a)
    {
        return new B();
    }
}

public class B
{
}

A a = new A();
B b = Cast.To<B>(a);

如您所料，此代码将失败并显示InvalidCastException。

此代码是否失败是因为虚拟机不知道如何在运行时将object 类型的变量转换为B 类型？但是异常消息说：“无法将 A 类型的对象转换为 B 类型”。所以 CLR 知道变量o 的真实类型，为什么它不能执行转换？

这里是主要问题：我应该如何重写方法T To<T>(object o) 来解决这个问题？

Answer 1

关于运营商解决方案的所有说法都是正确的......但这是我对您的主要问题的回答：

    public static T To<T>(this object o)
    {
        return (T)(dynamic)o;
    }

这里的关键是，将 o 转换为 dynamic 将强制 .NET 在运行时搜索显式运算符。

另外，为什么不让它成为一个扩展方法呢？

代替

        A a = new A();
        B b = Cast.To<B>(a);

你可以的

        A a = new A();
        B b = a.To<B>();

将其作为扩展方法公开的另一个好处是，您可以获得一个用于显式转换的流畅接口（如果您喜欢那种东西）。我一直讨厌在 .NET 中显式转换所需的嵌套括号平衡量。

所以你可以这样做：

a.To<B>().DoSomething().To<C>().DoSomethingElse() 

而不是

((C)((B)a).DoSomething())).DoSomethingElse()

在我看来，它看起来更清晰。

Answer 2

如果您可以使用 c# 4.0，则可以：

namespace CastTest
{
    internal class Program
    {
        private static void Main(string[] args)
        {

            A a = new A();
            B b = Cast.To<B>(a);
            b.Test();

            Console.Write("Done.");
            Console.ReadKey();
        }

        public class Cast
        {
            public static T To<T>(dynamic o)
            {
                return (T)o;
            }
        }

        public class A
        {
            public static explicit operator B(A a)
            {
                return new B();
            }
        }

        public class B
        {
            public void Test()
            {
                Console.WriteLine("It worked!");
            }
        }

    }
}

Answer 3

你可以通过反射找到正确的方法来做到这一点：

public static T To<T> (object obj)
{
    Type sourceType = obj.GetType ();
    MethodInfo op = sourceType.GetMethods ()
                    .Where (m => m.ReturnType == typeof (T))
                    .Where (m => m.Name == "op_Implicit" || m.Name == "op_Explicit")
                    .FirstOrDefault();

    return (op != null)
        ? (T) op.Invoke (null, new [] { obj })
        : (T) Convert.ChangeType (obj, typeof (T));
}

在 .NET 4.0 中，您可以按照其他答案中的建议使用 dynamic 关键字。

Answer 4

您的 Cast.To<T>() 只是试图将对给定对象的引用解释为对 T 的引用。这当然失败了。

如果编译器遇到(B) a 并且知道a 是A 类型并且A 类型具有编译时类型转换运算符B - 它会发出这个类型转换。这不是你的情况。

Answer 5

Instance a 是一个 object 到转换为 B 的那一刻。不是A 类型，而是object。因此，不可能将 object 转换为 B，因为 CLR 无法知道 o 包含显式运算符。
编辑：
是的！这是解决方案：

public class Cast
{
    public static T1 To<T1>(dynamic o)
    {
        return (T1) o;
    }
}

现在 CLR 确切地知道，o 是 A 类型的实例，并且可以调用显式运算符。

Answer 6

如果没有“类型转换器”（一个手动映射所有已知类型的属性的过程，这根本不会发生），您将永远无法使用它。您根本不能只将一个不相关的具体类转换为另一个。它会破坏单一继承模型（这是现代 OOP 的定义原则之一 - 阅读“钻石问题”）

还注意到接口（多态性） - 两个类也必须从同一个接口派生（沿着相同的路线）

Answer 7

我实际上不止一次遇到过这个问题，当我可以将自己限制为实现IConvertible 接口的类型时，它并不觉得OOP“脏”。然后解决方案实际上变得非常干净！

private T To<T>(object o) where T : IConvertible
{
    return (T)Convert.ChangeType(o, typeof(T));
}

例如，当我编写一个分词器时，我使用了它的一个变体，其中输入是一个字符串，但其中的令牌可以被解释为字符串、整数和双精度数。

由于它使用Convert 类，编译器实际上将有信息知道该做什么。这不仅仅是一个简单的演员表。

如果您需要一种更通用的转换方式，我不得不怀疑这是否不是代码中的设计问题。我认为扩大这些东西的范围的一个问题是，你试图覆盖的领域越多，外人就越难知道这种方法能做多少。

我认为最重要的是，当有人专门为该工作编写了一种方法以避免Add(x, y) 仅针对x 和y 的某些值的情况时，强制转换真正起作用。

我认为，如果您自己尝试铸造，预期会有所不同，例如 T1 x = (T1) T2 y。然后我认为更明显的是，您真的是靠自己，因为您只是编造了一些演员阵容，而不是所谓的“覆盖所有演员阵容方法”。

在这种情况下，很明显它专门处理实现IConvertible 的对象，开发人员可以假设它可以很好地处理任何这些对象。

也许不是每个人都同意的面向对象哲学的沉重答案，但我认为这类“概念性问题”通常会出现在编程哲学中。

Answer 8

也许不是你要做什么，但这会奏效：

public class Cast
{
    public static targetType To<soureType, targetType>(object o)
    {
        return (targetType)((sourceType) o);
    }
}

不过，这样的方法对我来说似乎没什么用......