DoubanFm之设计模式（一）

　　前两版DoubanFm写的太戳，第一版可以忽略，当是熟悉WP手机的一些API。。

第二版用了比较多的依赖注入，熟悉了Messenger,过后越写越大，感觉不对，赶快打住。。现在开始好好思考各模块了。

在Http请求方面，在知道了Restful后还没有机会使用它，感觉Restful应该还不错，不过我还是为我的Http请求使用了下面的设计模式

一.工厂方法

1.抽象产品

UML有空再画，先上代码，

使用Rx建立抽象的Get类产品，如下：

 public  abstract class HttpGetMethodBase<T>
     {
             public virtual IObservable<T> Get(string Url)//设置虚拟方法是为了多态 但是这里不用设置应该也可以
             {
                 //多态既是为了用子类的方法
                 //其实我这里不需要用子类的方法
                 //写了应该也可以
                 //只要注意子类的Override
                 var func = Observable.FromAsyncPattern<HttpWebRequest, T>(Webrequest, WebResponse);
                 HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(Url);
                 return func(request);
             }
            private  IAsyncResult Webrequest(HttpWebRequest request, AsyncCallback callbcak, object ob)
             {
                 return request.BeginGetResponse(callbcak, request);
             }

            //发的请求用的是父类的get,WebResponse用的是子类的
             protected    abstract T WebResponse(IAsyncResult result);
      }

作为抽象的产品，有些方法可以共享，比如Get方法。要重写的是WebResponse

2.具体产品

（1）返回stream的产品

   public class HttpGetStream : HttpGetMethodBase<Stream>
     {
         protected override Stream WebResponse(IAsyncResult result)
         {
             try
             {
                 var request = result.AsyncState as HttpWebRequest;
                 HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(result);
                 #region ignore
                 if (response.Cookies != null)
                 {
                     foreach (Cookie cookie in response.Cookies)
                     {
                         Debug.WriteLine(cookie.Value);
                     }
                 }
                 Debug.WriteLine(response.ContentType);
                 Debug.WriteLine(response.StatusDescription);
                 if (response.Headers["Set-Cookie"] != null)
                 {
                     //setting may write
                     Debug.WriteLine(response.Headers["Set-Cookie"]);
                 }
                 #endregion
                return  response.GetResponseStream();
             }
             catch
             {
                 Debug.WriteLine("WEBERROR");
                 return null;
             }
         }
     }

（2）返回string的产品

   public class HttpGetString : HttpGetMethodBase<string>
     {
         protected  override string WebResponse(IAsyncResult result)
         {
             try
             {
                 var request = result.AsyncState as HttpWebRequest;
                 HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(result);
                 #region ignore
                 if (response.Cookies != null)
                 {
                     foreach (Cookie cookie in response.Cookies)
                     {
                         Debug.WriteLine(cookie.Value);
                     }
                 }
                 Debug.WriteLine(response.ContentType);
                 Debug.WriteLine(response.StatusDescription);
                 if (response.Headers["Set-Cookie"] != null)
                 {
                     //setting may write
                     Debug.WriteLine(response.Headers["Set-Cookie"]);
                 }
                 #endregion
                 Stream stream = response.GetResponseStream();
                 using (StreamReader sr = new StreamReader(stream))
                 {
                     return sr.ReadToEnd();
                 }
             }
             catch
             {
                 Debug.WriteLine("WEBERROR");
                 return null;
             }
         }
     }

（3）返回位图的产品

   public class HttpGetBitmapImage : HttpGetMethodBase<BitmapImage>
     {
         protected override BitmapImage  WebResponse(IAsyncResult result)
         {
             try
             {
                 var request = result.AsyncState as HttpWebRequest;
                 HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(result);
                 #region ignore
                 if (response.Cookies != null)
                 {
                     foreach (Cookie cookie in response.Cookies)
                     {
                         Debug.WriteLine(cookie.Value);
                     }
                 }
                 Debug.WriteLine(response.ContentType);
                 Debug.WriteLine(response.StatusDescription);
                 if (response.Headers["Set-Cookie"] != null)
                 {
                     //setting may write
                     Debug.WriteLine(response.Headers["Set-Cookie"]);
                 }
                 #endregion
                 Stream stream = response.GetResponseStream();
                 BitmapImage bitmapimage = new BitmapImage();
                 bitmapimage.SetSource(stream);
                 return bitmapimage;
             }
             catch
             {
                 Debug.WriteLine("WEBERROR");
                 return null;
             }
         }
     }

