Sliverlight调用Rest服务的一点思考和实践

最近在写一个SL的小工具，用于图形化编辑一些东西。刚好调用的服务是WCF的Rest方式，于是就碰到了在SL里面直接调用Rest服务的问题，本来Rest服务就是只要有url和内容就可以直接调用的，事实上如果搜索该主题，也可以得到漫山遍野的WebClient方案。不过看看Framework下的WebChannelFactory<TChannel>这个类（这个类型在SL下面不支持...），又感觉用WebClient方式太寒酸了点。。。

这里讨论的前提是：

已经有Rest服务的契约
不想自己去拼请求

期望的结果应该是类似与调用WebService的方式。

然后，就慢慢开始达成我们的目标吧。

第一步，Copy契约。。。废话，而且只要会按Ctrl+C和Ctrl+V的人都会做，问题是Copy过来的契约不能直接用，SL没提供这样的类，为了方便示例，就准备一个Sample契约：

    [ServiceContract]
    public interface ISample
    {
        [WebInvoke(UriTemplate = "/echo/?name={name}",
            BodyStyle = WebMessageBodyStyle.Bare, RequestFormat = WebMessageFormat.Json, ResponseFormat = WebMessageFormat.Json)]
        [OperationContract]
        EchoResponse Echo(string name, string message);
    }
    [DataContract]
    public class EchoResponse
    {
        [DataMember]
        public string Name { get; set; }
        [DataMember]
        public string Message { get; set; }
    }

第二步，实现契约，等等，这里是客户端怎么冒出来个实现契约了？这里实现契约，实际上是指做一个代理类，只不过平时WebService的时候是自动生成代理类的，而Rest服务没有生成代理类的手段，只能人工做了。。。

当然，立即想到的是，代理类底层一定是调用WebClient，毕竟服务是Rest方式提供的，问题是形式，如果全部人工翻译，这个代价有点大，更重要的是：我很懒，能只写一次的代码，绝不写两次，有任何共性的代码结构+无限可能的类型组合，都倾向于使用代码生成来实现。

代理类代码准备

首先，准备好基本的代码：

