ObjectBuilder 项目中 Utility 文件夹 — PolicyList 类(未)

  1using System;
  2using System.Collections.Generic;
  3
  4namespace Microsoft.Practices.ObjectBuilder
  5{
  6    /**//// <summary>
  7    /// <see cref="IBuilderPolicy"/> 
  8    /// 对象的自定义集合。
  9    /// </summary>
 10    /// <remarks>
 11    /// 该类实际上是一个
 12    /// 保存 "方针标识/
 13    /// 方针" 对的字典。
 14    /// 其中 ，"方针标识" 
 15    /// 包含：方针的类型
 16    /// （也叫做 "方针接
 17    /// 口" 的类型）、应
 18    /// 用该 "方针" 的类
 19    /// 型和应用该 "方针" 
 20    /// 的 Id 。在这里规
 21    /// 定：如果 "方针标
 22    /// 识" 中只包含 "方
 23    /// 针接口" 的类型而
 24    /// 其它的信息为 null，
 25    /// 则称该 "方针" 为
 26    /// 该 "方针接口" 类
 27    /// 型的缺省 "方针"。
 28    /// </remarks>
 29    public class PolicyList
 30    {
 31
 32        字段#region 字段
 33        private Dictionary<BuilderPolicyKey, IBuilderPolicy> policies = new Dictionary<BuilderPolicyKey, IBuilderPolicy>();
 34        private object lockObject = new object();
 35        #endregion
 36
 37        属性#region 属性
 38        /**//// <summary>
 39        /// 返回当前 "方针列
 40        /// 表" 中 "方针" 的
 41        /// 数量。
 42        /// </summary>
 43        public int Count
 44        {
 45            get
 46            {
 47                lock (lockObject)
 48                {
 49                    return policies.Count;
 50                }
 51            }
 52        }
 53        #endregion
 54
 55        构造函数#region 构造函数
 56        /**//// <summary>
 57        /// 初始化 <see cref="PolicyList"/> 类新实例。
 58        /// </summary>
 59        /// <param name="policiesToCopy">
 60        /// 要复制到 "方针列
 61        /// 表" 中的 "创建方
 62        /// 针" 的集合，可以
 63        /// 是 null。
 64        /// </param>
 65        public PolicyList(params PolicyList[] policiesToCopy)
 66        {
 67            if (policiesToCopy != null)
 68            {
 69                foreach (PolicyList policyList in policiesToCopy)
 70                {
 71                    AddPolicies(policyList);
 72                }
 73            }
 74        }
 75        #endregion
 76
 77        公有方法#region 公有方法
 78        /**//// <summary>
 79        /// 将指定 "方针列表" 
 80        /// 中的 "方针" 添加
 81        /// （也叫做 "注册"）
 82        /// 到当前的 "方针列
 83        /// 表"。如果 "方针"
 84        /// 已经存在，则使用
 85        /// 新的 "方针" 替换
 86        /// 原有的 "方针"。
 87        /// </summary>
 88        /// <param name="policiesToCopy">
 89        /// 要添加的 "创建
 90        /// 方针" 的集合。
 91        /// </param>
 92        public void AddPolicies(PolicyList policiesToCopy)
 93        {
 94            lock (lockObject)
 95            {
 96                if (policiesToCopy != null)
 97                {
 98                    foreach (KeyValuePair<BuilderPolicyKey, IBuilderPolicy> kvp in policiesToCopy.policies)
 99                    {
100                        policies[kvp.Key] = kvp.Value;
101                    }
102                }
103            }
104        }
105        /**//// <summary>
106        /// 从 "方针列表" 中
107        /// 获取一个指定 "方
108        /// 针"。
109        /// </summary>
110        /// <param name="policyInterface">
111        /// 该 "方针" 注册的
112        ///  "方针接口"。
113        /// </param>
114        /// <param name="typePolicyAppliesTo">
115        /// 应用该 "方针" 的
116        /// 类型。
117        /// </param>
118        /// <param name="idPolicyAppliesTo">
119        /// 应用该 "方针" 的
120        /// Id。
121        /// </param>
122        /// <returns>
123        ///  "方针列表" 中的
124        /// 方针。如果不存在，
125        /// 则为 null。
126        /// </returns>
127        public IBuilderPolicy Get(
128            Type policyInterface,
129            Type typePolicyAppliesTo,
130            string idPolicyAppliesTo)
131        {
132            BuilderPolicyKey key = new BuilderPolicyKey(policyInterface, typePolicyAppliesTo, idPolicyAppliesTo);
133
134            lock (lockObject)
135            {
136                IBuilderPolicy policy;
137                if (policies.TryGetValue(key, out policy))
138                {
139                    return policy;
140                }
141
142                /**//* 
143                 * 代码走到这里，表
144                 * 示指定的 "方针" 
145                 * 没有找到，这时将
146                 * 返回缺省的 "方针"。
147                 */
148                BuilderPolicyKey defaultKey = new BuilderPolicyKey(policyInterface, null, null);
149
150                if (policies.TryGetValue(defaultKey, out policy))
151                {
152                    return policy;
153                }
154
155                /**//* 
156                 * 如果指定的 "方针"
157                 * 和缺省的 "方针" 都
158                 * 没有找到，则返回空
159                 * 引用。
160                 */
161                return null;
162            }
163        }
164        /**//// <summary>
165        /// 从 "方针列表" 中
166        /// 获取一个指定 "方
167        /// 针"。
168        /// </summary>
169        /// <param name="typePolicyAppliesTo">
170        /// 应用该 "方针" 的
171        /// 类型。
172        /// </param>
173        /// <param name="idPolicyAppliesTo">
174        /// 应用该 "方针" 的
175        /// Id。
176        /// </param>
177        /// <returns>
178        ///  "方针列表" 中的
179        /// 方针。如果不存在，
180        /// 则为 null。
181        /// </returns>
182        /// <typeparam name="TPolicyInterface">
183        /// 该 "方针" 注册的
184        ///  "方针接口"。
185        /// </typeparam>
186        public TPolicyInterface Get<TPolicyInterface>(
187            Type typePolicyAppliesTo,
188            string idPolicyAppliesTo) where TPolicyInterface : IBuilderPolicy
189        {
190            return (TPolicyInterface)Get(typeof(TPolicyInterface), typePolicyAppliesTo, idPolicyAppliesTo);
191        }
192        /**//// <summary>
193        /// 设置一个指定 "方针"。
194        /// </summary>
195        /// <param name="policyInterface">
196        /// 该 "方针" 要注册
197        /// 的 "方针接口"。
198        /// </param>
199        /// <param name="policy">
200        /// 要注册的 "方针"。
201        /// </param>
202        /// <param name="typePolicyAppliesTo">
203        /// 应用该 "方针" 的
204        /// 类型。
205        /// </param>
206        /// <param name="idPolicyAppliesTo">
207        /// 应用该 "方针" 的
208        /// Id。
209        /// </param>
210        public void Set(
211            Type policyInterface,
212            IBuilderPolicy policy,
213            Type typePolicyAppliesTo,
214            string idPolicyAppliesTo)
215        {
216            BuilderPolicyKey key = new BuilderPolicyKey(policyInterface, typePolicyAppliesTo, idPolicyAppliesTo);
217
218            lock (lockObject)
219            {
220                policies[key] = policy;
221            }
222        }
223        /**//// <summary>
224        /// 设置一个指定 "方针"。
225        /// </summary>
226        /// <param name="policy">
227        /// 要注册的 "方针"。
228        /// </param>
229        /// <param name="typePolicyAppliesTo">
230        /// 应用该 "方针" 的
231        /// 类型。
232        /// </param>
233        /// <param name="idPolicyAppliesTo">
234        /// 应用该 "方针" 的
235        /// Id。
236        /// </param>
237        /// <typeparam name="TPolicyInterface">
238        /// 该 "方针" 要注册
239        /// 的 "方针接口"。
240        /// </typeparam>
241        public void Set<TPolicyInterface>(
242            TPolicyInterface policy,
243            Type typePolicyAppliesTo,
244            string idPolicyAppliesTo) where TPolicyInterface : IBuilderPolicy
245        {
246            Set(typeof(TPolicyInterface), policy, typePolicyAppliesTo, idPolicyAppliesTo);
247        }
248        /**//// <summary>
249        /// 设置一个缺省 "方
250        /// 针"。 当获取一个
251        /// 指定的 "方针" 时，
252        /// 如果没有找到，则
253        /// 返回这个缺省 "方
254        /// 针"。
255        /// </summary>
256        /// <param name="policyInterface">
257        /// 该 "方针" 注册的
258        ///  "方针接口"。
259        /// </param>
260        /// <param name="policy">
261        /// 要注册的缺省 "方
262        /// 针"。
263        /// </param>
264        public void SetDefault(
265            Type policyInterface,
266            IBuilderPolicy policy)
267        {
268            Set(policyInterface, policy, null, null);
269        }
270        /**//// <summary>
271        /// 设置一个缺省 "方
272        /// 针"。 当获取一个
273        /// 指定的 "方针" 时，
274        /// 如果没有找到，则
275        /// 返回这个缺省 "方
276        /// 针"。
277        /// </summary>
278        /// <param name="policy">
279        /// 要注册的缺省 "方
280        /// 针"。
281        /// </param>
282        /// <typeparam name="TPolicyInterface">
283        /// 该 "方针" 注册的
284        ///  "方针接口"。
285        /// </typeparam>
286        public void SetDefault<TPolicyInterface>(TPolicyInterface policy) where TPolicyInterface : IBuilderPolicy
287        {
288            SetDefault(typeof(TPolicyInterface), policy);
289        }
290        /**//// <summary>
291        /// 从 "方针列表" 中
292        /// 移除一个指定 "方
293        /// 针"。
294        /// </summary>
295        /// <param name="policyInterface">
296        /// 该 "方针" 注册的
297        /// 类型。
298        /// </param>
299        /// <param name="typePolicyAppliesTo">
300        /// 应用该 "方针" 的
301        /// 类型。
302        /// </param>
303        /// <param name="idPolicyAppliesTo">
304        /// 应用该 "方针" 的
305        /// Id。
306        /// </param>
307        public void Clear(
308            Type policyInterface,
309            Type typePolicyAppliesTo,
310            string idPolicyAppliesTo)
311        {
312            lock (lockObject)
313            {
314                policies.Remove(new BuilderPolicyKey(policyInterface, typePolicyAppliesTo, idPolicyAppliesTo));
315            }
316        }
317        /**//// <summary>
318        /// 从 "方针列表" 中
319        /// 移除一个指定 "方
320        /// 针"。
321        /// </summary>
322        /// <param name="typePolicyAppliesTo">
323        /// 应用该 "方针" 的
324        /// 类型。
325        /// </param>
326        /// <param name="idPolicyAppliesTo">
327        /// 应用该 "方针" 的
328        /// Id。
329        /// </param>
330        /// <typeparam name="TPolicyInterface">
331        /// 该 "方针" 注册的
332        /// 类型。
333        /// </typeparam>
334        public void Clear<TPolicyInterface>(
335            Type typePolicyAppliesTo,
336            string idPolicyAppliesTo)
337        {
338            Clear(typeof(TPolicyInterface), typePolicyAppliesTo, idPolicyAppliesTo);
339        }
340        /**//// <summary>
341        /// 清除缺省的 "方针"。
342        /// </summary>
343        /// <param name="policyInterface">
344        /// 该缺省 "方针" 注
345        /// 册的类型。
346        /// </param>
347        public void ClearDefault(Type policyInterface)
348        {
349            Clear(policyInterface, null, null);
350        }
351        /**//// <summary>
352        /// 清除缺省的 "方针"。
353        /// </summary>
354        /// <typeparam name="TPolicyInterface">
355        /// 该缺省 "方针" 注
356        /// 册的类型。
357        /// </typeparam>
358        public void ClearDefault<TPolicyInterface>()
359        {
360            ClearDefault(typeof(TPolicyInterface));
361        }
362        /**//// <summary>
363        /// 清除 "方针列表" 
364        /// 中的所有 "方针"。
365        /// </summary>
366        public void ClearAll()
367        {
368            lock (lockObject)
369            {
370                policies.Clear();
371            }
372        }
373        #endregion
374
375    }
376}