现在主要有三种产品，如果以后有返回音频的产品，就照搬就好了，这样便于扩展。

3.接口工厂（不叫抽象工厂是怕跟抽象工厂模式冲突）

（1）用于创建对象（产品）的接口

 interface IHttpGet<T>
    {
        HttpGetMethodBase<T> CreateHttpRequest();
    }

（2）具体的工厂

具体工厂都用来创建具体的产品

1.string(get)工厂

  public class StringHttpFactory:IHttpGet<string>
     {
          public HttpGetMethodBase<string>  CreateHttpRequest()
         {
             return new HttpGetString();
         }
     }

2.stream（get）工厂

   public class StreamHttpFactory : IHttpGet<Stream>
     {

         public HttpGetMethodBase<Stream> CreateHttpRequest()
         {
             return new HttpGetStream();
         }
     }

3.位图工厂

 public class BitmapImageHttpFactory : IHttpGet<BitmapImage>
     {
         public HttpGetMethodBase<BitmapImage> CreateHttpRequest()
         {
             return new HttpGetBitmapImage();
         }
     }

客户端调用：

客户端调用还是得知道具体的工厂型号，所以这里我打个问号，先看看代码吧

   IHttpGet<string> factory = new StringHttpFactory();//string 工厂
             factory.CreateHttpRequest().Get("http://douban.fm/j/mine/playlist?from=mainsite&channel=0&kbps=128&type=n").Subscribe(
                 (result) =>
                 {
                                    });

代码new了一个具体的工厂，这里并没有达到真正的解耦，所以我考虑看能不能以后做

1。配置文件反射处理

2.依赖注入。

//to be continued................

二.职责链

先看看背景。

虽然用Newtonsoft的json库很爽，但是面对复杂的json串，不能很好的面对它的变化，变化点在于，JToken[][][][][][][][][]，中括号的个数未知，我不知道哪天出来的json串会有几个[],如果使用到解析json串的地方很多，这个中括号的数量会非常多，看着非常恶心。。。。。。。。当然也许Newtonsoft有解决办法，但是我没摸索出来。

1.Json串的多样性

json串是由Web服务端安排的，各种命名，各种key/vaule，客户端很难应对这种变。

用职责链的效果是：客户端只用发出获得的json字符串，就可以获得与之对应的类，至于json串怎么被处理的，客户端不知道

上代码

   public abstract class RequestorBase<T>
     {
         protected RequestorBase<T> Successor;
         internal void SetSucessor(RequestorBase<T> suc)
         {
             Successor = suc;
         }
         public abstract T ProcessRequest(string json);//抽象不依赖于具体，抽象依赖于抽象
     }

     public class Requestor1<T> : RequestorBase<T>
     {
         public override T ProcessRequest(string json)
         {
             try
             {
                 return JsonConvert.DeserializeObject<T>(JToken.Parse(json)["song"].ToString());
             }
             catch
             {
                 Debug.WriteLine("这个是在职责链中的该有的异常");
                 return Successor.ProcessRequest(json);
             }
         }
     }
     public class Requestor2<T> : RequestorBase<T>
     {
         public override T ProcessRequest(string json)
         {
             try
             {
                 return JsonConvert.DeserializeObject<T>(JToken.Parse(json)["song"][].ToString());
             }
             catch
             {
                 Debug.WriteLine("这个是在职责链中的该有的异常");
                 return Successor.ProcessRequest(json);
             }
         }
     }
     public class Requestor3<T> : RequestorBase<T>
     {
         public override T ProcessRequest(string json)
         {
             Debug.WriteLine("在职责链中没有能找到处理请求的方法，返回Default");
             return default(T);
             //NO Chain 继续下去了
         }
     }

不同的职责人作不同的json串解析。

然后再使用

三.单例模式

使用单例模式来创建管理职责链，使用单例管理职责链的目的是职责链只负责处理json串，他们都是无状态的，所有把他们的方法装入内存就可以了。

   public class ManagerResponsibilityChain<T>
     {
        static private RequestorBase<T> _startrequestor;
        static public RequestorBase<T> Instance_Startrequestor
         {
             get
             {
                 if (_startrequestor == null)
                 {
                     Inital();
                 }
                 return _startrequestor;
             }
         }
         private ManagerResponsibilityChain()
         {

         }
         static private void Inital()
         {
             _startrequestor = new Requestor1<T>();
             var secondrequestor = new Requestor2<T>();
             var thridrequestor = new Requestor3<T>();
             _startrequestor.SetSucessor(secondrequestor);
             secondrequestor.SetSucessor(thridrequestor);//requestor3 is the end
         }
     }

今天就到这。

后面再来追加一下：

对于上面的职责链，要想增加职责者，难免会忘记增加的过程，要插入在倒数第二个地方，再重新设置后两个的职责链

    public class ManagerResponsibilityChain<T>
     {
         static private RequestorBase<T> _startrequestor;
         static public RequestorBase<T> Instance_Startrequestor
         {
             get
             {
                 if (_startrequestor == null)
                 {
                     Inital();
                 }
                 return _startrequestor;
             }
         }
         private ManagerResponsibilityChain()
         {

         }
         static public List<RequestorBase<T>> RequestList=new List<RequestorBase<T>>();
         static private void InsertARequestor(RequestorBase<T> InsertItem)
         {
             RequestList.Insert(RequestList.Count - , InsertItem);
             InsertItem.SetSucessor(RequestList[RequestList.Count - ]);
             RequestList[RequestList.Count - ].SetSucessor(InsertItem);

         }

         static private void Inital()
         {

             _startrequestor = new Requestor1<T>();
             var secondrequestor = new Requestor2<T>();
             var thridrequestor = new Requestor3<T>();
             RequestList.Add(_startrequestor);
             RequestList.Add(secondrequestor);
             RequestList.Add(thridrequestor);
             _startrequestor.SetSucessor(secondrequestor);
             secondrequestor.SetSucessor(thridrequestor);//requestor3 is the end 

             InsertARequestor(new Requestor4<T>());
             InsertARequestor(new Requestor5<T>());
             InsertARequestor(new Requestor6<T>());
         }

     }

或者是

   public class ManagerResponsibilityChain<T>
     {
         static private RequestorBase<T> _startrequestor;
         static public RequestorBase<T> Instance_Startrequestor
         {
             get
             {
                 if (_startrequestor == null)
                 {
                     Inital();
                 }
                 return _startrequestor;
             }
         }
         private ManagerResponsibilityChain()
         {

         }

       static  private void InsertARequestor(RequestorBase<T> InsertItem, List<RequestorBase<T>> RequestList)
         {
             RequestList.Insert(RequestList.Count - , InsertItem);
             InsertItem.SetSucessor(RequestList[RequestList.Count - ]);
             RequestList[RequestList.Count - ].SetSucessor(InsertItem);

         }

         static private void Inital()
         {
             List<RequestorBase<T>> RequestList = new List<RequestorBase<T>>();
             _startrequestor = new Requestor1<T>();
             var secondrequestor = new Requestor2<T>();
             var thridrequestor = new Requestor3<T>();
             RequestList.Add(_startrequestor);
             RequestList.Add(secondrequestor);
             RequestList.Add(thridrequestor);
             _startrequestor.SetSucessor(secondrequestor);
             secondrequestor.SetSucessor(thridrequestor);//requestor3 is the end 

             InsertARequestor(new Requestor4<T>(), RequestList);
             InsertARequestor(new Requestor5<T>(), RequestList);
             InsertARequestor(new Requestor6<T>(), RequestList);
         }

     }