基础工作

    public class RestClient<T>
        where T : class
    {

        private static readonly Type s_proxyType = CreateProxyType();
        private readonly T m_proxy;

        public RestClient(string baseUrl)
        {
            m_proxy = Activator.CreateInstance(s_proxyType, baseUrl) as T;
        }

        private static Type CreateProxyType()
        {
            // todo : 生成代理类型
            return null;
        }

        public T Channel { get { return m_proxy; } }

这里的T需要是契约类型，也就是示例中的ISample，泛型约束不给力，不能约束到T必须是接口，只能退而求其次，约束必须是引用类型（接口类型一定是引用类型，如果想到了值类型可以实现接口，那是因为值类型的装箱形式实现了接口，值类型的装箱形式也是引用类型）

那为什么要给一个BaseUri哪？别忘了，契约接口里面的（例如：ISample）只提供了相对地址，没有基地址的话，根本找不到终结点。

然后，开始添加类型生成代码：

创建类型-part-1

        private static Type CreateProxyType()
        {
            if (!typeof(T).IsInterface)
                throw new NotSupportedException();
            if (!Attribute.IsDefined(typeof(T), typeof(ServiceContractAttribute)))
                throw new NotSupportedException();
            var interfaces = Enumerable.Repeat(typeof(T), 1).Concat(typeof(T).GetInterfaces()).ToArray();
            return CreateProxyType(interfaces);
        }

        private static Type CreateProxyType(Type[] interfaces)
        {
            var assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName("^_^." + typeof(T).FullName), AssemblyBuilderAccess.Run);
            var module = assembly.DefineDynamicModule("^_^");
            var tb = module.DefineType("$_$." + typeof(T).FullName, TypeAttributes.Public | TypeAttributes.Class, typeof(object), interfaces);
            var field = tb.DefineField("f", typeof(string), FieldAttributes.Private | FieldAttributes.InitOnly);
            CreateProxyCtor(tb, field);
            int methodCount = 0;
            foreach (var i in interfaces)
                foreach (var m in i.GetMethods(BindingFlags.Public | BindingFlags.Instance))
                    CreateProxyMethod(tb, m, field, ref methodCount);
            return tb.CreateType();

这里正好可以把泛型约束的遗憾给不上，还可以变本加厉的要求接口上必须标注了ServiceContract，不满足要求的也泛型过来的话，直接给个不支持（对了别忘了接口是可以多继承的，所以实现的时候要实现全部接口，别只实现其中的一两个哦）

现在，问题变成了如何生成这么一个类型来实现这一个或多个接口，不过，这个问题先放一下，考虑一下，如果已经提取到了地址和Method，以及可能有的Post内容，如何获得返回值哪？问题的解决方案晚上到处都有——用WebClient，先把这个实现了吧（这里仅仅实现Json的）：

对WebClient的封装

        public static TResp PostJson<TReq, TResp>(string baseUri, string uri, string method, TReq data)
        {
            string req;
            {
                DataContractJsonSerializer jsonSerializer = new DataContractJsonSerializer(typeof(TReq));
                var ms = new MemoryStream();
                jsonSerializer.WriteObject(ms, data);
                ms.Seek(0L, SeekOrigin.Begin);
                req = new StreamReader(ms).ReadToEnd();
            }
            ManualResetEvent mre = new ManualResetEvent(false);
            UploadStringCompletedEventArgs acArgs = null;
            WebClient client = new WebClient();
            client.UploadStringCompleted += (sender, e) =>
            {
                acArgs = e;
                mre.Set();
            };
            client.Headers[HttpRequestHeader.ContentType] = "application/json; charset=UTF-8";
            client.UploadStringAsync(new Uri(baseUri + uri), method, req);
            mre.WaitOne();
            if (acArgs.Cancelled)
                throw new TimeoutException();
            if (acArgs.Error != null)
                throw new WebException("Rest Error:" + acArgs.Error.Message, acArgs.Error);
            var str = acArgs.Result;
            {
                DataContractJsonSerializer respSerializer = new DataContractJsonSerializer(typeof(TResp));
                var ms = new MemoryStream();
                var sw = new StreamWriter(ms);
                sw.Write(acArgs.Result);
                sw.Flush();
                ms.Seek(0L, SeekOrigin.Begin);
                return (TResp)respSerializer.ReadObject(ms);
            }
        }

        public static TResp GetJson<TResp>(string baseUri, string uri, string method)
        {
            ManualResetEvent mre = new ManualResetEvent(false);
            DownloadStringCompletedEventArgs acArgs = null;
            WebClient client = new WebClient();
            client.DownloadStringCompleted += (sender, e) =>
            {
                acArgs = e;
                mre.Set();
            };
            client.DownloadStringAsync(new Uri(baseUri + uri), method);
            mre.WaitOne();
            if (acArgs.Cancelled)
                throw new TimeoutException();
            if (acArgs.Error != null)
                throw new WebException("Rest Error:" + acArgs.Error.Message, acArgs.Error);
            var str = acArgs.Result;
            {
                DataContractJsonSerializer respSerializer = new DataContractJsonSerializer(typeof(TResp));
                var ms = new MemoryStream();
                var sw = new StreamWriter(ms);
                sw.Write(acArgs.Result);
                sw.Flush();
                ms.Seek(0L, SeekOrigin.Begin);
                return (TResp)respSerializer.ReadObject(ms);
            }

现在可以继续思考前面的问题，我们有了契约的信息，有了如何请求Rest服务的原始代码，剩下的工作就是：

所有参数的名称+他们的值+UriTemplate=实际的Uri+post内容的参数

看起来就是个数组的查找和字符串替换的事情，问题已经被化解的差不多了，突然想起来一个蛋疼的东西。。。BodyStyle=WebMessageBodyStyle.Wrapped | WrappedRequest | WrapperResponse

这东西还要给他们生成一个类型才能玩，算了不陪WCF玩了，其它的几种一律不支持

既然决定不完全支持，那干脆在加几条：

不支持自定义类型转换器 - 不是不能支持，而是嫌其麻烦（统一用ToString代替转换器）
不支持Fault契约 - 还是麻烦
不支持KnownType - 依然是麻烦

在成功的“减赋”之后，终于真的感觉事情少了很多，现在再去实现那堆接口：

创建类型-part-2

        private static void CreateProxyCtor(TypeBuilder tb, FieldBuilder field)
        {
            var ctor = tb.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new Type[] { typeof(string) });
            var il = ctor.GetILGenerator();
            il.Emit(OpCodes.Ldarg_0);
            il.Emit(OpCodes.Call, typeof(object).GetConstructor(Type.EmptyTypes));
            il.Emit(OpCodes.Ldarg_0);
            il.Emit(OpCodes.Ldarg_1);
            il.Emit(OpCodes.Stfld, field);
            il.Emit(OpCodes.Ret);
        }

        private static void CreateProxyMethod(TypeBuilder tb, MethodInfo mi, FieldBuilder field, ref int methodCount)
        {
            var m = tb.DefineMethod(
                "M" + (++methodCount).ToString(),
                MethodAttributes.Private | MethodAttributes.Virtual | MethodAttributes.Final,
                mi.ReturnType,
                (from pi in mi.GetParameters() select pi.ParameterType).ToArray());
            if (!Attribute.IsDefined(mi, typeof(OperationContractAttribute)))
            {
                CreateEmptyMethod(m);
            }
            else
            {
                string template = null;
                string method = null;
                {
                    var wga = (WebGetAttribute)Attribute.GetCustomAttribute(mi, typeof(WebGetAttribute));
                    if (wga != null)
                    {
                        template = wga.UriTemplate;
                        method = "GET";
                    }
                }
                {
                    var wia = (WebInvokeAttribute)Attribute.GetCustomAttribute(mi, typeof(WebInvokeAttribute));
                    if (wia != null)
                    {
                        template = wia.UriTemplate;
                        method = wia.Method ?? "POST";
                    }
                }
                if (template == null)
                {
                    CreateEmptyMethod(m);
                }
                else
                {
                    CreateCoreMethod(m, mi, template, method, field);
                }
            }
            tb.DefineMethodOverride(m, mi);
        }

        private static void CreateCoreMethod(MethodBuilder m, MethodInfo mi, string template, string method, FieldBuilder field)
        {
            var il = m.GetILGenerator();
            il.DeclareLocal(typeof(string));
            il.Emit(OpCodes.Ldstr, template);
            il.Emit(OpCodes.Stloc_0);
            var pis = mi.GetParameters();
            int postParameter = -1;
            for (int i = 0; i < pis.Length; i++)
            {
                if (template.Contains("{" + pis[i].Name + "}"))
                {
                    // template = template.Replace("{?.Name}", HttpUtility.UrlEncode(?.ToString()));
                    il.Emit(OpCodes.Ldloc_0);
                    il.Emit(OpCodes.Ldstr, "{" + pis[i].Name + "}");
                    il.Emit(OpCodes.Ldarg, i + 1);
                    if (pis[i].ParameterType.IsValueType)
                        il.Emit(OpCodes.Box, pis[i].ParameterType);
                    il.Emit(OpCodes.Callvirt, typeof(object).GetMethod("ToString"));
                    il.Emit(OpCodes.Call, typeof(HttpUtility).GetMethod("UrlEncode"));
                    il.Emit(OpCodes.Call, typeof(string).GetMethod("Replace", new Type[] { typeof(string), typeof(string) }));
                    il.Emit(OpCodes.Stloc_0);
                }
                else
                {
                    if (postParameter > 0)
                        throw new NotSupportedException();
                    postParameter = i;
                    if (method == "GET")
                        method = "POST";
                }
            }
            if (postParameter == -1)
            {
                il.Emit(OpCodes.Ldarg_0);
                il.Emit(OpCodes.Ldfld, field);
                il.Emit(OpCodes.Ldloc_0);
                il.Emit(OpCodes.Ldstr, method);
                il.Emit(OpCodes.Call, typeof(RestClient).GetMethod("GetJson").MakeGenericMethod(mi.ReturnType));
            }
            else
            {
                il.Emit(OpCodes.Ldarg_0);
                il.Emit(OpCodes.Ldfld, field);
                il.Emit(OpCodes.Ldloc_0);
                il.Emit(OpCodes.Ldstr, method);
                il.Emit(OpCodes.Ldarg, postParameter + 1);
                il.Emit(OpCodes.Call, typeof(RestClient).GetMethod("PostJson").MakeGenericMethod(pis[postParameter].ParameterType, mi.ReturnType));
            }
            il.Emit(OpCodes.Ret);
        }

        private static void CreateEmptyMethod(MethodBuilder m)
        {
            var il = m.GetILGenerator();
            if (m.ReturnType != typeof(void))
            {
                if (m.ReturnType.IsValueType)
                {
                    il.DeclareLocal(m.ReturnType);
                    il.Emit(OpCodes.Ldarga_S, (byte)0);
                    il.Emit(OpCodes.Initobj, m.ReturnType);
                }
                else
                {
                    il.Emit(OpCodes.Ldnull);
                }
            }
            il.Emit(OpCodes.Ret);

这里，做了几件额外的事情：

如果接口里面有非契约的方法 - 用返回默认值来实现（当然也可以修改成throw）
如果发现参数中多余1个未在UriTemplate中出现的参数，直接报错 - 因为不支持Wrapper
如果方法为GET并且带Post信息，将方法更改为POST

不过，还有几件事情没做：

参数的值为null时会抛空引用 - 有空的话可以自己改，我这里反正都传空字符串的。。。而且，在后面的外壳部分也可以包装掉

使用代理类

类看看这个代理类怎么用：

var client = new RestClient<ISample>("http://127.0.0.1:12345/");
var result = client.Channel.Echo("Zhenway", "Hello world!");

是不是有点调用WebService的感觉？

不过还有点欠缺，多了个Channel，而且随便调用那个方法，都要出现这个Channel，感觉不爽

干脆再学一次WebService，来个外壳（当然，也可以直接拿着Channel去干活）：

    public class SampleClient
        : RestClient<ISample>, ISample
    {
        public SampleClient()
            : base("the default uri") { }
        public SampleClient(string uri)
            : base(uri) { }
        public EchoResponse Echo(string name, string message)
        {
            return Channel.Echo(name, message);
        }
    }

这样用起来就会舒服一些（而且也可以做些额外的工作）

var client = new SampleClient("http://127.0.0.1:12345/");
var result = client.Echo("Zhenway", "Hello world!");

这样明显更舒服一些。

暗藏的危机

看起来万事俱备，但是实际上一使用才发现神马都是浮云。

如果在用户界面上调用client.Echo，那么就算等上一万年，也拿不到结果，而且整个浏览器也会因为Sliverlight插件而出现假死。

为什么会这样哪？分析一下原因：可以发现在实现PostJson和GetJson方法中的

mre.WaitOne();

永远等不到被Set的那一刻，看看代码逻辑似乎没什么问题，不过仔细想想，就可以发现问题：

首先，Sliverlight的UI线程是基于消息的
其次，webclient的回调事件是会回到请求Async方法的同步上下文上的

那么，是不是发现问题了，UI线程请求了client.Echo，client.Echo请求了channel.Echo，channel.Echo请求了WebClient的DownloadStringAsync，然后等待mre信号。

WebClient在开始DownloadStringAsync时，抓取了当时的同步上下文，也就是UI的同步上下文，再开始异步下载，下载完成时，告诉同步上下文，可以执行回调事件了。

而此时，同步上下文-也就是UI线程的消息处理机制却无法工作，之前的一个消息尚未处理完成（被迫在等待mre的信号中），于是出现了死锁。

发现了问题所在，要排除问题，也就很简单了，只要破坏这个死锁中的一个环节，自然就能让UI活起来。

最简单的方式是从入口下手：UI线程不直接请求client.Echo，而是修改成UI线程新开个线程（直接用线程池就可以了），请求client.Echo，这样就把同步上下文从UI线程的上下文切换到了另一个上下文。

来看看修改后的代码：

ThreadPool.QueueUserWorkItem(_ =>
{
    var client = new SampleClient("http://127.0.0.1:12345/");
    var result = client.Echo("Zhenway", "Hello world!");
    // do something ...
});

看起来不错，不过要修改界面的话（90%的情况下都要修改界面的吧），还要回归到UI线程，干脆根据Silverlight的基于事件的异步方式，重写我们的Client

重写后的Client

        public void EchoAsync(string name, string message)
        {
            EchoAsync(name, message, null);
        }

        public void EchoAsync(string name, string message, object userState)
        {
            var sc = SynchronizationContext.Current;
            ThreadPool.QueueUserWorkItem(_ =>
            {
                EchoResponse result = null;
                Exception ex1 = null;
                try
                {
                    result = Channel.Echo(name, message);
                }
                catch (Exception ex)
                {
                    ex1 = ex;
                }
                try
                {
                    var handler = EchoCompleted;
                    if (handler != null)
                        sc.Post(__ => handler(this, new EchoAsyncCompletedEventArgs(result, ex1, false, userState)), null);
                }
                catch (Exception) { }
            });
        }

        public event EventHandler<EchoAsyncCompletedEventArgs> EchoCompleted;

        public class EchoAsyncCompletedEventArgs
            : AsyncCompletedEventArgs
        {
            public EchoAsyncCompletedEventArgs(EchoResponse response,
                Exception error, bool cancelled, object userState)
                : base(error, cancelled, userState)
            {
                Response = response;
            }
            public EchoResponse Response { get; private set; }

这样，Echo就可以很好的工作了（在UI线程中调用EchoAsync后，EchoCompleted事件也会在UI线程中执行）：

var client = new SampleClient("http://127.0.0.1:12345/");
client.EchoCompleted += (sender, e) =>
{
// update UI elements, here.
};
var result = client.EchoAsync("Zhenway", "Hello world!");

是不是看起来还不错，不过，想想如果一个服务有10来个方法，每个这么搞一下，这个量依然很高。。。

再次使用动态代理

遇到这类重复性工作，第一反应，就是再动态一把，把这些重复工作消除成一次性的静态行为，这里就可以通过再次动态代理，来消除原来动态代理的种种不爽之处。

只不过，这次的动态代理不是用动态生成类型，而是换dynamic，也给大家换换口味

这次动态代理的功能自然是完成“重写后的Client”的功能，这里分两大块，一个是异步方法，一个是事件

动态异步代理

    public class DynamicAsyncClient
        : DynamicObject
    {

        private readonly object m_channel;
        private readonly HashSet<string> m_methods;
        private readonly Dictionary<string, DynamicAsyncCompletedEventHandler> m_events;

        public DynamicAsyncClient(object channel)
        {
            if (channel == null)
                throw new ArgumentNullException("channel");
            m_channel = channel;
            m_methods = new HashSet<string>(from m in channel.GetType().GetMethods(BindingFlags.Public | BindingFlags.Instance)
                                            select m.Name);
            m_events = new Dictionary<string, DynamicAsyncCompletedEventHandler>();
        }

        public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
        {
            if (m_methods.Contains(binder.Name))
            {
                result = m_channel.GetType().InvokeMember(binder.Name, BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Instance, null, m_channel, args);
                return true;
            }
            if (binder.Name.EndsWith("Completed"))
            {
                lock (m_events)
                    m_events[binder.Name] = (DynamicAsyncCompletedEventHandler)args[0];
                result = null;
                return true;
            }
            if (binder.Name.EndsWith("Async"))
            {
                try
                {
                    AsyncInvoke(binder.Name.Remove(binder.Name.Length - "Async".Length), args, null);
                    result = null;
                    return true;
                }
                catch (MissingMethodException) { }
            }
            return base.TryInvokeMember(binder, args, out result);
        }

        private void AsyncInvoke(string name, object[] args)
        {
            var sc = SynchronizationContext.Current;
            ThreadPool.QueueUserWorkItem(_ =>
            {
                dynamic result = null;
                Exception ex1 = null;
                try
                {
                    result = m_channel.GetType().InvokeMember(name, BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Instance, null, m_channel, args);
                }
                catch (Exception ex)
                {
                    ex1 = ex;
                }
                try
                {
                    DynamicAsyncCompletedEventHandler handler;
                    lock (m_events)
                        if (m_events.TryGetValue(name + "Completed", out handler))
                            sc.Post(__ => handler(this, new DynamicAsyncCompletedEventArgs(result, ex1, false, null)), null);
                }
                catch (Exception) { }
            });
        }

    }

    public delegate void DynamicAsyncCompletedEventHandler(object sender, DynamicAsyncCompletedEventArgs e);

    public class DynamicAsyncCompletedEventArgs
        : AsyncCompletedEventArgs
    {

        public DynamicAsyncCompletedEventArgs(dynamic response, Exception error, bool cancelled, object userState)
            : base(error, cancelled, userState)
        {
            Response = response;
        }

        public dynamic Response { get; private set; }

再删除SampleClient中前面添加的两个异步方法后，来看看如何跑起来：

var client = new DynamicAsyncClient(new SampleClient("http://127.0.0.1:12345/"));
client.EchoCompleted += (sender, e) =>
{
  // update UI elements, here.
  textbox1.Text = e.Response.Name;
  textbox2.Text = e.Response.Message;
};
var result = client.EchoAsync("Zhenway", "Hello world!");

小节

到这里，整个主题也告一段落，当然这里面可以改良的东西还有很多，例如，对WCF的Rest服务更多的支持，动态异步代理支持userState等，众多改良尚可去做，不过这些暂时省略了