将通用类型转换为其基本类型，反之亦然

Question

Can someone help me with the conversion I am facing in enclosed code ... I commented the lines of code, where I am having problem. Is this even the right way to achieve this ... what I am trying to do, is forward responses of specified type to provided callback.

EDIT 1

I forgot to mention that Response and AFResponse are abstract classes, which goes: >Response -> AFResponse -> concrete implementations of AF layer messages

public class MessageBinder
{
    private class Subscriber<T> : IEquatable<Subscriber<T>> where T : Response
    {
        ...
    }

    private readonly Dictionary<Type, List<Subscriber<Response>>> bindings;

    public MessageBinder()
    {
        this.bindings = new Dictionary<Type, List<Subscriber<Response>>>();
    }

    public void Bind<TResponse>(short shortAddress, Action<ZigbeeAsyncResponse<TResponse>> callback)
        where TResponse : Response
    {
        List<Subscriber<TResponse>> subscribers = this.GetSubscribers<TResponse>();
        if (subscribers != null)
        {
            subscribers.Add(new Subscriber<TResponse>(shortAddress, callback));
        }
        else
        {
            var subscriber = new Subscriber<TResponse>(shortAddress, callback);

            // ERROR: cannot convert from 'List<Subscriber<TResponse>>' to 'List<Subscriber<Response>>' ... tried LINQ Cast operator - does not work either
            this.bindings.Add(typeof(TResponse), new List<Subscriber<TResponse>> { subscriber });
        }
    }

    public void Forward<TResponse>(TResponse response)
        where TResponse : Response
    {
        var subscribers = this.GetSubscribers<TResponse>();
        if (subscribers != null)
        {
            Subscriber<TResponse> subscriber;
            Type responseType = typeof (TResponse);

            if (responseType.IsSubclassOf(typeof (AFResponse)))
            {
                // ERROR: Cannot convert type 'TResponse' to 'AFResponse' ... tried cast to object first, works, but is this the right way?
                var afResponse = (AFResponse)response;
                subscriber = subscribers.SingleOrDefault(s => s.ShortAddress == afResponse.ShortAddress);
            }
            else
            {
                subscriber = subscribers.First();
            }

            if (subscriber != null)
            {
                subscriber.Forward(response);
            }
        }
    }

    private List<Subscriber<TResponse>> GetSubscribers<TResponse>() where TResponse : Response
    {
        List<Subscriber<Response>> subscribers;
        this.bindings.TryGetValue(typeof(TResponse), out subscribers);

        // ERROR: How can I cast List<Subscriber<Response>> to List<Subscriber<TResponse>>?
        return subscribers;
    }
}

Thank you for any help :)

EDIT 2

I changed the code according to @Bojan answer, and it is working. But I am curious, why the Dictionary can't hold the base class of all Response messages? Is there even a way to accomplish that, or did I just tried to push my head through a wall?

EDIT 3

Now I am facing another problem ... when message arrive, it is composed of byte array, >which goes to message factory which resolves and builds it:

public static T Build<T>(Packet packet) where T : Response
{
    Type resolvedType;
    if (!dependencyMap.TryGetValue(packet.MessageId, out resolvedType))
    {
        var str = String.Format("Could not resolve message. Message info: CMD0: {0}, CMD1: {1}, MessageID: {2}",
                                packet.Cmd0, packet.Cmd1, packet.MessageId);
        Debug.WriteLine(str);

        throw new MessageNotFoundException(str);
    }

    ConstructorInfo firstConstructor = resolvedType.GetConstructors().First();

    return (T) firstConstructor.Invoke(new object[] {packet});
}

Then an OnAsyncResponseReceived(Response response) event handler is invoked, which then forwards message to the subscriber of this message, if any. The problem is now that if I subscribe to (sub layer of response are: AFResponse, SystemResponse, etc...) SystemResetResponse which is subclass of SystemResponse which is subclass of Response, that I must cast that response from Response(base) type all the way to the concrete type, which is SystemResetResponse in order the Forwarder in MessageBinder can find subscribers of this message type, and forwards it.

There are many types and casting by hand would be an overkill ... is there a way around this, or even a better way to design this type of system?

EDIT 4

I changed a code like this ... is this the right way to do this, is there any other, better way and over all, am I trying to solve the problem the right way or is there better way to handle this?

private void OnAsyncResponseReceived(Response response)
{
    dynamic resolvedResponse = Convert.ChangeType(response, response.GetType());
    messageBinder.Forward(resolvedResponse);
}

Answer 1

You need to cast each item in subscribers list to Subscriber<TResponse> . Something like this always works for me -

private List<T> get<T>()
    {
        List<IEntity> list = new List<IEntity>();
        List<T> genericList = new List<T>();
        foreach (var item in list)
        {
            genericList.Add((T)item);
        }
        return genericList;
    }

Hope it helps!!

Answer 2

As well as the answer already provided, the following lines of code...

    Type responseType = typeof (TResponse);
    if (responseType.IsSubclassOf(typeof (AFResponse)))

Could be replaced with either:

    if (response is AFResponse)

or (better)

    AFResponse af = response as AFResponse;
    if (af != null)

EDIT Updated the code because I didn't realise beforehand that TResponse was a generic. Are you also aware that IsSubclassOf returns false if its a matching type?

Answer 3

Part of your problem is that you are trying to declare your dictionary as having generic subscribers ( List<Subscriber<Response>> ), while expecting each entry to be of an unrelated type ( List<Subscriber<TResponse>> ). A solution would be to hide the actual type behind object or IList :

private readonly Dictionary<Type, object> bindings;

private List<Subscriber<TResponse>> GetSubscribers<TResponse>() 
    where TResponse : Response
{
    object subscribers;
    bindings.TryGetValue(typeof(TResponse), out subscribers);

    return (List<Subscriber<TResponse>>)subscribers;
}

Your Forward method can check for AFResponse and subclasses in a bit easier way, but the cast will have to go through object :

public void Forward<TResponse>(TResponse response)
    where TResponse : Response
{
    var subscribers = GetSubscribers<TResponse>();
    if (subscribers != null)
    {
        Subscriber<TResponse> subscriber;

        var afResponse = response as AFResponse;
        if (afResponse != null)
        {
            subscriber = subscribers.SingleOrDefault(s => s.ShortAddress == afResponse.ShortAddress);
        }
        else
        {
            subscriber = subscribers.First();
        }

        if (subscriber != null)
        {
            subscriber.Forward(response);
        }
    }
}

UPDATE

You did not declare your dictionary to hold "base class of all messages". Even though Response is the base class of all responses, Subscriber<Response> and Subscriber<T> are unrelated types. It is somewhat analogous to how List<int> and List<string> are not related, even though both string and int inherit from object .

What you are looking for is called covariance and is only supported by some interfaces.

For example, if you had:

interface ISubscriber<out T> where T:Response
{}

class Subscriber<T> : ISubscriber<T> where T:Response
{}

You could do:

ISubscriber<Response> s = new Subscriber<AFResponse>();

However, List<ISubscriber<Response>> and List<ISubscriber<AFResponse>> would still be unrelated types.