主页 / 问题 / 919154
Accepted
i-one
Asked:2020-12-13 00:51:10 +0000 UTC2020-12-13 00:51:10 +0000 UTC

Cast<T> 用于一组转换为 T 的元素

  • 772

有一个类包含从int类型到此类类型的强制转换运算符

class Item
{
    public int ID;

    public static implicit operator Item(int id)
    {
        return new Item { ID = id };
    }
}

如果你这样写

int id = 1;
Item item = id;

然后类型转换起作用。

现在我想将一组int 转换为一组Items，所以我这样做了

int[] ids = new int[] { 1, 2, 3 };
Item[] items = ids.Cast<Item>().ToArray();

并得到

System.Core.dll 中发生“System.InvalidCastException”类型的未处理异常附加信息：无法将“System.Int32”类型的对象转换为“Item”类型。

用显式替换隐式没有帮助。

解决这个问题的最优雅的方法是什么，以及（最重要的是）为什么Cast<T>不起作用？

c#

2 个回答

  1. Best Answer

    Cast不起作用，因为如果我们打开它的源代码，我们将看到以下内容：

    static IEnumerable<TResult> CastIterator<TResult>(IEnumerable source) {
    foreach (object obj in source) yield return (TResult)obj;
}

    那些。它本质上是等价的

    int id = 1;
Item item = (Item)(object)id;

    当然，这不起作用，因为object它无法转换为您的类型，并且object通常禁止创建用于显式/隐式转换的运算符。

    为了使用您的运算符，编译器必须在编译时看到它并生成调用：

    int[] ids = new int[] { 1, 2, 3 };
Item[] items = ids.Select(i => (Item)i).ToArray();

    对于已经编译的程序集，这将不起作用。

    PS：

    当然，您可以尝试编写自己的强制转换方法：

    public static class MyExtensions
{
    public static IEnumerable<TOut> MyCast<TIn, TOut>(this IEnumerable<TIn> sourse)
    {
        foreach (TIn e in sourse) yield return (TOut)e;
    }
}

    但这不会编译，因为您不能TIn将任意类型转换为任意TOut.

    您可以尝试对类型添加约束：

    public static class MyExtensions
{
    public static IEnumerable<TOut> MyCast<TIn, TOut>(
        this IEnumerable<TIn> sourse) where TOut : TIn
    {
        foreach (TIn e in sourse) yield return (TOut)e;
    }
}

    这个类甚至可以编译，但你将无法使用它：

    Item[] items = ids.MyCast<int, Item>().ToArray();

    因为它Item不是（继承人）int。

    当然，如果你真的需要一个解决这个问题的方法，以至于你准备好使用反射或动态类型，那么你可以想出某种解决方案，通过它的签名找到一个方法，为它创建一个委托它并缓存它：

    public static class MyExtensions
{
    public static IEnumerable<TOut> MyCast<TIn, TOut>(this IEnumerable<TIn> sourse)
    {
        var castMethod = CastImpl<TIn, TOut>.CastMethod;
        foreach (TIn e in sourse) yield return castMethod(e);
    }

    static class CastImpl<TIn, TOut>
    {
        public static readonly Func<TIn, TOut> CastMethod;

        static CastImpl()
        {
            var attr = MethodAttributes.Static
                     | MethodAttributes.Public
                     | MethodAttributes.HideBySig
                     | MethodAttributes.SpecialName;
            var names = new[] { "op_Implicit", "op_Explicit" };
            var method = typeof(TIn).GetMethods()
                .Concat(typeof(TOut).GetMethods())
                .Where(mi => mi.Attributes == attr
                    && names.Contains(mi.Name)
                    && mi.ReturnType == typeof(TOut)
                    && mi.GetParameters() is ParameterInfo[] pi
                    && pi.Length == 1
                    && pi[0].ParameterType == typeof(TIn))
                .FirstOrDefault();
            if (method == null) throw new NotSupportedException(
                $"Cast {typeof(TIn)} => {typeof(TOut)} not supported!");
            CastMethod = (Func<TIn, TOut>)method.CreateDelegate(typeof(Func<TIn, TOut>));
        }
    }
}

    那么这当然会起作用：

    int[] ids = new int[] { 1, 2, 3 };
Item[] items = ids.MyCast<int, Item>().ToArray();

    Expression由于会自动找到转换方法，因此using看起来会更短：

    public static class MyExtensions
{
    public static IEnumerable<TOut> MyCast<TIn, TOut>(this IEnumerable<TIn> sourse)
    {
        var castMethod = CastImpl<TIn, TOut>.CastMethod;
        foreach (TIn e in sourse) yield return castMethod(e);
    }

    static class CastImpl<TIn, TOut>
    {
        public static readonly Func<TIn, TOut> CastMethod;

        static CastImpl()
        {
            var param = Expression.Parameter(typeof(TIn), "i");
            var body = Expression.Convert(param, typeof(TOut));
            var lambda = Expression.Lambda(body, new[] { param });
            CastMethod = (Func<TIn, TOut>)lambda.Compile();
        }
    }
}

    此外，这种方法被证明更加通用，通常的转换将在其中起作用（与前一种不同）：

    var cars = items.MyCast<Vehicle, Car>();
    • 8 
  2. int[] ids = new int[] { 1, 2, 3 };

var test = Array.ConvertAll(ids, (p => (Item)p));//Вариант 1
var test2 = ids.Select(p => (Item)p).ToArray();  //Вариант 2

    检查您自己的代码。

    两者都绝对成功。选择你最喜欢的。

    不要忘记包含命名空间：使用 System.Linq

    • 1

相关问题