Util应用程序框架公共操作类(十):可空值类型扩展

　　当你使用可空的值类型时，你会发现取值很不方便，比如Guid? obj，你要从obj中获取值，可以使用Value属性obj. Value，但obj可能为null，这时候就会抛出一个异常。

　　可空值类型提供了一个HasValue属性，它可以识别出obj是不是一个null值，每当你获取可空值都需要加上这个判断if(value.HasValue){ var value = obj.Value;}。

　　下面我们通过几个扩展方法，把判断封装起来。

　　在Util项目中添加Extensions.Nullable.cs，代码如下。

using System;

namespace Util {
    /// <summary>
    /// 扩展 - 可空类型
    /// </summary>
    public static partial class Extensions {
        /// <summary>
        /// 安全返回值
        /// </summary>
        /// <param name="value">可空值</param>
        public static int SafeValue( this int? value ) {
            return value.HasValue ? value.Value : 0;
        }

        /// <summary>
        /// 安全返回值
        /// </summary>
        /// <param name="value">可空值</param>
        public static Guid SafeValue( this Guid? value ) {
            return value.HasValue ? value.Value : Guid.Empty;
        }

        /// <summary>
        /// 安全返回值，为null返回DateTime.MinValue
        /// </summary>
        /// <param name="value">可空值</param>
        public static DateTime SafeValue( this DateTime? value ) {
            return value.HasValue ? value.Value : DateTime.MinValue;
        }

        /// <summary>
        /// 安全返回值
        /// </summary>
        /// <param name="value">可空值</param>
        public static bool SafeValue( this bool? value ) {
            return value.HasValue && value.Value;
        }

        /// <summary>
        /// 安全返回值
        /// </summary>
        /// <param name="value">可空值</param>
        public static double SafeValue( this double? value ) {
            return value.HasValue ? value.Value : 0;
        }

        /// <summary>
        /// 安全返回值
        /// </summary>
        /// <param name="value">可空值</param>
        public static decimal SafeValue( this decimal? value ) {
            return value.HasValue ? value.Value : 0;
        }
    }
}

　　在Util.Tests测试项目的Extensions目录中，添加NullableExtensionTest，代码如下。

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace Util.Tests.Extensions {
    /// <summary>
    /// 可空类型扩展
    /// </summary>
    [TestClass]
    public class NullableExtensionTest {
        /// <summary>
        /// 测试可空整型
        /// </summary>
        [TestMethod]
        public void TestSafeValue_Int() {
            int? value = null;
            Assert.AreEqual( 0, value.SafeValue() );

            value = 1;
            Assert.AreEqual( 1, value.SafeValue() );
        }

        /// <summary>
        /// 测试可空Guid
        /// </summary>
        [TestMethod]
        public void TestSafeValue_Guid() {
            Guid? value = null;
            Assert.AreEqual( Guid.Empty, value.SafeValue() );

            value = Guid.NewGuid();
            Assert.AreEqual( value.Value, value.SafeValue() );
        }

        /// <summary>
        /// 测试可空DateTime
        /// </summary>
        [TestMethod]
        public void TestSafeValue_DateTime() {
            DateTime? value = null;
            Assert.AreEqual( DateTime.MinValue, value.SafeValue() );

            value = Conv.ToDate( "2000-1-1" );
            Assert.AreEqual( value.Value, value.SafeValue() );
        }

        /// <summary>
        /// 测试可空bool
        /// </summary>
        [TestMethod]
        public void TestSafeValue_Boolean() {
            bool? value = null;
            Assert.AreEqual( false, value.SafeValue() );

            value = true;
            Assert.AreEqual( true, value.SafeValue() );
        }

        /// <summary>
        /// 测试可空double
        /// </summary>
        [TestMethod]
        public void TestSafeValue_Double() {
            double? value = null;
            Assert.AreEqual( 0, value.SafeValue() );

            value = 1.1;
            Assert.AreEqual( 1.1, value.SafeValue() );
        }

        /// <summary>
        /// 测试可空decimal
        /// </summary>
        [TestMethod]
        public void TestSafeValue_Decimal() {
            decimal? value = null;
            Assert.AreEqual( 0, value.SafeValue() );

            value = 1.1M;
            Assert.AreEqual( 1.1M, value.SafeValue() );
        }
    }
}

 

　　以后通过SafeValue方法就可以安全的获取可空值类型了。

 　　calvinK同学给出一个更好的方案，代码如下，在此表示感谢。

namespace Util {
    /// <summary>
    /// 扩展 - 可空类型
    /// </summary>
    public static partial class Extensions {
        /// <summary>
        /// 安全返回值
        /// </summary>
        /// <param name="value">可空值</param>
        public static T SafeValue<T>( this T? value ) where T : struct {
            return value ?? default( T );
        }
    }
}

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

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

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