在协变类型的接口中使用具有协变类型的接口作为方法的返回类型

Question

I need to create a factory which produces message builders and message senders. I've got three interfaces:

public interface IMessageFactory<out T> where T : GenericMessage
{
    IMessageBuilder<T> CreateBuilder();
    IMessageSender<T> CreateSender();
}

public interface IMessageBuilder<out T>
{
    T Build(EmailMessage message);
    T Build(EmailTask task);
}

public interface IMessageSender<in T>
{
    void Send(T message);
}

Problem is that IMessageFactory won't compile as compiler says that

Invalid variance: The type parameter 'T' must be contravariantly valid on 'IMessageFactory<T>.CreateSender()'. 'T' is covariant.

If I make T covariant in IMessageSender, I cannot use it as a type of a method argument.

And I need T to be covariant in IMessageFactory in order to do something like:

    public IMessageFactory<GenericMessage> CreateMessageFactory(DispatchService dispatchService)
    {
        if (dispatchService == DispatchService.Service1)
        {
            return new Service1MessageFactory();
        }
        else if (dispatchService == DispatchService.Service2)
        {
            return new Service2MessageFactory();
        }

        return null;
    }

where

public class Service1MessageFactory : IMessageFactory<Message<Service1Message>>
{
}

public class Service2MessageFactory : IMessageFactory<Message<Service2Message>>
{
}

public class Message<T> : GenericMessage
{
    public T SpecificMessage { get; private set; }

    public string UserLogin { get; set; }

    public Message(T message, string userLogin)
    {
        SpecificMessage = message;
    }
}

I've reached a deadlock. Any ideas?

UPD.

Probably I'm doing everything wrong, so I'll just describe what I basically need, and maybe you can give me some hints about how can I achieve it.

So, I need:

1. to be able to create builders and senders for messages of different types
2. to have factories that will create builders and senders for each message type
3. to have factory method that will create factory according to a parameter passed to it

Answer 1

Any ideas?

Make IMessageFactory<T> non-variant. Problem solved.

The system you've got right now is not type safe, which is why it is not legal. Do you see why it is not type safe? Suppose you have an implementation of IMessageFactory<Tiger> which has a method CreateSender that returns an IMessageSender<Tiger> . You can then call Send(new Tiger()) and all is good.

If you can then convert the original IMessageFactory<Tiger> to IMessageFactory<Animal> -- because it is covariant -- then you can get an IMessageSender<Animal> out of it, and you can then call Send(new Octopus()) but the underlying implementation remember only takes tigers .

The compiler knows that this can happen and therefore prevents you from compiling your program in the first place.