将 Action<T> 公开为 Action<object>

Question

我正在创建一个框架，其中包含一个库（特别是 SharpBrake）的包装器，它通过反射执行与 SharpBrake 的所有交互，因此我的框架的第 3 方对库没有硬性依赖。

如果我的框架的第 3 方想要使用 SharpBrake，他们可以将 SharpBrake.dll 塞入 bin 文件夹，但如果他们不这样做，他们可以忘记它。如果我的框架有对 SharpBrake 类型的显式引用，我的框架的用户会在缺少 SharpBrake.dll 的运行时遇到异常，这是我不希望的。

所以，我的包装器首先从磁盘加载 SharpBrake.dll，找到 AirbrakeClient 类型，并将指向 AirbrakeClient.Send(AirbrakeNotice) 方法的委托存储在私有字段中。然而，我的问题是，由于Send() 方法采用AirbrakeNotice 对象并且我不能直接引用AirbrakeNotice 对象，我需要以某种方式将Send() 方法转换为Action<object>。

我有一种强烈的感觉，这是不可能的，但我想在决定公开Delegate 和使用DynamicInvoke() 之前探索所有选项，我认为这在性能方面远非最佳。我想做的是：

Type clientType = exportedTypes.FirstOrDefault(type => type.Name == "AirbrakeClient");
Type noticeType = exportedTypes.FirstOrDefault(type => type.Name == "AirbrakeNotice");
MethodInfo sendMethod = clientType.GetMethod("Send", new[] { noticeType });
object client = Activator.CreateInstance(clientType);
Type actionType = Expression.GetActionType(noticeType);
Delegate sendMethodDelegate = Delegate.CreateDelegate(actionType, client, sendMethod);

// This fails with an InvalidCastException:
Action<object> sendAction = (Action<object>)sendMethodDelegate;

但是，这会失败并出现以下异常：

System.InvalidCastException：无法将“System.Action`1[SharpBrake.Serialization.AirbrakeNotice]”类型的对象转换为“System.Action`1[System.Object]”类型。

显然，因为sendMethodDelegate 是Action<AirbrakeNotice> 而不是Action<object>。由于我不能在我的代码中提及AirbrakeNotice，我不得不这样做：

Action<object> sendAction = x => sendMethodDelegate.DynamicInvoke(x);

或者直接暴露Delegate sendMethodDelegate。这可能吗？我知道有可能会遇到object 可能与AirbrakeNotice 不同类型的情况，这会很糟糕，但是看到无论如何你可以搞砸反射，我希望某处存在漏洞。

Answer 1

如果您乐于使用表达式树，这相当简单：

ConstantExpression target = Expression.Constant(client, clientType);

ParameterExpression parameter = Expression.Parameter(typeof(object), "x");
Expression converted = Expression.Convert(parameter, noticeType);
Expression call = Expression.Call(target, sendMethod, converted);

Action<object> action = Expression.Lambda<Action<object>>(call, parameter)
                                  .Compile();

我认为这就是你想要的......

Answer 2

如果您不需要低于 C# 4 的支持，您可以使用 dynamic 与 DynamicInvoke 获得更好的性能。

Action<dynamic> sendAction = x => sendMethodDelegate(x);

实际上，如果您可以使用动态，我猜您甚至不需要上述内容，因为如果您这样做，它会提高性能并简化一切：

Type clientType = exportedTypes.FirstOrDefault(type => type.Name == "AirbrakeClient");
dynamic client = Activator.CreateInstance(clientType);

...
client.Send(anAirbrakeNotice);

但是如果你需要支持 .net 3.5 jon skeets 用表达式树回答肯定是要走的路。

Answer 3

来自我对 OP 的评论：

如果您担心性能，我会避免扩展使用反射。如果您可以为您正在使用的类提供一个接口，那么我会创建一个。然后编写一个包装器，通过调用 SharpBreak 代码来实现接口，并将其填充到单独的 DLL 中。然后仅动态加载您的包装程序集和具体包装器类型，并调用该接口。这样你就不必在方法级别进行反射了。

我不确定您需要的所有类，但这里有一个简单的示例，说明如何通过基于接口的松散耦合连接到该库。

在程序的程序集中：

public IExtensions
{
    void SendToAirbrake(Exception exception);
}

public static AirbreakExtensions
{
    private static IExtensions _impl;

    static()
    {
        impl = new NullExtensions();
        // Todo: Load if available here
    }

    public static void SendToAirbrake(this Exception exception)
    {
        _impl.SendToAirbrake(exception);
    }
}

internal class NullExtensions : IExtensions // no-op fake
{
    void SendToAirbrake(Exception exception)
    {
    }
}

在加载时可用（通过反射）程序集

