c# - 在构造函数上调用 MethodBase 的 Invoke(反射)

Question

首先，很抱歉，如果之前有人问过这个问题。我进行了相当全面的搜索，没有发现任何类似的东西，但我可能遗漏了一些东西。

现在回答问题:我试图通过反射调用构造函数，但没有成功。基本上，我有一个要克隆的对象，因此我查找其类型的复制构造函数然后调用它。这是我拥有的:

public Object clone(Object toClone) {
     MethodBase copyConstructor = type.GetConstructor(
         new Type[] { toClone.GetType() });
     return method.Invoke(toClone, new object[] { toClone }); //<-- doesn't work
}

我这样调用上面的方法:

List<int> list = new List<int>(new int[] { 0, 1, 2 });
List<int> clone = (List<int>) clone(list);

现在，请注意我使用的调用方法是 MethodBase的调用。 ConstructorInfo提供了一个 invoke 方法，如果像这样调用它确实有效:

return ((ConstructorInfo) method).Invoke(new object[] { toClone });

但是，我想使用 MethodBase的方法，因为实际上我不是每次都查找复制构造函数，而是将其存储在字典中，而字典包含方法和构造函数，所以它是 Dictionary<MethodBase> , 不是 Dictionary<ConstructorInfo> .我当然可以转换为 ConstructorInfo正如我上面所做的，但我宁愿避免转换并使用 MethodBase方法直接。我只是想不出正确的参数。

有什么帮助吗？非常感谢。

---

编辑

本杰明，
非常感谢您的建议。我实际上完全按照你在第二次编辑中的建议做了，除了(这是一个很大的“除了”)我的字典在哪里

class ClonerMethod {

    public MethodBase method;
    public bool isConstructor;

    ...

    public Object invoke(Object toClone) {
        return isConstructor ?
            ((ConstructorInfo) method).Invoke(new object[] { toClone }) : //<-- I wanted to avoid this cast
            method.Invoke(toClone, null);
    }

}

然后我调用ClonerMethod的 invoke根据我在字典中找到的内容。我没有添加处理所有这些的代码，因为我正在寻找的答案只是如何在 ConstructorInfo 上调用 Invoke。使用 MethodBase的 Invoke方法，所以我不想添加不必要的信息和太多代码供你们阅读。不过，我喜欢你使用 Func<,>好多了，所以我转向那个。同时制作 Clone方法 generic 是一个很好的补充，但在我的例子中，调用者不知道对象的类型，所以我将保留它为非泛型。

我不知道 Func<,> ，如果我知道我忘记的 lambda 运算符(我以前真的不需要这样的东西)，所以我实际上从你的回答中学到了很多东西。我总是喜欢学习新事物，这在将来会派上用场，非常感谢! :)

Answer 1

如果您知道该对象具有这样的构造函数，您是否考虑过使用 Activator.CreateInstance 的重载？相反？

---

更新:所以您已经对 MethodInfo/MethodBase 进行了级联搜索并存储了它们 -> 您不想/不能使用 Activator .

在那种情况下，我看不出有什么方法可以在没有类型转换的情况下做你想做的事。但是 - 也许您可以更改架构以存储 Dictionary<Type, Func<object, object>>并添加那些 Func<>实例代替。使调用代码更好(我假设)并允许您执行一次此转换:

// Constructor
dictionary.Add(type,
  source => ((ConstructorInfo) method).Invoke(new object[] {source})
);

// Clone
dictionary.Add(type,
  source => method.Invoke(source, new object[]{})
);

事实上，由于您只关心构造函数和普通方法在抓取它们的地方的区别，所以根本不需要强制转换，对吗？

// Constructor 2
dictionary.Add(type,
  source => yourConstructorInfo.Invoke(new object[] {source})
);

除非我遗漏了什么(当然很有可能)这可以通过在围栏的定义侧执行一次来解决问题，调用者不需要介意这是否是构造函数？

---

最后一次，然后我将停止编辑垃圾邮件。我很无聊，想出了以下代码。这就是您要实现的目标吗？

public class Cloner {
    private readonly IDictionary<Type, Func<object, object>> _cloneMap =
            new Dictionary<Type, Func<object, object>>();

    public T Clone<T>(T source) {
        Type sourceType = source.GetType();
        Func<object, object> cloneFunc;

        if (_cloneMap.TryGetValue(sourceType, out cloneFunc)) {
            return (T)cloneFunc(source);
        }

        if (TryGetCopyConstructorCloneFunc(sourceType, out cloneFunc)) {
            _cloneMap.Add(sourceType, cloneFunc);
            return (T)cloneFunc(source);
        }

        if (TryGetICloneableCloneFunc(sourceType, out cloneFunc)) {
            _cloneMap.Add(sourceType, cloneFunc);
            return (T)cloneFunc(source);
        }

        return default(T);
    }

    private bool TryGetCopyConstructorCloneFunc(Type type, 
                    out Func<object, object> cloneFunc) {
        var constructor = type.GetConstructor(new[] { type });
        if (constructor == null) {
            cloneFunc = source => null;
            return false;
        }
        cloneFunc = source => constructor.Invoke(new[] { source });
        return true;
    }

    private bool TryGetICloneableCloneFunc(Type type,
                    out Func<object, object> cloneFunc) {
        bool isICloneable = typeof(ICloneable).IsAssignableFrom(type);
        var cloneMethod = type.GetMethod("Clone", new Type[] { });
        if (!isICloneable || (cloneMethod == null)) {
            cloneFunc = source => null;
            return false;
        }
        cloneFunc = source => cloneMethod.Invoke(source, new object[] {});
        return true;
    }
}