在接口中使用泛型时无法转换/匹配类型，为什么？ [复制]

Question

在 IMyMessage.cs 中

public interface IMyMessage
{
}

在 IMyMessageReceiver.cs 中

public interface IMyMessageReceiver<T> where T: IMyMessage
{
    void HandleMessage(T message);
    void Subscribe();
}

在 MyMessagePublisher.cs 中

public static class MyMessagePublisher
{
    private static Dictionary<Type, List<IMyMessageReceiver<IMyMessage>>> _subscribers;

    static MyMessagePublisher
    {
         _subscribers = new Dictionary<Type, List<IMyMessageReceiver<IMyMessage>>>();
    }

    public static function Subscribe<T>(IMyMessageReceiver<T> receiver) where T: IMyMessage
    {
        Type messageType = typeof (T);
        List<IMyMessageReceiver<IMyMessage>> listeners;

        if(!_subscribers.TryGetValue(messageType, out listeners))
        {
             // no list found, so create it
             List<IMyMessageReceiver<T>> newListeners = new List<IMyMessageReceiver<T>>();
             // ERROR HERE: Can't convert List<IMyMessageReceiver<T>> to List<IMyMessageReceiver<IMyMessage>>
             _subscribers.add(messageType, newListeners);

        }

        //  I would then find the right list and add the receiver it to it but haven't got this far
    }
}

所以我希望使用一堆“IMyMessages”和“IMyMessageReceivers”来传递消息。我之前做了一个硬编码的方法，但厌倦了 100 个不同的发布/订阅函数名称，所以我想我应该用泛型很好地包装它。

我的问题是使用泛型时我无法让代码工作。即使我指定 T 类型是 IMyMessage，我也不能在任何需要 IMyMessage 的地方使用 T。也许我只是习惯于基础/扩展类，因为它在那里可以正常工作。我尝试了各种方法，从铸造到真正通用，但我总是遇到同样的问题。

Answer 1

好的，这就是我如何看待它的工作方式。由于您尝试以不受支持的方式使用协方差，因此您需要避免在某些地方使用泛型。但这样做不会失去任何类型安全性。

创建一个非泛型IMessageReceiver接口，让不能使用泛型参数的类型可以改用这个：

public interface IMyMessageReceiver
{
    void HandleMessage(IMyMessage message);

    void Subscribe();
}

public interface IMyMessageReceiver<in T> : IMyMessageReceiver
    where T : IMyMessage
{
    void HandleMessage(T message);
}

如果您愿意，可以创建一个基类来简化事情：

public abstract class MyMessageReceiverBase<T> : IMyMessageReceiver<T>
    where T : IMyMessage
{
    public abstract void HandleMessage(T message);

    public void HandleMessage(IMyMessage message)
    {
        if (!(message is T))
            throw new InvalidOperationException();
        HandleMessage((T)message);
    }

    public abstract void Subscribe();
}

然后您可以更改 IMyMessageListeners 以使用非泛型版本，因为它实际上并不需要泛型类型：

public interface IMyMessageListeners
{
    void Add(IMyMessageReceiver receiver);

    // I added this since I think this is how you're going to use it
    void Send(IMyMessage message);
}

这个类的具体是这样的：

public class MyMessageListeners : IMyMessageListeners
{
    readonly List<IMyMessageReceiver> _list = new List<IMyMessageReceiver>();

    public void Add(IMyMessageReceiver receiver)
    {
        _list.Add(receiver);
    }

    public void Send(IMyMessage message)
    {
        foreach (var listener in _list)
            listener.HandleMessage(message);
    }
}

然后（最终），您的静态类将如下所示：

public static class MyMessagePublisher
{
    static readonly Dictionary<Type, IMyMessageListeners> _subscribers = new Dictionary<Type, IMyMessageListeners>();

    // I added this too, since I think this is how you intend to use it
    public static void Publish<T>(T message) where T : IMyMessage
    {
        Type messageType = typeof(T);
        IMyMessageListeners listeners;

        if (_subscribers.TryGetValue(messageType, out listeners))
            listeners.Send(message);
    }

    public static void Subscribe<T>(IMyMessageReceiver<T> receiver) where T : IMyMessage
    {
        Type messageType = typeof(T);
        IMyMessageListeners listeners;

        if (!_subscribers.TryGetValue(messageType, out listeners))
        {
            // no list found, so create it
            listeners = new MyMessageListeners();
            _subscribers.Add(messageType, listeners);
        }

        listeners.Add(receiver);
    }
}

你可以像这样使用你的静态类：

MyMessagePublisher.Subscribe(new FooMessageReceiver());
MyMessagePublisher.Publish(new FooMessage());

Answer 2

泛型不支持协方差。因此，即使 T 实现了 IMyMessage，也无法将 IMyMessageReceiver T 强制转换为 IMyMessageReceiver IMyMessage。这就是你得到错误的原因。

我认为您不应该在 IMyMessageReceiver 接口中使用泛型。我不确定您要达到的目标，但也许这样的事情可以解决问题：

public interface IMyMessageReceiver
{
    void HandleMessage(IMyMessage message);
    void Subscribe();
}

public class MyMessageReceiver<T> : IMyMessageReceiver where T: IMyMessage
{
    void IMyMessageReceiver.HandleMessage(IMyMessage message)
    {
        HandleMessage(message as T);
    }

    public void HandleMessage(T message) {...}
    public void Subscribe() {...}
}

Answer 3

鉴于您知道类型将始终为 IMyMessageReceiver<T>，您可以通过将所有内容存储为对象并强制转换来模拟行为：

private static Dictionary<Type, List<object>> _subscribers;


    public static function Subscribe<T>(IMyMessageReceiver<T> receiver) where T: IMyMessage
    {
      Type messageType = typeof (T);
      List<object> listeners;

      if(!_subscribers.TryGetValue(messageType, out listeners))
      {
        // no list found, so create it
        List<object> newListeners = new List<object>();
        newListeners.Add(receiver)
        _subscribers.add(messageType, newListeners);

      }

      var messageReceivers = listeners.Cast<IMyMessageReceiver<T>>();
}

既然您知道字典中的列表将始终属于给定类型，您可以放心地转换它们！

Answer 4

在这种情况下KeyedByTypeCollection<T> 是合适的：

public interface IMyMessage
{
}

public interface IMyMessageReceiver<T> where T : IMyMessage
{
    void HandleMessage(T message);
    void Subscribe();
}

public static class MyMessagePublisher
{
    private static readonly KeyedByTypeCollection<IList> Subscribers;

    static MyMessagePublisher()
    {
        Subscribers = new KeyedByTypeCollection<IList>();
    }

    public static void Subscribe<T>(IMyMessageReceiver<T> receiver) where T : IMyMessage
    {
        List<IMyMessageReceiver<T>> listeners = Subscribers.Find<List<IMyMessageReceiver<T>>>();

        if (listeners == null)
        {
            listeners = new List<IMyMessageReceiver<T>>();
            Subscribers.Add(listeners);
        }

        // Now you can use the listeners list

        listeners.Add(receiver);
    }
}