public ExtensionsAdapter : IExtensions
{
    void SendToAirbrake(Exception exception)
    {
        SharpBrake.Extensions.SendToAirbrake(exception);
    }
}

这种方法的优点是您只使用一次反射（在加载时），并且再也不会触摸它。修改为使用依赖注入或模拟对象（用于测试）也很简单。

编辑：

对于其他类型，这需要更多的工作。

您可能需要use the Abstract Factory pattern 来实例化AirbrakeNoticeBuilder，因为您需要直接处理接口，并且不能将构造函数放在接口中。

public interface IAirbrakeNoticeBuilderFactory
{
    IAirbrakeNoticeBuilder Create();
    IAirbrakeNoticeBuilder Create(AirbrakeConfiguration configuration);
}

如果您要处理自定义 Airbreak 结构，您将需要做更多的工作。

例如对于AirbrakeNoticeBuilder，您必须为您使用的任何相关类创建重复的 POCO 类型。

public interface IAirbrakeNoticeBuilder
{
    AirbrakeNotice Notice(Exception exception);
}

由于您要返回 AirbrakeNotice，您可能必须拉入 Serialization 文件夹下的几乎所有 POCO，具体取决于您使用的数量以及传递回框架的数量。

如果您决定复制 POCO 代码，包括整个对象树，您可以look into using AutoMapper to convert to and from your POCO copies。

或者，如果您不使用要返回的类中的值，而只是将它们传递回 SharpBreak 代码，您可以提出某种不透明的参考方案，该方案将使用您的字典实际 POCO 类型的不透明引用类型。然后你不必将整个 POCO 对象树复制到你的代码中，也不需要花费太多的运行时开销来来回映射对象树：

public class AirbrakeNotice
{
    // Note there is no implementation
}

internal class AirbreakNoticeMap
{
    static AirbreakNoticeMap()
    {
        Map = new Dictionary<AirbreakNotice, SharpBreak.AirbreakNotice>();
    }

    public static Dictionary<AirbreakNotice, SharpBreak.AirbreakNotice> Map { get; }
}

public interface IAirbrakeClient
{
    void Send(AirbrakeNotice notice);
    // ...
}

internal class AirbrakeClientWrapper : IAirbrakeClient
{
    private AirbrakeClient _airbrakeClient;

    public void Send(AirbrakeNotice notice)
    {
        SharpBreak.AirbrakeNotice actualNotice = AirbreakNoticeMap.Map[notice];
        _airbrakeClient.Send(actualNotice);
    }

    // ...
}

internal class AirbrakeNoticeBuilderWrapper : IAirbrakeNoticeBuilder
{
    AirbrakeNoticeBuilder _airbrakeNoticeBuilder;

    public AirbrakeNotice Notice(Exception exception)
    {
        SharpBreak.AirbrakeNotice actualNotice =
            _airbrakeNoticeBuilder.Notice(exception);

        AirbrakeNotice result = new AirbrakeNotice();
        AirbreakNoticeMap.Map[result] = actualNotice;

        return result;
    }

    // ...
}

请记住，您只需要包装您将要使用的公共接口的类和部分。即使您不包装其整个公共接口，该对象仍将在内部表现相同。这可能意味着您必须做更少的工作，因此请努力思考并尝试仅包装您现在需要的东西，以及您知道将来会需要的东西。记住YAGNI。

Answer 4

对于此类问题，我真正喜欢的编程风格是编写尽可能多的强类型代码，然后将逻辑从动态类型代码移交给强类型代码。所以我会这样写你的代码：

  //your code which gets types
  Type clientType = exportedTypes.FirstOrDefault(type => type.Name == "AirbrakeClient");
  Type noticeType = exportedTypes.FirstOrDefault(type => type.Name == "AirbrakeNotice");

  //construct my helper object
  var makeDelegateHelperType=typeof(MakeDelegateHelper<,>).MakeGenericType(clientType, noticeType);
  var makeDelegateHelper=(MakeDelegateHelper)Activator.CreateInstance(makeDelegateHelperType);

  //now I am in strongly-typed world again
  var sendAction=makeDelegateHelper.MakeSendAction();

这是帮助器对象的定义，它能够通过更少的反射调用而摆脱困境。

public abstract class MakeDelegateHelper {
  public abstract Action<object> MakeSendAction();
}

public class MakeDelegateHelper<TClient,TNotice> : MakeDelegateHelper where TClient : new() {
  public override Action<object> MakeSendAction() {
    var sendMethod = typeof(TClient).GetMethod("Send", new[] { typeof(TNotice) });

    var client=new TClient();
    var action=(Action<TNotice>)Delegate.CreateDelegate(typeof(Action<TNotice>), client, sendMethod);
    return o => action((TNotice)o);
  }
}