Bdtjtk

What I have is a asynchronous request/response model, when the response is received I want to run an action.

A small code sample of what I'd like to accomplish:

class Program {

    static void Main(string args) {

        //Make a request and show 'hello world' when the response was received

        Connection.Request<MyResponse>("key", (MyResponse) => {

            Console.WriteLine(MyResponse.Value);

        });



        //set the response making the action write "hello world"

        Connection.SetResponse("key", new MyResponse("hello world"));

    }

}



public class Connection {

    static Dictionary<string, Action<BaseResponse>> _dicActions = new Dictionary<string, Action<BaseResponse>>();

    public static void Request<T>(string key, Action<T> action) where T : BaseResponse {

        _dicActions.Add(key, action);

    }



    public static void SetResponse(string key, BaseResponse pResponse) {

        _dicActions[key](pResponse);

    }

}



public class BaseResponse { }

public class MyResponse : BaseResponse {

    public string Value;

    public MyResponse(string pValue) {

        Value = pValue;

    }

}

Of course in the sample above the _dicActions.Add doesn't work.
How could I make the below code work?, for some reason haven't been able to figure it out.

To do this properly you really have to ensure that the dictionary is type-safe. This is simple to do. Just change the dictionary from Dictionary<string, Action<BaseResponse>> to Dictionary<string, Dictionary<Type, Delegate>> and then implement Connection like this:

public class Connection

{

    static Dictionary<string, Dictionary<Type, Delegate>> _dicActions = new Dictionary<string, Dictionary<Type, Delegate>>();

    public static void Request<T>(string key, Action<T> action) where T : BaseResponse

    {

        if (!_dicActions.ContainsKey(key))

        {

            _dicActions.Add(key, new Dictionary<Type, Delegate>());

        }

        _dicActions[key].Add(typeof(T), action);

    }



    public static void SetResponse<T>(string key, T pResponse) where T : BaseResponse

    {

        ((Action<T>)_dicActions[key][typeof(T)])(pResponse);

    }

}

That works with your existing code like a treat and it ensures that you don't mismatch your key and your T when calling SetResponse.

Why don't you use Action<BaseResponse> directly?

public static void Request<T>(string key, Action<BaseResponse> action) where T : BaseResponse

Or you can make the class generic:

public static void Main()

{

    //Make a request and show 'hello world' when the response was received

    Connection<MyResponse>.Request("key", (MyResponse) => {

        Console.WriteLine(MyResponse.Value);

    });



    //set the response making the action write "hello world"

    Connection<MyResponse>.SetResponse("key", new MyResponse("hello world"));

}



public class Connection<T> where T: BaseResponse

{

    static Dictionary<string, Action<T>> _dicActions = new Dictionary<string, Action<T>>();

    public static void Request(string key, Action<T> action)

    {

        _dicActions.Add(key, action);

    }



    public static void SetResponse(string key, T pResponse)

    {

        _dicActions[key](pResponse);

    }

}

If you just want to make a smaller change in your code, you can convert the action like this:

_dicActions.Add(key, o => action((T)o));