Recently I extended a previous blog post and published it on Code Project under the title Generic WCF Service Host and Client. An astute reader asked about calling a service method asynchronously, something I had not given much thought.
I decided that I wanted a way to support asynchronous calls on the generic WCF client without having to modify my service contract (interface) or implementation class libraries. I also wanted a way to do asynchronous calls with as little client code as possible, which meant support for a simple event based solution.
So I went to work experimenting. If you want the WCF version of the solution, visit the Code Project article and you can get the updated code there just as soon as I get an update published.
In this post, I'll present a more generalized version of the solution I created. The GenericAsyncWrapper<T> class is the heart of the solution. Take any instance of T (any class) and GenericAsyncWrapper<T> puts an event based asynchronous wrapper that allows you to call any method on the instance asynchronously.
I'm not going to explain how standard delegates are used to make asynchronous calls. If you want to brush up on the basics, check out Microsoft's How to call a Visual C# method asynchronously along with thousands of other online resources. I will show some examples of using standard generic delegates to do the asynchronous calls to compare with the use of the generic wrapper's event model.
Here's my test class. It does nothing, as you can see, but it does allow me to test my wrapper.
internal class MyTestClass
{
public void DoNothingNoParams()
{
Console.WriteLine("MyTestClass.DoNothingNoParams called on thread: {0}",
Thread.CurrentThread.ManagedThreadId);
}
public string DoSomething(string input)
{
Console.WriteLine("MyTestClass.DoSomething called on thread: {0}",
Thread.CurrentThread.ManagedThreadId);
return "Output of DoSomething with " + input + " as input.";
}
}
And here's the test code. Just a simple console app that first shows the test class being called directly, then using standard generic delegates and finally using the wrapper. One advantage you may note is that with the wrapper, you also get all your original input params back.
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Main called on thread: {0}", Thread.CurrentThread.ManagedThreadId);
Console.WriteLine("+++++++++++++++++++++++++++++++++++++++++++++");
Console.WriteLine("synchronous calls");
var mytest = new MyTestClass();
mytest.DoNothingNoParams();
string output = mytest.DoSomething("my name is Tyler");
Console.WriteLine(output);
Console.WriteLine("+++++++++++++++++++++++++++++++++++++++++++++");
Console.WriteLine("Action<> and Func<> delgate calls");
Action action = new Action(mytest.DoNothingNoParams);
action.BeginInvoke(new AsyncCallback(ActionCallback), "test1");
Func<string, string> func = new Func<string, string>(mytest.DoSomething);
func.BeginInvoke("my name is Arnold", new AsyncCallback(FuncTTCallback), "test2");
Thread.Sleep(1000);
Console.WriteLine("+++++++++++++++++++++++++++++++++++++++++++++");
Console.WriteLine("asynchronous wrapper calls");
var wrapper = new GenericAsyncWrapper<MyTestClass>(mytest);
wrapper.AsyncCompleted += new EventHandler<GenericAsyncWrapperCompletedEventArgs>(wrapper_AsyncCompleted);
wrapper.AsyncInvoke("DoSomething", "test2", "my name is Bob");
wrapper.AsyncInvoke("DoNothingNoParams", "test1", null);
Console.ReadLine();
}
static void FuncTTCallback(IAsyncResult result)
{
Console.WriteLine("FuncTTCallback called on thread: {0}", Thread.CurrentThread.ManagedThreadId);
Thread.Sleep(250);
Func<object, object> deleg = ((AsyncResult)result).AsyncDelegate as Func<object, object>;
if (deleg != null)
{
object returnValue = deleg.EndInvoke(result);
Console.WriteLine("FuncTTCallback return value: {0}", returnValue);
}
}
static void ActionCallback(IAsyncResult result)
{
Console.WriteLine("ActionCallback called on thread: {0}", Thread.CurrentThread.ManagedThreadId);
Thread.Sleep(250);
Action deleg = ((AsyncResult)result).AsyncDelegate as Action;
if (deleg != null)
{
deleg.EndInvoke(result);
}
}
static void wrapper_AsyncCompleted(object sender, GenericAsyncWrapperCompletedEventArgs e)
{
Console.WriteLine("wrapper_AsyncCompleted called on thread: {0}", Thread.CurrentThread.ManagedThreadId);
if (e.Error == null)
{
Console.WriteLine("methodName: {0}, userState: {1}, result: {2}",
e.MethodName, e.UserState, e.Result);
if (e.InValues != null)
{
for (int i = 0; i < e.InValues.Length; i++)
{
Console.WriteLine(" value[{0}] = {1}", i, e.InValues[i]);
}
}
}
else
{
Console.WriteLine(e.Error.ToString());
}
}
}
Now here's the real magic. The GenericAsyncWrapper<T> class and its attendant event args class.
public class GenericAsyncWrapper<T> where T : class
{
private T _instance;
public GenericAsyncWrapper(T instance)
{
if (instance == null) throw new NullReferenceException("instance cannot be null");
_instance = instance;
}
public T Instance { get { return _instance; } }
public event EventHandler<GenericAsyncWrapperCompletedEventArgs> AsyncCompleted;
public void AsyncInvoke(string methodName, object userState, params object[] inValues)
{
if (string.IsNullOrEmpty(methodName)) throw new NullReferenceException("methodName cannot be null");
MethodInfo mi = this.Instance.GetType().GetMethod(methodName);
if (null != mi)
{
Func<MethodInfo, object[], object> func = new Func<MethodInfo, object[], object>(this.ExecuteAsyncMethod);
func.BeginInvoke(mi, inValues, new AsyncCallback(this.FuncCallback),
new GenericAsyncState() { UserState = userState, MethodName = methodName, InValues = inValues });
}
else
throw new TargetException(string.Format("methodName {0} not found on instance", methodName));
}
private object ExecuteAsyncMethod(MethodInfo mi, object[] inValues)
{
return mi.Invoke(this.Instance, inValues);
}
private void FuncCallback(IAsyncResult result)
{
var deleg = (Func<MethodInfo, object[], object>)((AsyncResult)result).AsyncDelegate;
var state = result.AsyncState as GenericAsyncState;
if (null != deleg)
{
Exception error = null;
object retval = null;
try
{
retval = deleg.EndInvoke(result);
}
catch (Exception e)
{
error = e;
}
object userState = state == null ? null : state.UserState;
string methodName = state == null ? (string)null : state.MethodName;
object[] inValues = state == null ? null : state.InValues;
GenericAsyncWrapperCompletedEventArgs args = new GenericAsyncWrapperCompletedEventArgs(retval, error, methodName, userState, inValues);
if (this.AsyncCompleted != null)
this.AsyncCompleted(this, args);
}
}
private class GenericAsyncState
{
public object UserState { get; set; }
public string MethodName { get; set; }
public object[] InValues { get; set; }
}
}
public class GenericAsyncWrapperCompletedEventArgs : EventArgs
{
public GenericAsyncWrapperCompletedEventArgs(object result, Exception error, string methodName, object userState, object[] inValues)
{
this.Result = result;
this.Error = error;
this.MethodName = methodName;
this.UserState = userState;
this.InValues = inValues;
}
public object Result { get; private set; }
public Exception Error { get; private set; }
public string MethodName { get; private set; }
public object UserState { get; private set; }
public object[] InValues { get; private set; }
}
You can download the code here GenericUtils.zip (7.33 KB). If you find it useful, I'd love to hear from you. If you think this was a total waste of time, turn the TV back on.