Question

我目前正在寻找构建动态类型转换器，

例如，我可以很容易地做到：

public struct Tester
{
    public int Hello;

    public static implicit operator int(Tester d)
    {
        return d.Hello;
    }

    public static implicit operator float(Tester d)
    {
        return d.Hello;
    }
}

然后

typeof(Tester).GetMethods()

将返回隐式转换MethodInfo。

但是，如果我这样做：

typeof(int).GetMethods()

它不会返回任何op_implicit

我看到你可以看到表格here，但我想知道是否有可能从框架本身反映出来。

请注意，它不是真正的阻塞问题，如果不可能，我会手动从表中添加转换器，但我显然希望动态构建（更干净，更不容易出错）。

Answer 1

原始类型的运算符未在框架中定义 - 它们是CLI本身的一部分;他们基本上都有自己的特殊指示。没有涉及IL，没有方法，因此MethodInfo无需引用。

但是，如果你看一下System.Decimal，你会发现运算符在框架本身中只是“实现”。

（在略微类似的方式中，string未声明+运算符;在C＃中使用+会转换为对{{string.Concat的调用1}}。）

Answer 2

Jon当然是对的。但是，您可能需要查看System.Linq.Expressions.Expression类（尤其是Convert方法）。例如，人们可以快速构建这样的东西：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;

namespace Tests
{
    static class ConvertTest
    {
        // conceptual point
        static Func<TInput, TOutput> CreateConvertFunc<TInput, TOutput>()
        {
            var source = Expression.Parameter(typeof(TInput), "source");
            // the next will throw if no conversion exists
            var convert = Expression.Convert(source, typeof(TOutput));
            var method = convert.Method;
            if (method != null)
            {
                // here is your method info
            }
            else
            {
                // here is the case of primitive types
                // unfortunately it would not help you, because it's resolved when you call Complile.
                // but you can take a look at reference implementation how they handle it 
            }
            return Expression.Lambda<Func<TInput, TOutput>>(convert, source).Compile();
        }
        // cache
        struct ConverterFunc<TInput, TOutput>
        {
            public static readonly Func<TInput, TOutput> Instance = CreateConvertFunc<TInput, TOutput>();
        }
        // fluent accessor
        struct ConvertSource<T>
        {
            public T source;
            public U To<U>()
            {
                try { return ConverterFunc<T, U>.Instance(source); }
                catch (TypeInitializationException e) { throw e.InnerException; }
            }
        }
        static ConvertSource<T> Convert<T>(this T source) { return new ConvertSource<T> { source = source }; }
        // test
        struct Wrapper<T>
        {
            public T Value;
            public static implicit operator Wrapper<T>(T source) { return new Wrapper<T> { Value = source }; }
            public static implicit operator T(Wrapper<T> source) { return source.Value; }
        }
        class A { }
        class B : A { }
        static void Main(string[] args)
        {
            var v0 = 1;
            var v1 = v0.Convert().To<byte>();
            var v2 = v1.Convert().To<double>();
            var v3 = v2.Convert().To<decimal>();
            var v4 = v3.Convert().To<Wrapper<decimal>>();
            var v5 = v4.Convert().To<decimal?>();
            var v6 = v5.Convert().To<int>();
            var v7 = Enumerable.Empty<B>().Convert().To<IEnumerable<A>>();
            var v8 = v7.Convert().To<int>(); // exception
        }
    }
}

反映op_implicit表

2 个答案: