利用流水线改进代码中的if处理流程

本文用到的编程语言为C#，具体思路不限制编程语言。

刚才正在浏览http://ruby-china.org/topics/7384的时候，看到5楼的回复，突然有一种想法，不知道优劣，请大家帮忙评判一下，或者给出一些更好的实现方案。

我们先来上一段代码，就是常见的一种代码。

1. Order getOrder(string orderNo) 
2. { 
3.  
4.     order = repo.getOrder(orderNo); 
5.  
6.     if(order.condition1) 
7.     { 
8.      ... 
9.     } 
10.  
11.     if(order.condition2) 
12.     { 
13.     ... 
14.     } 
15.  
16.     if(order.condition3) 
17.     { 
18.     ... 
19.     } 
20.    
21.     .   
22.     . 
23.     . 
24.  
25. } 

上面是一段伪代码，实现的就是一个根据订单号，获取订单，然后根据订单的一些条件进行一些处理。

order是获取出来的订单，condition1、condition2、condition3是一些条件。随着业务的复杂，condition3后面还可能更多的condition，就需要添加更多的if，进行更多的判断，然后这个方法越来越长，越来越难以读懂，越来越难以维护，越来越。。。

我想是不是可以换个角度，不是订单来判断条件，然后执行一些代码。而是订单进入一个处理流程，然后处理流程中有很多的闸门，每个闸门代表一个特征条件处理器，然后由这个处理器来判断流经自己的订单是否符合条件，符合就处理，不符合就掠过。

这样有几个好处：

1. 上面代码中的获取订单方法，不会越来越长，这样阅读起来就很好理解，在后面进行维护的时候，就很容易来做了。
2. 添加一个新的条件处理分支也很容易，只要把这种条件处理看做是一个闸门，在处理流水线中加入新闸门就可以了，其他的都不需要变化。
3. 调整原来的条件处理，也只需要修改闸门内部的处理代码即可，不用担心是否影响其他处理分支。
4. 分支独立之后，还可以针对每个分支做单元测试。

其实扩展开来想，这个流程不仅可以处理订单，任何针对一个对象进行流程化处理的场景，都可以套用上面的代码结构，都可以得到上面的好处。

我画了一个示意图。

图 1.1 对象处理流水线 

放出一段示例代码。

1. public interface IRepo 
2.    { 
3.        string getOrder(string orderNo); 
4.    } 
5.    public class Repo : IRepo 
6.    { 
7.  
8.        public string getOrder(string orderNo) 
9.        { 
10.            return string.Empty; 
11.        } 
12.    } 
13.  
14.    public class Client 
15.    { 
16.  
17.  
18.        public void getOrder(string orderNo) 
19.        { 
20.            var order = new Repo().getOrder(orderNo); 
21.            var pipeline = new Pipeline(); 
22.            var handle1 = new condition1_Handle(); 
23.            var handle2 = new condition2_Handle(); 
24.            pipeline.add_order(order); 
25.            pipeline.add_handle(handle1); 
26.            pipeline.add_handle(handle2); 
27.            pipeline.processOrder(); 
28.        } 
29.    } 
30.    class Pipeline 
31.    { 
32.        private List<IHandle> _handles; 
33.        private string _order; 
34.        public Pipeline() 
35.        { _handles = new List<IHandle>(); } 
36.        internal void add_order(string order) 
37.        { 
38.            this._order = order; 
39.        } 
40.  
41.        internal void add_handle(IHandle handle1) 
42.        { 
43.            _handles.Add(handle1); 
44.        } 
45.  
46.        internal void processOrder() 
47.        { 
48.            foreach (var h in _handles) 
49.            { 
50.                h.process(_order); 
51.            } 
52.        } 
53.    } 
54.    public interface IHandle 
55.    { 
56.        void process(string order); 
57.    } 
58.    public class condition1_Handle : IHandle 
59.    { 
60.        public  void process(string _order) 
61.        { 
62.            throw new NotImplementedException(); 
63.        } 
64.    } 
65.    public class condition2_Handle : IHandle 
66.    { 
67.        public void process(string _order) 
68.        { 
69.            throw new NotImplementedException(); 
70.        } 
71.    } 

感觉有点像是策略模式，但是感觉又不太像。

上面的代码还有优化的空间，大家有没有更好的方案呢，欢迎大家一起讨论！

稍加改进，引入泛型，就可以支持任意类型的对象处理。

1. using System; 
2. using System.Collections.Generic; 
3. using System.Linq; 
4. using System.Text; 
5.  
6. namespace ConsoleClient.Pipeline 
7. { 
8.     public interface IRepo 
9.     { 
10.         Purchase getOrder(string orderNo); 
11.         Product getProduct(int id); 
12.  
13.     } 
14.     public class Repo : IRepo 
15.     { 
16.  
17.         public Purchase getOrder(string orderNo) 
18.         { 
19.             return new Purchase(); 
20.         } 
21.  
22.         public Product getProduct(int id) 
23.         { 
24.             return new Product(); 
25.         } 
26.     } 
27.  
28.     public class Client 
29.     { 
30.  
31.  
32.         public Purchase getOrder(string orderNo) 
33.         { 
34.             var order = new Repo().getOrder(orderNo); 
35.             var pipeline = new Pipeline<Purchase>(); 
36.             var handle1 = new condition1_orderHandle(); 
37.             var handle2 = new condition2_orderHandle(); 
38.             pipeline.add_order(order); 
39.             pipeline.add_handle(handle1); 
40.             pipeline.add_handle(handle2); 
41.             pipeline.processOrder(); 
42.  
43.             return order; 
44.         } 
45.  
46.  
47.         public Product getProduct(int id) 
48.         { 
49.             var product = new Repo().getProduct(id); 
50.             var pipeline = new Pipeline<Product>(); 
51.             var handle1 = new condition1_productHandle(); 
52.             var handle2 = new condition2_productHandle(); 
53.             pipeline.add_order(product); 
54.             pipeline.add_handle(handle1); 
55.             pipeline.add_handle(handle2); 
56.             pipeline.processOrder(); 
57.  
58.             return product; 
59.         } 
60.     } 
61.     public class Pipeline<T> 
62.     { 
63.         private List<IHandle<T>> _handles; 
64.         private T _order; 
65.         public Pipeline() 
66.         { _handles = new List<IHandle<T>>(); } 
67.         public void add_order(T order) 
68.         { 
69.             this._order = order; 
70.         } 
71.  
72.         public void add_handle(IHandle<T> handle1) 
73.         { 
74.             _handles.Add(handle1); 
75.         } 
76.  
77.         public void processOrder() 
78.         { 
79.             foreach (var h in _handles) 
80.             { 
81.                 h.process(_order); 
82.             } 
83.         } 
84.     } 
85.  
86.     public class Purchase 
87.     { 
88.  
89.         public bool IsPay { get; set; } 
90.  
91.     } 
92.     public class Product 
93.     { 
94.         public bool IsExpired { get; set; } 
95.     } 
96.     public interface IHandle<T> 
97.     { 
98.         void process(T order); 
99.     } 
100.     public class condition1_orderHandle : IHandle<Purchase> 
101.     { 
102.  
103.         public void process(Purchase order) 
104.         { 
105.             if (order.IsPay == false ) 
106.             { 
107.                 Console.WriteLine("you don't pay money"); 
108.             } 
109.         } 
110.     } 
111.     public class condition2_orderHandle : IHandle<Purchase> 
112.     { 
113.         public void process(Purchase order) 
114.         { 
115.  
116.         } 
117.     } 
118.  
119.     public class condition1_productHandle : IHandle<Product> 
120.     { 
121.         public void process(Product product) 
122.         { 
123.  
124.         } 
125.     } 
126.     public class condition2_productHandle : IHandle<Product> 
127.     { 
128.         public void process(Product product) 
129.         { 
130.  
131.         } 
132.     } 
133. } 

本文转自 virusswb 51CTO博客，原文链接：http://blog.51cto.com/virusswb/1081790，如需转载请自行联系原作者