Question

I need to call a method that accepts an interface as a parameter. The object I am using as a parameter implements the inteface however I still get a compile error. What am I doing wrong?

public class ViewModel 
{
    public ViewModel()
    {
        QueueManager<CFMessage<CFQueueItem>, CFQueueItem> q = new QueueManager<CFMessage<CFQueueItem>, CFQueueItem>();
        DoSomething(q);     // This line does not compile:  Cannot convert from QueueManager<CFQueueItem> to QueueManager<IQueueItem>
    }

    public void DoSomething(QueueManager<IQueueMessage<IQueueItem>, IQueueItem> queueManager)
    {

    }
}

public interface IQueueMessage<T> where T : IQueueItem
{
    int ID { get; set; }
}

public interface IQueueItem
{
    int ID { get; set; }
}

public class CFMessage<CFQueueItem> : IQueueMessage<CFQueueItem> where CFQueueItem : IQueueItem
{
    public int ID { get; set; }
}

public class CFQueueItem : IQueueItem
{
    public int ID { get; set; }
}

public class QueueManager<T, Q>
    where T : IQueueMessage<Q>
    where Q : IQueueItem
{

}

Answer 1

You can work around by using concept covariance, define interface IQueueMessage as covariant, using keyword out:

public interface IQueueMessage<out T> where T : IQueueItem
{
}

Then create new covariant interface IQueueManager for QueueManager:

public interface IQueueManager<out T, out Q> where T : IQueueMessage<Q>
                                             where Q : IQueueItem
{
}

public class QueueManager<T, Q> : IQueueManager<T, Q>
    where T : IQueueMessage<Q>
    where Q : IQueueItem
{

}

Then you can use this interface for method DoSomething:

public void DoSomething(IQueueManager<IQueueMessage<IQueueItem>, IQueueItem> queueManager)
{
}

Your code will compile successfully:

public ViewModel()
{
    var q = new QueueManager<CFMessage<CFQueueItem>, CFQueueItem>();
    DoSomething(q);
}