我可以使用具体方法订阅通用 Action 吗？

如何解决我可以使用具体方法订阅通用 Action 吗？

See Enigmativity's answer for a much clearer phrasing of this question.

---

我有一个通用的 Action 正在注册，然后转换为我期望的类型：

public interface IMyInterface { }

public static Action<IMyInterface> MyAction;

public class MyClass : IMyInterface { }

public void Subscribe()
{
    MyAction<MyClass> += MyMethod;
}

public void MyMethod(IMyInterface myInterface)
{
    var myClass = (MyClass)myInterface;
}

但我希望能够使用已经指定类型的方法进行订阅，这样我就可以避免额外的转换步骤。是否可以只订阅 MyActions 以便 IMyInterface 具有特定类型？所以 MyMethod 可以是这样的：

public void MyMethod(MyClass myClass)
{

}

我尝试这样做的原因是我正在编写一个使用特定类型的消息传递系统。我正在使用泛型来确定要订阅哪些消息。我认为这部分不会影响我的问题，但看起来像这样：

private Dictionary<Type,List<Action<IMessage>> subscribers = new Dictionary<Type,List<Action<IMessage>>();

public void SubscribeMessage<TMessage>(Action<IMessage> callback)
    where TMessage : IMessage
{
    var type = typeof(TMessage);
    if (subscribers.ContainsKey(type))
    {
        if (!subscribers[type].Contains(callback))
        {
            subscribers[type].Add(callback);
        }
        else
        {
            LogManager.LogError($"Failed to subscribe to {type} with {callback},because it is already subscribed!");
        }
    }
    else
    {
        subscribers.Add(type,new List<Action<IMessage>>());
        subscribers[type].Add(callback);
    }
}

public void UnsubscribeMessage<TMessage>(Action<IMessage> callback)
    where TMessage : IMessage
{
    var type = typeof(TMessage);
    if (subscribers.ContainsKey(type))
    {
        if (subscribers[type].Contains(callback))
        {
            subscribers[type].Remove(callback);
        }
        else
        {
            LogManager.LogError($"Failed to unsubscribe from {type} with {callback},because there is no subscription of that type ({type})!");
        }
    }
    else
    {
        LogManager.LogError($"Failed to unsubscribe from {type} with {callback},because there is no subscription of that type ({type})!");
    }
}

//The use case given MyClass implements IMessage
public void Subscribe()
{
    SubscribeMessage<MyClass>(MyMethod);
}

public void MyMethod(IMessage myMessage)
{
    var myClass = (MyClass)myMessage;
}

那么我可以使用具有具体类型的方法订阅泛型 Action 吗？

解决方法

您问题中的类型似乎有点乱 - 问题顶部为 IMyInterface，底部为 IMessage。我假设了这些接口和基本方法：

public interface IMessage { }

public class MyClass1 : IMessage { }
public class MyClass2 : IMessage { }

public void MyMethod1(MyClass1 myClass1)
{
    Console.WriteLine("MyMethod1");
}

public void MyMethod2(MyClass2 myClass1)
{
    Console.WriteLine("MyMethod2");
}

现在，我进一步简化了您的代码，使其没有 SubscribeMessage 和 UnsubscribeMessage 方法，因为这将迫使您维护对原始委托的引用以删除委托。使用返回 Subscribe 的单个 IDisposable 方法更容易让您取消订阅。与许多不同类型的代表相比，持有一堆一次性用品要容易得多 - 否则就是“从煎锅中进入火中”之类的事情。

这是您需要的所有 Subscribe：

private Dictionary<Type,List<Delegate>> _subscribers = new Dictionary<Type,List<Delegate>>();

public IDisposable Subscribe<TMessage>(Action<TMessage> callback) where TMessage : IMessage
{
    var type = typeof(TMessage);
    if (!_subscribers.ContainsKey(type))
    {
        _subscribers.Add(type,new List<Delegate>());
    }
    _subscribers[type].Add(callback);
    return new ActionDisposable(() => _subscribers[type].Remove(callback));
}

我已不再需要检查重复项。这应该是调用代码的责任。在某些情况下，两次调用委托可能是有效的。把它留给调用代码，以确保它是一个明智的选择。

我还使用了 List<Delegate>，因为它可以存储任何委托类型。

这是您需要的 ActionDisposable 类：

public sealed class ActionDisposable : IDisposable
{
    private readonly Action _action;
    private int _disposed;

    public ActionDisposable(Action action)
    {
        _action = action;
    }

    public void Dispose()
    {
        if (Interlocked.Exchange(ref _disposed,1) == 0)
        {
            _action();
        }
    }
}

现在是Send：

public void Send<TMessage>(TMessage message) where TMessage : IMessage
{
    var type = typeof(TMessage);
    if (_subscribers.ContainsKey(type))
    {
        var subscriptions = _subscribers[type].Cast<Action<TMessage>>().ToArray();
        foreach (var subscription in subscriptions)
        {
            subscription(message);
        }
    }
}

所以要调用所有这些代码，你可以这样做：

IDisposable subscription1 = Subscribe<MyClass1>(MyMethod1);
IDisposable subscription2 = Subscribe<MyClass2>(MyMethod2);

Send(new MyClass1());
Send(new MyClass2());

subscription1.Dispose();

Send(new MyClass1());
Send(new MyClass2());

我得到的结果是：

MyMethod1
MyMethod2
MyMethod2

它显然是订阅和取消订阅，并且它只是为传递的消息类型调用委托。我认为这掩盖了您正在尝试做的事情。