Util应用程序框架公共操作类(二):数据类型转换公共操作类（源码篇）

　　上一篇介绍了数据类型转换的一些情况，可以看出，如果不进行封装，有可能导致比较混乱的代码。本文通过TDD方式把数据类型转换公共操作类开发出来，并提供源码下载。

　　我们在应用程序框架实战十一:创建VS解决方案与程序集一文已经创建了解决方案，包含一个类库项目和一个单元测试项目。单元测试将使用.Net自带的 MsTest，另外通过Resharper工具来观察测试结果。

　　首先考虑我们期望的API长成什么样子。基于TDD开发，其中一个作用是帮助程序员设计期望的API，这称为意图导向编程。

　　因为数据类型转换是Convert，所以我们先在单元测试项目中创建一个ConvertTest的类文件。

　　类创建好以后，我先随便创建一个方法Test，以迅速展开工作。测试的方法名Test，我是随便起的，因为现在还不清楚API是什么样，我一会再回过头来改。

using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Util.Tests {
    /// <summary>
    /// 类型转换公共操作类测试
    /// </summary>
    [TestClass]
    public class ConvertTest {
        [TestMethod]
        public void Test() {
        }
    }
}

　　为了照顾还没有使用单元测试的朋友，我在这里简单介绍一下MsTest。MsTest是.Net仿照JUnit打造的一个单元测试框架。在单元测试类上需要添加一个TestClass特性，在测试方法上添加TestMethod特性，用来识别哪些类的操作需要测试。还有一些其它特性，在用到的时候我再介绍。

　　现在先来实现一个最简单的功能，把字符串”1”转换为整数1。

[TestMethod]
public void Test() {
    Assert.AreEqual( 1, Util.ConvertHelper.ToInt( "1" ) );
}

　　我把常用公共操作类尽量放到顶级命名空间Util，这样我就可以通过编写Util.来弹出代码提示，这样我连常用类也不用记了。

　　使用ConvertHelper是一个常规命名，大多数开发人员可以理解它是一个类型转换的公共操作类。我也这样用了多年，不过后面我发现Util.ConvertHelper有点啰嗦，所以我简化成Util.Convert,但Convert又和系统重名了，所以我现在使用Util.Conv，你不一定要按我的这个命名，你可以使用ConvertHelper这样的命名以提高代码清晰度。

　　System.Convert使用ToInt32来精确表示int是一个32位的数字，不过我们的公共操作类不用这样精确，ToInt就可以了，如果要封装ToInt64呢，我就用ToLong，这样比较符合我的习惯。

　　现在代码被简化成了下面的代码。

Assert.AreEqual( 1, Util.Conv.ToInt( "1" ) );

　　Assert在测试中用来断言，断言就是比较实际计算出来的值是否和预期一致，Assert包含大量比较方法，AreEqual使用频率最高，用来比较预期值（左边）与实际值（右边）是否值相等，还有一个AreSame方法用来比较是否引用相等。

　　由于Conv类还未创建，所以显示一个红色警告。现在在Util类库项目中创建一个Conv类。

　　创建了Conv类以后，单元测试代码检测到Conv，但ToInt方法未创建，所以红色警告转移到ToInt方法。

　　现在用鼠标左键单击红色ToInit方法，Resharper在左侧显示一个红色的灯泡。

　　单击红色灯泡提示，选择第一项”Create Method ‘Conv.ToInt’”。

　　Resharper会在Conv类中自动创建一个ToInt方法。

public class Conv {
    public static int ToInt( string s ) {
        throw new NotImplementedException();
     }
}

　　方法体抛出一个未实现的异常，这正是我们想要的。TDD的口诀是“红、绿、重构”，第一步需要先保证方法执行失败，显示红色警告。至于未何需要测试先行，以及首先执行失败，牵扯TDD开发价值观，请大家参考相关资料。

　　准备工作已经就绪，现在可以运行测试了。安装了Resharper以后，在添加了TestClass特性的左侧，会看见两个重叠在一起的圆形图标。另外，在TestMethod特性左侧，有一个黑白相间的圆形图标。

　　单击Test方法左侧的图标，然后点击Run按钮。如果单击TestClass特性左侧的图标，会运行该类所有测试。

　　测试开始运行，并显示红色警告，提示未实现的异常，第一步完成。

　　为了实现功能，现在来添加ToInt方法的代码。

public static int ToInt( string s ) {
    int result;
    int.TryParse( s, out result );
    return result;
}

　　再次运行测试，已经能够成功通过，第二步完成。

　　第三步是进行重构，现在看哪些地方可以重构。参数s看起来有点不爽，改成data，并添加XML注释。

        /// <summary>
        /// 转换为整型
        /// </summary>
        /// <param name="data">数据</param>
        public static int ToInt( string data ) {
            int result;
            int.TryParse( data, out result );
            return result;
        }

　　另外重构一下测试，为了更容易找到相关测试，一般测试文件名使用类名+Test，现在测试文件名改成ConvTest.cs，测试类名改成ConvTest。把测试方法名改成TestToInt，并添加XML注释。

        /// <summary>
        /// 测试转换为整型
        /// </summary>
        [TestMethod]
        public void TestToInt() {
            Assert.AreEqual( 1, Util.Conv.ToInt( "1" ) );
        }

　　关于测试的命名，很多著作都提出了自己不同的方法。在《.Net单元测试艺术》中，作者建议使用三部分进行组合命名。还有一些著作建议将测试内容用下划线分隔单词，拼成一个长句子，以方便阅读和理解。这可能对英文水平好的人很有效，不过我的英文水平很烂，我拿一些单词拼成一个长句以后，发现更难理解了。所以我所采用的测试方法命名可能不一定好，你可以按你容易理解的方式来命名。

　　重构之后，需要重新测试代码，以观察是否导致失败。

　　上面简单介绍了TDD的一套开发流程，主要为了照顾还没有体验过单元测试的人，后面直接粘贴代码，以避免这样低效的叙述方式。

　　单元测试代码如下。

  1 using System;
  2 using Microsoft.VisualStudio.TestTools.UnitTesting;
  3 
  4 namespace Util.Tests {
  5     /// <summary>
  6     /// 类型转换公共操作类测试
  7     /// </summary>
  8     [TestClass]
  9     public class ConvTest {
 10 
 11         #region ToInt(转换为整型)
 12 
 13         /// <summary>
 14         ///转换为整型,值为null
 15         ///</summary>
 16         [TestMethod]
 17         public void TestToInt_Null() {
 18             Assert.AreEqual( 0, Util.Conv.ToInt( null ) );
 19         }
 20 
 21         /// <summary>
 22         ///转换为整型,值为空字符串
 23         ///</summary>
 24         [TestMethod]
 25         public void TestToInt_Empty() {
 26             Assert.AreEqual( 0, Util.Conv.ToInt( "" ) );
 27         }
 28 
 29         /// <summary>
 30         ///转换为整型,无效值
 31         ///</summary>
 32         [TestMethod]
 33         public void TestToInt_Invalid() {
 34             Assert.AreEqual( 0, Util.Conv.ToInt( "1A" ) );
 35         }
 36 
 37         /// <summary>
 38         ///转换为整型,有效值
 39         ///</summary>
 40         [TestMethod]
 41         public void TestToInt() {
 42             Assert.AreEqual( 1, Util.Conv.ToInt( "1" ) );
 43             Assert.AreEqual( 1778020, Util.Conv.ToInt( "1778019.7801684" ) );
 44         }
 45 
 46         #endregion
 47 
 48         #region ToIntOrNull(转换为可空整型)
 49 
 50         /// <summary>
 51         ///转换为可空整型,值为null
 52         ///</summary>
 53         [TestMethod]
 54         public void TestToIntOrNull_Null() {
 55             Assert.IsNull( Util.Conv.ToIntOrNull( null ) );
 56         }
 57 
 58         /// <summary>
 59         ///转换为可空整型,值为空字符串
 60         ///</summary>
 61         [TestMethod]
 62         public void TestToIntOrNull_Empty() {
 63             Assert.IsNull( Util.Conv.ToIntOrNull( "" ) );
 64         }
 65 
 66         /// <summary>
 67         ///转换为可空整型,无效值
 68         ///</summary>
 69         [TestMethod]
 70         public void TestToIntOrNull_Invalid() {
 71             Assert.IsNull( Util.Conv.ToIntOrNull( "1A" ) );
 72         }
 73 
 74         /// <summary>
 75         ///转换为可空整型,值为0
 76         ///</summary>
 77         [TestMethod]
 78         public void TestToIntOrNull_0() {
 79             Assert.AreEqual( 0, Util.Conv.ToIntOrNull( "0" ) );
 80         }
 81 
 82         /// <summary>
 83         ///转换为可空整型,有效值
 84         ///</summary>
 85         [TestMethod]
 86         public void TestToIntOrNull() {
 87             Assert.AreEqual( 1, Util.Conv.ToIntOrNull( "1" ) );
 88         }
 89 
 90         #endregion
 91 
 92         #region ToDouble(转换为双精度浮点数)
 93 
 94         /// <summary>
 95         ///转换为双精度浮点数,值为null
 96         ///</summary>
 97         [TestMethod]
 98         public void TestToDouble_Null() {
 99             Assert.AreEqual( 0, Util.Conv.ToDouble( null ) );
100         }
101 
102         /// <summary>
103         ///转换为双精度浮点数,值为空字符串
104         ///</summary>
105         [TestMethod]
106         public void TestToDouble_Empty() {
107             Assert.AreEqual( 0, Util.Conv.ToDouble( "" ) );
108         }
109 
110         /// <summary>
111         ///转换为双精度浮点数,无效值
112         ///</summary>
113         [TestMethod]
114         public void TestToDouble_Invalid() {
115             Assert.AreEqual( 0, Util.Conv.ToDouble( "1A" ) );
116         }
117 
118         /// <summary>
119         ///转换为双精度浮点数,有效值
120         ///</summary>
121         [TestMethod]
122         public void TestToDouble() {
123             Assert.AreEqual( 1.2, Util.Conv.ToDouble( "1.2" ) );
124         }
125 
126         /// <summary>
127         /// 转换为双精度浮点数,指定2位小数位数
128         ///</summary>
129         [TestMethod()]
130         public void TestToDouble_DigitsIs2() {
131             Assert.AreEqual( 12.36, Util.Conv.ToDouble( "12.355", 2 ) );
132         }
133 
134         #endregion
135 
136         #region ToDoubleOrNull(转换为可空双精度浮点数)
137 
138         /// <summary>
139         ///转换为可空双精度浮点数,值为null
140         ///</summary>
141         [TestMethod]
142         public void TestToDoubleOrNull_Null() {
143             Assert.IsNull( Util.Conv.ToDoubleOrNull( null ) );
144         }
145 
146         /// <summary>
147         ///转换为可空双精度浮点数,值为空字符串
148         ///</summary>
149         [TestMethod]
150         public void TestToDoubleOrNull_Empty() {
151             Assert.IsNull( Util.Conv.ToDoubleOrNull( "" ) );
152         }
153 
154         /// <summary>
155         ///转换为可空双精度浮点数,无效值
156         ///</summary>
157         [TestMethod]
158         public void TestToDoubleOrNull_Invalid() {
159             Assert.IsNull( Util.Conv.ToDoubleOrNull( "1A" ) );
160         }
161 
162         /// <summary>
163         ///转换为可空双精度浮点数,值为0
164         ///</summary>
165         [TestMethod]
166         public void TestToDoubleOrNull_0() {
167             Assert.AreEqual( 0, Util.Conv.ToDoubleOrNull( "0" ) );
168         }
169 
170         /// <summary>
171         ///转换为可空双精度浮点数,有效值
172         ///</summary>
173         [TestMethod]
174         public void TestToDoubleOrNull() {
175             Assert.AreEqual( 1.2, Util.Conv.ToDoubleOrNull( "1.2" ) );
176         }
177 
178         #endregion
179 
180         #region ToDecimal(转换为高精度浮点数)
181 
182         /// <summary>
183         ///转换为高精度浮点数,值为null
184         ///</summary>
185         [TestMethod]
186         public void TestToDecimal_Null() {
187             Assert.AreEqual( 0, Util.Conv.ToDecimal( null ) );
188         }
189 
190         /// <summary>
191         ///转换为高精度浮点数,值为空字符串
192         ///</summary>
193         [TestMethod]
194         public void TestToDecimal_Empty() {
195             Assert.AreEqual( 0, Util.Conv.ToDecimal( "" ) );
196         }
197 
198         /// <summary>
199         ///转换为高精度浮点数,无效值
200         ///</summary>
201         [TestMethod]
202         public void TestToDecimal_Invalid() {
203             Assert.AreEqual( 0, Util.Conv.ToDecimal( "1A" ) );
204         }
205 
206         /// <summary>
207         ///转换为高精度浮点数,有效值
208         ///</summary>
209         [TestMethod]
210         public void TestToDecimal() {
211             Assert.AreEqual( 1.2M, Util.Conv.ToDecimal( "1.2" ) );
212         }
213 
214         /// <summary>
215         /// 转换为高精度浮点数,指定2位小数位数
216         ///</summary>
217         [TestMethod()]
218         public void TestToDecimal_DigitsIs2() {
219             Assert.AreEqual( 12.24M, Util.Conv.ToDecimal( "12.235", 2 ) );
220         }
221 
222         #endregion
223 
224         #region ToDecimalOrNull(转换为可空高精度浮点数)
225 
226         /// <summary>
227         ///转换为可空高精度浮点数,值为null
228         ///</summary>
229         [TestMethod]
230         public void TestToDecimalOrNull_Null() {
231             Assert.IsNull( Util.Conv.ToDecimalOrNull( null ) );
232         }
233 
234         /// <summary>
235         ///转换为可空高精度浮点数,值为空字符串
236         ///</summary>
237         [TestMethod]
238         public void TestToDecimalOrNull_Empty() {
239             Assert.IsNull( Util.Conv.ToDecimalOrNull( "" ) );
240         }
241 
242         /// <summary>
243         ///转换为可空高精度浮点数,无效值
244         ///</summary>
245         [TestMethod]
246         public void TestToDecimalOrNull_Invalid() {
247             Assert.IsNull( Util.Conv.ToDecimalOrNull( "1A" ) );
248         }
249 
250         /// <summary>
251         ///转换为可空高精度浮点数,无效值,指定2位小数位数
252         ///</summary>
253         [TestMethod]
254         public void TestToDecimalOrNull_Invalid_DigitsIs2() {
255             Assert.IsNull( Util.Conv.ToDecimalOrNull( "1A", 2 ) );
256         }
257 
258         /// <summary>
259         ///转换为可空高精度浮点数,值为0
260         ///</summary>
261         [TestMethod]
262         public void TestToDecimalOrNull_0() {
263             Assert.AreEqual( 0, Util.Conv.ToDecimalOrNull( "0" ) );
264         }
265 
266         /// <summary>
267         ///转换为可空高精度浮点数,有效值
268         ///</summary>
269         [TestMethod]
270         public void TestToDecimalOrNull() {
271             Assert.AreEqual( 1.2M, Util.Conv.ToDecimalOrNull( "1.2" ) );
272         }
273 
274         /// <summary>
275         /// 转换为可空高精度浮点数,指定2位小数位数
276         ///</summary>
277         [TestMethod()]
278         public void ToDecimalOrNull_DigitsIs2() {
279             Assert.AreEqual( 12.24M, Util.Conv.ToDecimalOrNull( "12.235", 2 ) );
280         }
281 
282         #endregion
283 
284         #region ToGuid(转换为Guid)
285 
286         /// <summary>
287         ///转换为Guid,值为null
288         ///</summary>
289         [TestMethod]
290         public void TestToGuid_Null() {
291             Assert.AreEqual( Guid.Empty, Util.Conv.ToGuid( null ) );
292         }
293 
294         /// <summary>
295         ///转换为Guid,值为空字符串
296         ///</summary>
297         [TestMethod]
298         public void TestToGuid_Empty() {
299             Assert.AreEqual( Guid.Empty, Util.Conv.ToGuid( "" ) );
300         }
301 
302         /// <summary>
303         ///转换为Guid,无效值
304         ///</summary>
305         [TestMethod]
306         public void TestToGuid_Invalid() {
307             Assert.AreEqual( Guid.Empty, Util.Conv.ToGuid( "1A" ) );
308         }
309 
310         /// <summary>
311         ///转换为Guid,有效值
312         ///</summary>
313         [TestMethod]
314         public void TestToGuid() {
315             Assert.AreEqual( new Guid( "B9EB56E9-B720-40B4-9425-00483D311DDC" ), Util.Conv.ToGuid( "B9EB56E9-B720-40B4-9425-00483D311DDC" ) );
316         }
317 
318         #endregion
319 
320         #region ToGuidOrNull(转换为可空Guid)
321 
322         /// <summary>
323         ///转换为可空Guid,值为null
324         ///</summary>
325         [TestMethod]
326         public void TestToGuidOrNull_Null() {
327             Assert.IsNull( Util.Conv.ToGuidOrNull( null ) );
328         }
329 
330         /// <summary>
331         ///转换为可空Guid,值为空字符串
332         ///</summary>
333         [TestMethod]
334         public void TestToGuidOrNull_Empty() {
335             Assert.IsNull( Util.Conv.ToGuidOrNull( "" ) );
336         }
337 
338         /// <summary>
339         ///转换为可空Guid,无效值
340         ///</summary>
341         [TestMethod]
342         public void TestToGuidOrNull_Invalid() {
343             Assert.IsNull( Util.Conv.ToGuidOrNull( "1A" ) );
344         }
345 
346         /// <summary>
347         ///转换为可空Guid,有效值
348         ///</summary>
349         [TestMethod]
350         public void TestToGuidOrNull() {
351             Assert.AreEqual( new Guid( "B9EB56E9-B720-40B4-9425-00483D311DDC" ), Util.Conv.ToGuidOrNull( "B9EB56E9-B720-40B4-9425-00483D311DDC" ) );
352         }
353 
354         #endregion
355 
356         #region ToGuidList(转换为Guid集合)
357 
358         /// <summary>
359         /// 转换为Guid集合,验证空字符串
360         /// </summary>
361         [TestMethod]
362         public void TestToGuidList_Empty() {
363             Assert.AreEqual( 0, Util.Conv.ToGuidList( "" ).Count );
364         }
365 
366         /// <summary>
367         /// 转换为Guid集合,验证最后为逗号
368         /// </summary>
369         [TestMethod]
370         public void TestToGuidList_LastIsComma() {
371             Assert.AreEqual( 1, Util.Conv.ToGuidList( "83B0233C-A24F-49FD-8083-1337209EBC9A," ).Count );
372         }
373 
374         /// <summary>
375         /// 转换为Guid集合,验证中间包含逗号
376         /// </summary>
377         [TestMethod]
378         public void TestToGuidList_MiddleIsComma() {
379             const string guid = "83B0233C-A24F-49FD-8083-1337209EBC9A,,EAB523C6-2FE7-47BE-89D5-C6D440C3033A,";
380             Assert.AreEqual( 2, Util.Conv.ToGuidList( guid ).Count );
381             Assert.AreEqual( new Guid( "83B0233C-A24F-49FD-8083-1337209EBC9A" ), Util.Conv.ToGuidList( guid )[0] );
382             Assert.AreEqual( new Guid( "EAB523C6-2FE7-47BE-89D5-C6D440C3033A" ), Util.Conv.ToGuidList( guid )[1] );
383         }
384 
385         /// <summary>
386         /// 转换为Guid集合,仅1个Guid
387         /// </summary>
388         [TestMethod]
389         public void TestToGuidList_1Guid() {
390             const string guid = "83B0233C-A24F-49FD-8083-1337209EBC9A";
391             Assert.AreEqual( 1, Util.Conv.ToGuidList( guid ).Count );
392             Assert.AreEqual( new Guid( guid ), Util.Conv.ToGuidList( guid )[0] );
393         }
394 
395         /// <summary>
396         /// 转换为Guid集合,2个Guid
397         /// </summary>
398         [TestMethod]
399         public void TestToGuidList_2Guid() {
400             const string guid = "83B0233C-A24F-49FD-8083-1337209EBC9A,EAB523C6-2FE7-47BE-89D5-C6D440C3033A";
401             Assert.AreEqual( 2, Util.Conv.ToGuidList( guid ).Count );
402             Assert.AreEqual( new Guid( "83B0233C-A24F-49FD-8083-1337209EBC9A" ), Util.Conv.ToGuidList( guid )[0] );
403             Assert.AreEqual( new Guid( "EAB523C6-2FE7-47BE-89D5-C6D440C3033A" ), Util.Conv.ToGuidList( guid )[1] );
404         }
405 
406         #endregion
407 
408         #region ToDate(转换为日期)
409 
410         /// <summary>
411         ///转换为日期,值为null
412         ///</summary>
413         [TestMethod]
414         public void TestToDate_Null() {
415             Assert.AreEqual( DateTime.MinValue, Util.Conv.ToDate( null ) );
416         }
417 
418         /// <summary>
419         ///转换为日期,值为空字符串
420         ///</summary>
421         [TestMethod]
422         public void TestToDate_Empty() {
423             Assert.AreEqual( DateTime.MinValue, Util.Conv.ToDate( "" ) );
424         }
425 
426         /// <summary>
427         ///转换为日期,无效值
428         ///</summary>
429         [TestMethod]
430         public void TestToDate_Invalid() {
431             Assert.AreEqual( DateTime.MinValue, Util.Conv.ToDate( "1A" ) );
432         }
433 
434         /// <summary>
435         ///转换为日期,有效值
436         ///</summary>
437         [TestMethod]
438         public void TestToDate() {
439             Assert.AreEqual( new DateTime( 2000, 1, 1 ), Util.Conv.ToDate( "2000-1-1" ) );
440         }
441 
442         #endregion
443 
444         #region ToDateOrNull(转换为可空日期)
445 
446         /// <summary>
447         ///转换为可空日期,值为null
448         ///</summary>
449         [TestMethod]
450         public void TestToDateOrNull_Null() {
451             Assert.IsNull( Util.Conv.ToDateOrNull( null ) );
452         }
453 
454         /// <summary>
455         ///转换为可空日期,值为空字符串
456         ///</summary>
457         [TestMethod]
458         public void TestToDateOrNull_Empty() {
459             Assert.IsNull( Util.Conv.ToDateOrNull( "" ) );
460         }
461 
462         /// <summary>
463         ///转换为可空日期,无效值
464         ///</summary>
465         [TestMethod]
466         public void TestToDateOrNull_Invalid() {
467             Assert.IsNull( Util.Conv.ToDateOrNull( "1A" ) );
468         }
469 
470         /// <summary>
471         ///转换为可空日期,有效值
472         ///</summary>
473         [TestMethod]
474         public void TestToDateOrNull() {
475             Assert.AreEqual( new DateTime( 2000, 1, 1 ), Util.Conv.ToDateOrNull( "2000-1-1" ) );
476         }
477 
478         #endregion
479 
480         #region ToBool(转换为布尔值)
481 
482         /// <summary>
483         ///转换为布尔值,值为null
484         ///</summary>
485         [TestMethod]
486         public void TestToBool_Null() {
487             Assert.AreEqual( false, Util.Conv.ToBool( null ) );
488         }
489 
490         /// <summary>
491         ///转换为布尔值,值为空字符串
492         ///</summary>
493         [TestMethod]
494         public void TestToBool_Empty() {
495             Assert.AreEqual( false, Util.Conv.ToBool( "" ) );
496         }
497 
498         /// <summary>
499         ///转换为布尔值,无效值
500         ///</summary>
501         [TestMethod]
502         public void TestToBool_Invalid() {
503             Assert.AreEqual( false, Util.Conv.ToBool( "1A" ) );
504         }
505 
506         /// <summary>
507         ///转换为布尔值,值为False
508         ///</summary>
509         [TestMethod]
510         public void TestToBool_False() {
511             Assert.AreEqual( false, Util.Conv.ToBool( "0" ) );
512             Assert.AreEqual( false, Util.Conv.ToBool( "否" ) );
513             Assert.AreEqual( false, Util.Conv.ToBool( "no" ) );
514             Assert.AreEqual( false, Util.Conv.ToBool( "No" ) );
515             Assert.AreEqual( false, Util.Conv.ToBool( "false" ) );
516             Assert.AreEqual( false, Util.Conv.ToBool( "False" ) );
517         }
518 
519         /// <summary>
520         ///转换为布尔值,值为True
521         ///</summary>
522         [TestMethod]
523         public void TestToBool_True() {
524             Assert.AreEqual( true, Util.Conv.ToBool( "1" ) );
525             Assert.AreEqual( true, Util.Conv.ToBool( "是" ) );
526             Assert.AreEqual( true, Util.Conv.ToBool( "yes" ) );
527             Assert.AreEqual( true, Util.Conv.ToBool( "Yes" ) );
528             Assert.AreEqual( true, Util.Conv.ToBool( "true" ) );
529             Assert.AreEqual( true, Util.Conv.ToBool( "True" ) );
530         }
531 
532         #endregion
533 
534         #region ToBoolOrNull(转换为可空布尔值)
535 
536         /// <summary>
537         ///转换为可空布尔值,值为null
538         ///</summary>
539         [TestMethod]
540         public void TestToBoolOrNull_Null() {
541             Assert.IsNull( Util.Conv.ToBoolOrNull( null ) );
542         }
543 
544         /// <summary>
545         ///转换为可空布尔值,值为空字符串
546         ///</summary>
547         [TestMethod]
548         public void TestToBoolOrNull_Empty() {
549             Assert.IsNull( Util.Conv.ToBoolOrNull( "" ) );
550         }
551 
552         /// <summary>
553         ///转换为可空布尔值,无效值
554         ///</summary>
555         [TestMethod]
556         public void TestToBoolOrNull_Invalid() {
557             Assert.IsNull( Util.Conv.ToBoolOrNull( "1A" ) );
558         }
559 
560         /// <summary>
561         ///转换为布尔值,值为False
562         ///</summary>
563         [TestMethod]
564         public void TestToBoolOrNull_False() {
565             Assert.AreEqual( false, Util.Conv.ToBoolOrNull( "0" ) );
566             Assert.AreEqual( false, Util.Conv.ToBoolOrNull( "否" ) );
567             Assert.AreEqual( false, Util.Conv.ToBoolOrNull( "no" ) );
568             Assert.AreEqual( false, Util.Conv.ToBoolOrNull( "No" ) );
569             Assert.AreEqual( false, Util.Conv.ToBoolOrNull( "false" ) );
570             Assert.AreEqual( false, Util.Conv.ToBoolOrNull( "False" ) );
571         }
572 
573         /// <summary>
574         ///转换为布尔值,值为True
575         ///</summary>
576         [TestMethod]
577         public void TestToBoolOrNull_True() {
578             Assert.AreEqual( true, Util.Conv.ToBoolOrNull( "1" ) );
579             Assert.AreEqual( true, Util.Conv.ToBoolOrNull( "是" ) );
580             Assert.AreEqual( true, Util.Conv.ToBoolOrNull( "yes" ) );
581             Assert.AreEqual( true, Util.Conv.ToBoolOrNull( "Yes" ) );
582             Assert.AreEqual( true, Util.Conv.ToBoolOrNull( "true" ) );
583             Assert.AreEqual( true, Util.Conv.ToBoolOrNull( "True" ) );
584         }
585 
586         #endregion
587 
588         #region ToString(转换为字符串)
589 
590         /// <summary>
591         ///转换为字符串,值为null
592         ///</summary>
593         [TestMethod]
594         public void TestToString_Null() {
595             Assert.AreEqual( string.Empty, Util.Conv.ToString( null ) );
596         }
597 
598         /// <summary>
599         ///转换为字符串,值为空字符串
600         ///</summary>
601         [TestMethod]
602         public void TestToString_Empty() {
603             Assert.AreEqual( string.Empty, Util.Conv.ToString( " " ) );
604         }
605 
606         /// <summary>
607         ///转换为字符串,有效值
608         ///</summary>
609         [TestMethod]
610         public void TestToString() {
611             Assert.AreEqual( "1", Util.Conv.ToString( 1 ) );
612         }
613 
614         #endregion
615 
616         #region To(通用泛型转换)
617 
618         #region 目标为int
619 
620         /// <summary>
621         ///通用泛型转换,目标为整数，值为null
622         ///</summary>
623         [TestMethod]
624         public void TestTo_Int_Null() {
625             Assert.AreEqual( 0, Conv.To<int>( null ) );
626         }
627 
628         /// <summary>
629         ///通用泛型转换,目标为整数,值为空字符串
630         ///</summary>
631         [TestMethod]
632         public void TestTo_Int_Empty() {
633             Assert.AreEqual( 0, Conv.To<int>( "" ) );
634         }
635 
636         /// <summary>
637         ///通用泛型转换,目标为整数,无效值
638         ///</summary>
639         [TestMethod]
640         public void TestTo_Int_Invalid() {
641             Assert.AreEqual( 0, Conv.To<int>( "1A" ) );
642         }
643 
644         /// <summary>
645         ///通用泛型转换,目标为整数,有效值
646         ///</summary>
647         [TestMethod]
648         public void TestTo_Int() {
649             Assert.AreEqual( 1, Conv.To<int>( "1" ) );
650         }
651 
652         /// <summary>
653         ///通用泛型转换,目标为可空整数,无效值
654         ///</summary>
655         [TestMethod]
656         public void TestTo_IntOrNull_Invalid() {
657             Assert.IsNull( Conv.To<int?>( "1A" ) );
658         }
659 
660         /// <summary>
661         ///通用泛型转换,目标为可空整数,有效值
662         ///</summary>
663         [TestMethod]
664         public void TestTo_IntOrNull() {
665             Assert.AreEqual( 1, Conv.To<int?>( "1" ) );
666         }
667 
668         #endregion
669 
670         #region 目标为Guid
671 
672         /// <summary>
673         ///通用泛型转换,目标为Guid,无效值
674         ///</summary>
675         [TestMethod]
676         public void TestTo_Guid_Invalid() {
677             Assert.AreEqual( Guid.Empty, Conv.To<Guid>( "1A" ) );
678         }
679 
680         /// <summary>
681         ///通用泛型转换,目标为Guid,有效值
682         ///</summary>
683         [TestMethod]
684         public void TestTo_Guid() {
685             Assert.AreEqual( new Guid( "B9EB56E9-B720-40B4-9425-00483D311DDC" ),
686                 Conv.To<Guid>( "B9EB56E9-B720-40B4-9425-00483D311DDC" ) );
687         }
688 
689         /// <summary>
690         ///通用泛型转换,目标为可空Guid,无效值
691         ///</summary>
692         [TestMethod]
693         public void TestTo_GuidOrNull_Invalid() {
694             Assert.IsNull( Conv.To<Guid?>( "1A" ) );
695         }
696 
697         /// <summary>
698         ///通用泛型转换,目标为可空Guid,有效值
699         ///</summary>
700         [TestMethod]
701         public void TestTo_GuidOrNull() {
702             Assert.AreEqual( new Guid( "B9EB56E9-B720-40B4-9425-00483D311DDC" ),
703                 Conv.To<Guid?>( "B9EB56E9-B720-40B4-9425-00483D311DDC" ) );
704         }
705 
706         #endregion
707 
708         #region 目标为string
709 
710         /// <summary>
711         ///通用泛型转换,目标为string,有效值
712         ///</summary>
713         [TestMethod]
714         public void TestTo_String() {
715             Assert.AreEqual( "123", Conv.To<string>( 123 ) );
716         }
717 
718         #endregion
719 
720         #region 目标为double
721 
722         /// <summary>
723         ///通用泛型转换,目标为double,无效值
724         ///</summary>
725         [TestMethod]
726         public void TestTo_Double_Invalid() {
727             Assert.AreEqual( 0, Conv.To<double>( "1A" ) );
728         }
729 
730         /// <summary>
731         ///通用泛型转换,目标为double,有效值
732         ///</summary>
733         [TestMethod]
734         public void TestTo_Double() {
735             Assert.AreEqual( 12.5, Conv.To<double>( "12.5" ) );
736         }
737 
738         /// <summary>
739         ///通用泛型转换,目标为可空double,无效值
740         ///</summary>
741         [TestMethod]
742         public void TestTo_DoubleOrNull_Invalid() {
743             Assert.IsNull( Conv.To<double?>( "1A" ) );
744         }
745 
746         /// <summary>
747         ///通用泛型转换,目标为可空double,有效值
748         ///</summary>
749         [TestMethod]
750         public void TestTo_DoubleOrNull() {
751             Assert.AreEqual( 12.5, Conv.To<double?>( "12.5" ) );
752         }
753 
754         #endregion
755 
756         #region 目标为decimal
757 
758         /// <summary>
759         ///通用泛型转换,目标为decimal,无效值
760         ///</summary>
761         [TestMethod]
762         public void TestTo_Decimal_Invalid() {
763             Assert.AreEqual( 0, Conv.To<decimal>( "1A" ) );
764         }
765 
766         /// <summary>
767         ///通用泛型转换,目标为decimal,有效值
768         ///</summary>
769         [TestMethod]
770         public void TestTo_Decimal() {
771             Assert.AreEqual( 12.5M, Conv.To<decimal>( "12.5" ) );
772         }
773 
774         /// <summary>
775         ///通用泛型转换,目标为可空decimal,无效值
776         ///</summary>
777         [TestMethod]
778         public void TestTo_DecimalOrNull_Invalid() {
779             Assert.IsNull( Conv.To<decimal?>( "1A" ) );
780         }
781 
782         /// <summary>
783         ///通用泛型转换,目标为可空decimal,有效值
784         ///</summary>
785         [TestMethod]
786         public void TestTo_DecimalOrNull() {
787             Assert.AreEqual( 12.5M, Conv.To<decimal?>( "12.5" ) );
788         }
789 
790         #endregion
791 
792         #region 目标为bool
793 
794         /// <summary>
795         ///通用泛型转换,目标为bool,无效值
796         ///</summary>
797         [TestMethod]
798         public void TestTo_Bool_Invalid() {
799             Assert.AreEqual( false, Conv.To<bool>( "1A" ) );
800         }
801 
802         /// <summary>
803         ///通用泛型转换,目标为bool,有效值
804         ///</summary>
805         [TestMethod]
806         public void TestTo_Bool() {
807             Assert.AreEqual( true, Conv.To<bool>( 1 ) );
808         }
809 
810         /// <summary>
811         ///通用泛型转换,目标为可空bool,无效值
812         ///</summary>
813         [TestMethod]
814         public void TestTo_BoolOrNull_Invalid() {
815             Assert.IsNull( Conv.To<bool?>( "1A" ) );
816         }
817 
818         /// <summary>
819         ///通用泛型转换,目标为可空bool,有效值
820         ///</summary>
821         [TestMethod]
822         public void TestTo_BoolOrNull() {
823             Assert.AreEqual( true, Conv.To<bool?>( "true" ) );
824         }
825 
826         #endregion
827 
828         #region 目标为DateTime
829 
830         /// <summary>
831         ///通用泛型转换,目标为DateTime,无效值
832         ///</summary>
833         [TestMethod]
834         public void TestTo_DateTime_Invalid() {
835             Assert.AreEqual( DateTime.MinValue, Conv.To<DateTime>( "1A" ) );
836         }
837 
838         /// <summary>
839         ///通用泛型转换,目标为DateTime,有效值
840         ///</summary>
841         [TestMethod]
842         public void TestTo_DateTime() {
843             Assert.AreEqual( new DateTime( 2000, 1, 1 ), Conv.To<DateTime>( "2000-1-1" ) );
844         }
845 
846         /// <summary>
847         ///通用泛型转换,目标为可空DateTime,无效值
848         ///</summary>
849         [TestMethod]
850         public void TestTo_DateTimeOrNull_Invalid() {
851             Assert.IsNull( Conv.To<DateTime?>( "1A" ) );
852         }
853 
854         /// <summary>
855         ///通用泛型转换,目标为可空DateTime,有效值
856         ///</summary>
857         [TestMethod]
858         public void TestTo_DateTimeOrNull() {
859             Assert.AreEqual( new DateTime( 2000, 1, 1 ), Conv.To<DateTime?>( "2000-1-1" ) );
860         }
861 
862         #endregion
863 
864         #endregion
865     }
866 }

ConvTest

　　Conv类代码如下。

  1 using System;
  2 using System.Collections.Generic;
  3 using System.Linq;
  4 
  5 namespace Util {
  6     /// <summary>
  7     /// 类型转换
  8     /// </summary>
  9     public static class Conv {
 10 
 11         #region 数值转换
 12 
 13         /// <summary>
 14         /// 转换为整型
 15         /// </summary>
 16         /// <param name="data">数据</param>
 17         public static int ToInt( object data ) {
 18             if ( data == null )
 19                 return 0;
 20             int result;
 21             var success = int.TryParse( data.ToString(), out result );
 22             if ( success == true )
 23                 return result;
 24             try {
 25                 return Convert.ToInt32( ToDouble( data, 0 ) );
 26             }
 27             catch ( Exception ) {
 28                 return 0;
 29             }
 30         }
 31 
 32         /// <summary>
 33         /// 转换为可空整型
 34         /// </summary>
 35         /// <param name="data">数据</param>
 36         public static int? ToIntOrNull( object data ) {
 37             if ( data == null )
 38                 return null;
 39             int result;
 40             bool isValid = int.TryParse( data.ToString(), out result );
 41             if ( isValid )
 42                 return result;
 43             return null;
 44         }
 45 
 46         /// <summary>
 47         /// 转换为双精度浮点数
 48         /// </summary>
 49         /// <param name="data">数据</param>
 50         public static double ToDouble( object data ) {
 51             if ( data == null )
 52                 return 0;
 53             double result;
 54             return double.TryParse( data.ToString(), out result ) ? result : 0;
 55         }
 56 
 57         /// <summary>
 58         /// 转换为双精度浮点数,并按指定的小数位4舍5入
 59         /// </summary>
 60         /// <param name="data">数据</param>
 61         /// <param name="digits">小数位数</param>
 62         public static double ToDouble( object data, int digits ) {
 63             return Math.Round( ToDouble( data ), digits );
 64         }
 65 
 66         /// <summary>
 67         /// 转换为可空双精度浮点数
 68         /// </summary>
 69         /// <param name="data">数据</param>
 70         public static double? ToDoubleOrNull( object data ) {
 71             if ( data == null )
 72                 return null;
 73             double result;
 74             bool isValid = double.TryParse( data.ToString(), out result );
 75             if ( isValid )
 76                 return result;
 77             return null;
 78         }
 79 
 80         /// <summary>
 81         /// 转换为高精度浮点数
 82         /// </summary>
 83         /// <param name="data">数据</param>
 84         public static decimal ToDecimal( object data ) {
 85             if ( data == null )
 86                 return 0;
 87             decimal result;
 88             return decimal.TryParse( data.ToString(), out result ) ? result : 0;
 89         }
 90 
 91         /// <summary>
 92         /// 转换为高精度浮点数,并按指定的小数位4舍5入
 93         /// </summary>
 94         /// <param name="data">数据</param>
 95         /// <param name="digits">小数位数</param>
 96         public static decimal ToDecimal( object data, int digits ) {
 97             return Math.Round( ToDecimal( data ), digits );
 98         }
 99 
100         /// <summary>
101         /// 转换为可空高精度浮点数
102         /// </summary>
103         /// <param name="data">数据</param>
104         public static decimal? ToDecimalOrNull( object data ) {
105             if ( data == null )
106                 return null;
107             decimal result;
108             bool isValid = decimal.TryParse( data.ToString(), out result );
109             if ( isValid )
110                 return result;
111             return null;
112         }
113 
114         /// <summary>
115         /// 转换为可空高精度浮点数,并按指定的小数位4舍5入
116         /// </summary>
117         /// <param name="data">数据</param>
118         /// <param name="digits">小数位数</param>
119         public static decimal? ToDecimalOrNull( object data, int digits ) {
120             var result = ToDecimalOrNull( data );
121             if ( result == null )
122                 return null;
123             return Math.Round( result.Value, digits );
124         }
125 
126         #endregion
127 
128         #region Guid转换
129 
130         /// <summary>
131         /// 转换为Guid
132         /// </summary>
133         /// <param name="data">数据</param>
134         public static Guid ToGuid( object data ) {
135             if ( data == null )
136                 return Guid.Empty;
137             Guid result;
138             return Guid.TryParse( data.ToString(), out result ) ? result : Guid.Empty;
139         }
140 
141         /// <summary>
142         /// 转换为可空Guid
143         /// </summary>
144         /// <param name="data">数据</param>
145         public static Guid? ToGuidOrNull( object data ) {
146             if ( data == null )
147                 return null;
148             Guid result;
149             bool isValid = Guid.TryParse( data.ToString(), out result );
150             if ( isValid )
151                 return result;
152             return null;
153         }
154 
155         /// <summary>
156         /// 转换为Guid集合
157         /// </summary>
158         /// <param name="guid">guid集合字符串，范例:83B0233C-A24F-49FD-8083-1337209EBC9A,EAB523C6-2FE7-47BE-89D5-C6D440C3033A</param>
159         public static List<Guid> ToGuidList( string guid ) {
160             var listGuid = new List<Guid>();
161             if ( string.IsNullOrWhiteSpace( guid ) )
162                 return listGuid;
163             var arrayGuid = guid.Split( ',' );
164             listGuid.AddRange( from each in arrayGuid where !string.IsNullOrWhiteSpace( each ) select new Guid( each ) );
165             return listGuid;
166         }
167 
168         #endregion
169 
170         #region 日期转换
171 
172         /// <summary>
173         /// 转换为日期
174         /// </summary>
175         /// <param name="data">数据</param>
176         public static DateTime ToDate( object data ) {
177             if ( data == null )
178                 return DateTime.MinValue;
179             DateTime result;
180             return DateTime.TryParse( data.ToString(), out result ) ? result : DateTime.MinValue;
181         }
182 
183         /// <summary>
184         /// 转换为可空日期
185         /// </summary>
186         /// <param name="data">数据</param>
187         public static DateTime? ToDateOrNull( object data ) {
188             if ( data == null )
189                 return null;
190             DateTime result;
191             bool isValid = DateTime.TryParse( data.ToString(), out result );
192             if ( isValid )
193                 return result;
194             return null;
195         }
196 
197         #endregion
198 
199         #region 布尔转换
200 
201         /// <summary>
202         /// 转换为布尔值
203         /// </summary>
204         /// <param name="data">数据</param>
205         public static bool ToBool( object data ) {
206             if ( data == null )
207                 return false;
208             bool? value = GetBool( data );
209             if ( value != null )
210                 return value.Value;
211             bool result;
212             return bool.TryParse( data.ToString(), out result ) && result;
213         }
214 
215         /// <summary>
216         /// 获取布尔值
217         /// </summary>
218         private static bool? GetBool( object data ) {
219             switch ( data.ToString().Trim().ToLower() ) {
220                 case "0":
221                     return false;
222                 case "1":
223                     return true;
224                 case "是":
225                     return true;
226                 case "否":
227                     return false;
228                 case "yes":
229                     return true;
230                 case "no":
231                     return false;
232                 default:
233                     return null;
234             }
235         }
236 
237         /// <summary>
238         /// 转换为可空布尔值
239         /// </summary>
240         /// <param name="data">数据</param>
241         public static bool? ToBoolOrNull( object data ) {
242             if ( data == null )
243                 return null;
244             bool? value = GetBool( data );
245             if ( value != null )
246                 return value.Value;
247             bool result;
248             bool isValid = bool.TryParse( data.ToString(), out result );
249             if ( isValid )
250                 return result;
251             return null;
252         }
253 
254         #endregion
255 
256         #region 字符串转换
257 
258         /// <summary>
259         /// 转换为字符串
260         /// </summary>
261         /// <param name="data">数据</param>
262         public static string ToString( object data ) {
263             return data == null ? string.Empty : data.ToString().Trim();
264         }
265 
266         #endregion
267 
268         #region 通用转换
269 
270         /// <summary>
271         /// 泛型转换
272         /// </summary>
273         /// <typeparam name="T">目标类型</typeparam>
274         /// <param name="data">数据</param>
275         public static T To<T>( object data ) {
276             if ( data == null || string.IsNullOrWhiteSpace( data.ToString() ) )
277                 return default( T );
278             Type type = Nullable.GetUnderlyingType( typeof( T ) ) ?? typeof( T );
279             try {
280                 if ( type.Name.ToLower() == "guid" )
281                     return (T)(object)new Guid( data.ToString() );
282                 if ( data is IConvertible )
283                     return (T)Convert.ChangeType( data, type );
284                 return (T)data;
285             }
286             catch {
287                 return default( T );
288             }
289         }
290 
291         #endregion
292     }
293 }

Conv

　　Conv公共操作类的用法，在单元测试中已经说得很清楚了，这也是单元测试的一个用途，即作为API说明文档。

　　单元测试最强大的地方，可能是能够帮助你回归测试，如果你发现我的代码有BUG，请通知我一声，我只需要在单元测试中增加一个测试来捕获这个BUG，就可以永久修复它，并且由于采用TDD方式可以获得很高的测试覆盖率，所以我花上几秒钟运行一下全部测试，就可以知道这次修改有没有影响其它代码。这也是你创建自己的应用程序框架所必须要做的，它可以给你提供信心。

　　可以看到，我在单元测试中进行了很多边界测试，比如参数为null或空字符串等。但不可能穷举所有可能出错的情况，因为可能想不到，另外时间有限，也不可能做到。当在项目上发现BUG后，再通过添加单元测试的方式修复BUG就可以了。由于你的项目代码调用的是应用程序框架API，所以你只需要在框架内修复一次，项目代码完全不动。

　　像数据类型转换这样简单的操作，你发现写单元测试非常容易，因为它有明确的返回值，但如果没有返回值呢,甚至有外部依赖呢，那就没有这么简单了，需要很多技巧，所以你多看几本TDD和单元测试方面的著作有很多好处。

　　另外，再补充一下，Conv这个类里面有几个法宝。一个是ToGuidList这个方法，当你需要把字符串转换为List<Guid>的时候就用它。还有一个泛型转换的方法To<T>，很多时候可以用它进行泛型转换。

　　最后，我把所有方法参数类型都改成了object，主要是想使用起来方便一点，而不是只支持字符串参数，这可能导致装箱和拆箱，从而造成一些性能损失，不过我的大多数项目在性能方面还没有这么高的要求，所以这个损失对我来讲无关痛痒。

　　还有些数据类型转换，我没有放进来，主要是我平时很少用到，当我用到时再增加。

　　.Net应用程序框架交流QQ群: 386092459，欢迎有兴趣的朋友加入讨论。

　　谢谢大家的持续关注，我的博客地址：http://www.cnblogs.com/xiadao521/

　　下载地址: http://files.cnblogs.com/xiadao521/Util.2014.11.12.1.rar