【开源】OSharp框架解说系列（3）：扩展方法

前言

　　以上摘自MSDN的扩展方法描述，可见扩展方法是个很实用的语法糖，用过都说好。

　　OSharp 框架中也定义（收集）了不少非常实用的扩展方法，位于工具组件OSharp.Utility.dll中，命名空间为OSharp.Utility.Extensions，下面我们来一一分解。

　　注：本篇都是非常基础的代码，代码的功能都有注释，可讲的东西不多，思想性的东西就更少了，不想看代码的可以跳过本篇。

　　声明：本文的扩展方法部分出自原创，部分收集整理于互联网（出处已不可考），冒犯之处望见谅。

　　代码总览：

　　

泛型扩展

　　泛型扩展，如果没有类型限定，基本上就是 Object 类型的扩展。因为所有类型都继承自Object类型的，如果给Objext类型定义扩展方法，那么所有的类型都会增加这个方法，有时候反而会阻碍编码流畅性。

数据类型转换

　　在编码的过程中，经常会遇到数据类型转换的需求，为了方便统一，我们可以定义一个通用的类型转换扩展方法。

/// <summary>
/// 把对象类型转换为指定类型
/// </summary>
/// <param name="value"></param>
/// <param name="conversionType"></param>
/// <returns></returns>
public static object CastTo(this object value, Type conversionType)
{
if (value == null)
{
return null;
}
if (conversionType.IsNullableType())
{
conversionType = conversionType.GetUnNullableType();
}
if (conversionType.IsEnum)
{
return Enum.Parse(conversionType, value.ToString());
}
if (conversionType == typeof(Guid))
{
return Guid.Parse(value.ToString());
}
return Convert.ChangeType(value, conversionType);
}

/// <summary>
/// 把对象类型转化为指定类型
/// </summary>
/// <typeparam name="T"> 动态类型 </typeparam>
/// <param name="value"> 要转化的源对象 </param>
/// <returns> 转化后的指定类型的对象，转化失败引发异常。 </returns>
public static T CastTo<T>(this object value)
{
object result = CastTo(value, typeof(T));
return (T)result;
}

/// <summary>
/// 把对象类型转化为指定类型，转化失败时返回指定的默认值
/// </summary>
/// <typeparam name="T"> 动态类型 </typeparam>
/// <param name="value"> 要转化的源对象 </param>
/// <param name="defaultValue"> 转化失败返回的指定默认值 </param>
/// <returns> 转化后的指定类型对象，转化失败时返回指定的默认值 </returns>
public static T CastTo<T>(this object value, T defaultValue)
{
try
{
return CastTo<T>(value);
}
catch (Exception)
{
return defaultValue;
}
}

　　使用示例：

Assert.AreEqual(((object)null).CastTo<object>(), null);
Assert.AreEqual("123".CastTo<int>(), 123);
Assert.AreEqual(123.CastTo<string>(), "123");
Assert.AreEqual(true.CastTo<string>(), "True");
Assert.AreEqual("true".CastTo<bool>(), true);
Assert.AreEqual("56D768A3-3D74-43B4-BD7B-2871D675CC4B".CastTo<Guid>(), new Guid("56D768A3-3D74-43B4-BD7B-2871D675CC4B"));
Assert.AreEqual(1.CastTo<UriKind>(), UriKind.Absolute);
Assert.AreEqual("RelativeOrAbsolute".CastTo<UriKind>(), UriKind.RelativeOrAbsolute);
Assert.AreEqual("abc".CastTo<int>(123), 123);
ExceptionAssert.IsException<FormatException>(() => "abc".CastTo<int>());

JSON序列化

　　很多时候都要把对象序列化成JSON字符串，又不想让项目到处依赖于JSON.NET这个第三方类库，定义一个JSON序列化的扩展方法，让工具组件来引用JSON.NET做这件事吧

/// <summary>
/// 将对象序列化为JSON字符串，不支持存在循环引用的对象
/// </summary>
/// <typeparam name="T">动态类型</typeparam>
/// <param name="value">动态类型对象</param>
/// <returns>JSON字符串</returns>
public static string ToJsonString<T>(this T value)
{
return JsonConvert.SerializeObject(value);
}

　　有来有往，JSON反序列化：

/// <summary>
/// 将JSON字符串还原为对象
/// </summary>
/// <typeparam name="T">要转换的目标类型</typeparam>
/// <param name="json">JSON字符串 </param>
/// <returns></returns>
public static T FromJsonString<T>(this string json)
{
json.CheckNotNull("json");
return JsonConvert.DeserializeObject<T>(json);
}

MVC中的View直接使用 linq to entities 查询出来的匿名对象

　　EntityFramework 使用 linq 查询匿名结果的方式很好用，性能又好，爽呆了，但由于匿名结果的可访问性是 internal，可是不能直接返回给View（View在编译之后是另外一个程序集了，internal不能跨程序集）使用，来个扩展方法专门把匿名对象转换为dynamic吧

/// <summary>
/// 将对象[主要是匿名对象]转换为dynamic
/// </summary>
public static dynamic ToDynamic(this object value)
{
IDictionary<string, object> expando = new ExpandoObject();
Type type = value.GetType();
PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(type);
foreach (PropertyDescriptor property in properties)
{
var val = property.GetValue(value);
if (property.PropertyType.FullName.StartsWith("<>f__AnonymousType"))
{
dynamic dval = val.ToDynamic();
expando.Add(property.Name, dval);
}
else
{
expando.Add(property.Name, val);
}
}
return expando as ExpandoObject;
}

　　使用示例：

// Controller 端，转换为dynamic
var data = new { Id = 1, Name = "GMF" };
dynamic result = data.ToDynamic();
Viewbag.Result = result;
...
//View 端，可以直接用了
dynamic result = Viewbag.Result;
@result.Id
@result.Name
...

字符串扩展

正则表达式

　　使用正则表达式的原生静态方法，比较难用，做成扩展方法就好用多了

字符串操作

/// <summary>
/// 指示所指定的正则表达式在指定的输入字符串中是否找到了匹配项
/// </summary>
/// <param name="value">要搜索匹配项的字符串</param>
/// <param name="pattern">要匹配的正则表达式模式</param>
/// <returns>如果正则表达式找到匹配项，则为 true；否则，为 false</returns>
public static bool IsMatch(this string value, string pattern)
{
if (value == null)
{
return false;
}
return Regex.IsMatch(value, pattern);
}

/// <summary>
/// 在指定的输入字符串中搜索指定的正则表达式的第一个匹配项
/// </summary>
/// <param name="value">要搜索匹配项的字符串</param>
/// <param name="pattern">要匹配的正则表达式模式</param>
/// <returns>一个对象，包含有关匹配项的信息</returns>
public static string Match(this string value, string pattern)
{
if (value == null)
{
return null;
}
return Regex.Match(value, pattern).Value;
}

/// <summary>
/// 在指定的输入字符串中搜索指定的正则表达式的所有匹配项的字符串集合
/// </summary>
/// <param name="value"> 要搜索匹配项的字符串 </param>
/// <param name="pattern"> 要匹配的正则表达式模式 </param>
/// <returns> 一个集合，包含有关匹配项的字符串值 </returns>
public static IEnumerable<string> Matches(this string value, string pattern)
{
if (value == null)
{
return new string[] { };
}
MatchCollection matches = Regex.Matches(value, pattern);
return from Match match in matches select match.Value;
}

常用字符串正则判断

/// <summary>
/// 是否电子邮件
/// </summary>
public static bool IsEmail(this string value)
{
const string pattern = @"^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$";
return value.IsMatch(pattern);
}

/// <summary>
/// 是否是IP地址
/// </summary>
public static bool IsIpAddress(this string value)
{
const string pattern = @"^(\d(25[0-5]|2[0-4][0-9]|1?[0-9]?[0-9])\d\.){3}\d(25[0-5]|2[0-4][0-9]|1?[0-9]?[0-9])\d$";
return value.IsMatch(pattern);
}

/// <summary>
/// 是否是整数
/// </summary>
public static bool IsNumeric(this string value)
{
const string pattern = @"^\-?[0-9]+$";
return value.IsMatch(pattern);
}

/// <summary>
/// 是否是Unicode字符串
/// </summary>
public static bool IsUnicode(this string value)
{
const string pattern = @"^[\u4E00-\u9FA5\uE815-\uFA29]+$";
return value.IsMatch(pattern);
}

/// <summary>
/// 是否Url字符串
/// </summary>
public static bool IsUrl(this string value)
{
const string pattern = @"^(http|https|ftp|rtsp|mms):(\/\/|\\\\)[A-Za-z0-9%\-_@]+\.[A-Za-z0-9%\-_@]+[A-Za-z0-9\.\/=\?%\-&_~`@:\+!;]*$";
return value.IsMatch(pattern);
}

/// <summary>
/// 是否身份证号，验证如下3种情况：
/// 1.身份证号码为15位数字；
/// 2.身份证号码为18位数字；
/// 3.身份证号码为17位数字+1个字母
/// </summary>
public static bool IsIdentityCard(this string value)
{
const string pattern = @"^(^\d{15}$|^\d{18}$|^\d{17}(\d|X|x))$";
return value.IsMatch(pattern);
}

/// <summary>
/// 是否手机号码
/// </summary>
/// <param name="value"></param>
/// <param name="isRestrict">是否按严格格式验证</param>
public static bool IsMobileNumber(this string value, bool isRestrict = false)
{
string pattern = isRestrict ? @"^[1][3-8]\d{9}$" : @"^[1]\d{10}$";
return value.IsMatch(pattern);
}

简化操作

　　字符串的静态方法有时候用着实在别扭，包装成扩展方法，在编码的时候就感觉顺畅多了。

/// <summary>
/// 指示指定的字符串是 null 还是 System.String.Empty 字符串
/// </summary>
public static bool IsNullOrEmpty(this string value)
{
return string.IsNullOrEmpty(value);
}

/// <summary>
/// 指示指定的字符串是 null、空还是仅由空白字符组成。
/// </summary>
public static bool IsNullOrWhiteSpace(this string value)
{
return string.IsNullOrWhiteSpace(value);
}

/// <summary>
/// 为指定格式的字符串填充相应对象来生成字符串
/// </summary>
/// <param name="format">字符串格式，占位符以{n}表示</param>
/// <param name="args">用于填充占位符的参数</param>
/// <returns>格式化后的字符串</returns>
public static string FormatWith(this string format, params object[] args)
{
format.CheckNotNull("format");
return string.Format(CultureInfo.CurrentCulture, format, args);
}

/// <summary>
/// 将字符串反转
/// </summary>
/// <param name="value">要反转的字符串</param>
public static string ReverseString(this string value)
{
value.CheckNotNull("value");
return new string(value.Reverse().ToArray());
}

/// <summary>
/// 以指定字符串作为分隔符将指定字符串分隔成数组
/// </summary>
/// <param name="value">要分割的字符串</param>
/// <param name="strSplit">字符串类型的分隔符</param>
/// <param name="removeEmptyEntries">是否移除数据中元素为空字符串的项</param>
/// <returns>分割后的数据</returns>
public static string[] Split(this string value, string strSplit, bool removeEmptyEntries = false)
{
return value.Split(new[] { strSplit }, removeEmptyEntries ? StringSplitOptions.RemoveEmptyEntries : StringSplitOptions.None);
}

/// <summary>
/// 获取字符串的MD5 Hash值
/// </summary>
public static string ToMd5Hash(this string value)
{
return HashHelper.GetMd5(value);
}

类型扩展

　　类型相关的代码，通常都是一些反射的代码，利用扩展方法，可以使操作有效的简化。

Nullable类型

/// <summary>
/// 判断类型是否为Nullable类型
/// </summary>
/// <param name="type"> 要处理的类型 </param>
/// <returns> 是返回True，不是返回False </returns>
public static bool IsNullableType(this Type type)
{
return ((type != null) && type.IsGenericType) && (type.GetGenericTypeDefinition() == typeof(Nullable<>));
}

/// <summary>
/// 通过类型转换器获取Nullable类型的基础类型
/// </summary>
/// <param name="type"> 要处理的类型对象 </param>
/// <returns> </returns>
public static Type GetUnNullableType(this Type type)
{
if (IsNullableType(type))
{
NullableConverter nullableConverter = new NullableConverter(type);
return nullableConverter.UnderlyingType;
}
return type;
}

　　使用示例：

Assert.IsTrue(typeof(int?).IsNullableType());
Assert.IsTrue(typeof(Nullable<int>).IsNullableType());
Assert.IsFalse(typeof(int).IsNullableType());

Assert.AreEqual(typeof(int?).GetUnNullableType(), typeof(int));
Assert.AreEqual(typeof(Nullable<int>).GetUnNullableType(), typeof(int));
Assert.AreEqual(typeof(int).GetUnNullableType(), typeof(int));

Attribute特性操作

/// <summary>
/// 获取成员元数据的Description特性描述信息
/// </summary>
/// <param name="member">成员元数据对象</param>
/// <param name="inherit">是否搜索成员的继承链以查找描述特性</param>
/// <returns>返回Description特性描述信息，如不存在则返回成员的名称</returns>
public static string ToDescription(this MemberInfo member, bool inherit = false)
{
DescriptionAttribute desc = member.GetAttribute<DescriptionAttribute>(inherit);
return desc == null ? member.Name : desc.Description;
}

/// <summary>
/// 检查指定指定类型成员中是否存在指定的Attribute特性
/// </summary>
/// <typeparam name="T">要检查的Attribute特性类型</typeparam>
/// <param name="memberInfo">要检查的类型成员</param>
/// <param name="inherit">是否从继承中查找</param>
/// <returns>是否存在</returns>
public static bool AttributeExists<T>(this MemberInfo memberInfo, bool inherit = false) where T : Attribute
{
return memberInfo.GetCustomAttributes(typeof(T), inherit).Any(m => (m as T) != null);
}

/// <summary>
/// 从类型成员获取指定Attribute特性
/// </summary>
/// <typeparam name="T">Attribute特性类型</typeparam>
/// <param name="memberInfo">类型类型成员</param>
/// <param name="inherit">是否从继承中查找</param>
/// <returns>存在返回第一个，不存在返回null</returns>
public static T GetAttribute<T>(this MemberInfo memberInfo, bool inherit = false) where T : Attribute
{
var descripts = memberInfo.GetCustomAttributes(typeof(T), inherit);
return descripts.FirstOrDefault() as T;
}

/// <summary>
/// 从类型成员获取指定Attribute特性
/// </summary>
/// <typeparam name="T">Attribute特性类型</typeparam>
/// <param name="memberInfo">类型类型成员</param>
/// <param name="inherit">是否从继承中查找</param>
/// <returns>返回所有指定Attribute特性的数组</returns>
public static T[] GetAttributes<T>(this MemberInfo memberInfo, bool inherit = false) where T : Attribute
{
return memberInfo.GetCustomAttributes(typeof(T), inherit).Cast<T>().ToArray();
}

　　使用示例：

//测试类型
[Description("测试实体")]
public class TestEntity
{
[Description("名称")]
public string Name { get; set; }
}

//使用示例
Type type = typeof(TestEntity);
Assert.AreEqual(type.ToDescription(), "测试实体");
PropertyInfo property = type.GetProperty("Name");
Assert.AreEqual(property.ToDescription(), "名称");

type = typeof(string);
Assert.AreEqual(type.ToDescription(), "String"); //没有指定特性，返回类型名称

其他

/// <summary>
/// 判断类型是否为集合类型
/// </summary>
/// <param name="type">要处理的类型</param>
/// <returns>是返回True，不是返回False</returns>
public static bool IsEnumerable(this Type type)
{
if (type == typeof(string))
{
return false;
}
return typeof(IEnumerable).IsAssignableFrom(type);
}

/// <summary>
/// 判断当前泛型类型是否可由指定类型的实例填充
/// </summary>
/// <param name="genericType">泛型类型</param>
/// <param name="type">指定类型</param>
/// <returns></returns>
public static bool IsGenericAssignableFrom(this Type genericType, Type type)
{
genericType.CheckNotNull("genericType");
type.CheckNotNull("type");
if (!genericType.IsGenericType)
{
throw new ArgumentException("该功能只支持泛型类型的调用，非泛型类型可使用 IsAssignableFrom 方法。");
}

List<Type> allOthers = new List<Type> { type };
if (genericType.IsInterface)
{
allOthers.AddRange(type.GetInterfaces());
}

foreach (var other in allOthers)
{
Type cur = other;
while (cur != null)
{
if (cur.IsGenericType)
{
cur = cur.GetGenericTypeDefinition();
}
if (cur.IsSubclassOf(genericType) || cur == genericType)
{
return true;
}
cur = cur.BaseType;
}
}
return false;
}

随机数扩展

　　Random 随机数功能，也是非常常用的，.net fx 中已经定义了比如Next，NextDouble这些功能了，下面我们再定义一些其他的常用随机数操作，在编写代码的时候，更行云流水。

　　注：Random 的随机性是伪随机的，最好使用全局存在的Random对象，才能保证随机性，如果是即时声明的Random对象，在短时间内可能失去随机性。

/// <summary>
/// 返回随机布尔值
/// </summary>
/// <param name="random"></param>
/// <returns>随机布尔值</returns>
public static bool NextBoolean(this Random random)
{
return random.NextDouble() > 0.5;
}

/// <summary>
/// 返回指定枚举类型的随机枚举值
/// </summary>
/// <param name="random"></param>
/// <returns>指定枚举类型的随机枚举值</returns>
public static T NextEnum<T>(this Random random) where T : struct
{
Type type = typeof(T);
if (!type.IsEnum)
{
throw new InvalidOperationException();
}
Array array = Enum.GetValues(type);
int index = random.Next(array.GetLowerBound(0), array.GetUpperBound(0) + 1);
return (T)array.GetValue(index);
}

/// <summary>
/// 返回随机数填充的指定长度的数组
/// </summary>
/// <param name="random"></param>
/// <param name="length">数组长度</param>
/// <returns>随机数填充的指定长度的数组</returns>
public static byte[] NextBytes(this Random random, int length)
{
if (length < 0)
{
throw new ArgumentOutOfRangeException("length");
}
byte[] data = new byte[length];
random.NextBytes(data);
return data;
}

/// <summary>
/// 返回数组中的随机元素
/// </summary>
/// <typeparam name="T">元素类型</typeparam>
/// <param name="random"></param>
/// <param name="items">元素数组</param>
/// <returns>元素数组中的某个随机项</returns>
public static T NextItem<T>(this Random random, T[] items)
{
return items[random.Next(0, items.Length)];
}

/// <summary>
/// 返回指定时间段内的随机时间值
/// </summary>
/// <param name="random"></param>
/// <param name="minValue">时间范围的最小值</param>
/// <param name="maxValue">时间范围的最大值</param>
/// <returns>指定时间段内的随机时间值</returns>
public static DateTime NextDateTime(this Random random, DateTime minValue, DateTime maxValue)
{
long ticks = minValue.Ticks + (long)((maxValue.Ticks - minValue.Ticks) * random.NextDouble());
return new DateTime(ticks);
}

/// <summary>
/// 返回随机时间值
/// </summary>
/// <param name="random"></param>
/// <returns>随机时间值</returns>
public static DateTime NextDateTime(this Random random)
{
return NextDateTime(random, DateTime.MinValue, DateTime.MaxValue);
}

/// <summary>
/// 获取指定的长度的随机数字字符串
/// </summary>
/// <param name="random"></param>
/// <param name="length">要获取随机数长度</param>
/// <returns>指定长度的随机数字符串</returns>
public static string GetRandomNumberString(this Random random, int length)
{
if (length < 0)
{
throw new ArgumentOutOfRangeException("length");
}
char[] pattern = new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
string result = "";
int n = pattern.Length;
for (int i = 0; i < length; i++)
{
int rnd = random.Next(0, n);
result += pattern[rnd];
}
return result;
}

/// <summary>
/// 获取指定的长度的随机字母字符串
/// </summary>
/// <param name="random"></param>
/// <param name="length">要获取随机数长度</param>
/// <returns>指定长度的随机字母组成字符串</returns>
public static string GetRandomLetterString(this Random random, int length)
{
if (length < 0)
{
throw new ArgumentOutOfRangeException("length");
}
char[] pattern = new char[] { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L',
'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z' };
string result = "";
int n = pattern.Length;
for (int i = 0; i < length; i++)
{
int rnd = random.Next(0, n);
result += pattern[rnd];
}
return result;
}

/// <summary>
/// 获取指定的长度的随机字母和数字字符串
/// </summary>
/// <param name="random"></param>
/// <param name="length">要获取随机数长度</param>
/// <returns>指定长度的随机字母和数字组成字符串</returns>
public static string GetRandomLetterAndNumberString(this Random random, int length)
{
if (length < 0)
{
throw new ArgumentOutOfRangeException("length");
}
char[] pattern = new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z' };
string result = "";
int n = pattern.Length;
for (int i = 0; i < length; i++)
{
int rnd = random.Next(0, n);
result += pattern[rnd];
}
return result;
}

参数检查扩展

　　一个饱满健壮的软件，检查用户输入是必不少的步骤，永远也不要相信用户输入的数据，即早对输入的非法数据进行拦截，有利于及早发现错误，使非法数据的破坏减至最小。

　　参数检查至关重要，那么，什么时候该进行参数检查呢，我个人认为：

所有的公共方法都应该进行检查。因为是公共方法，你无法控制调用方会以怎样的方式来进行调用，所以，都应该进行参数检查。

对于私有方法，在可控范围内，可以不进行参数检查。

　　通常我们做参数检查，会使用如下的方式

public static void Method(string input, int number)
{
if (input == null)
{
throw new ArgumentNullException("input");
}
if (number <= 0)
{
throw new ArgumentOutOfRangeException("number");
}
// do something
}

　　写法虽然不复杂，但整天写这样的代码，也会累的，而且一个简单就得占4行的空间，我们需要一种更简单的方式。为了适应各种异常的抛出，我们定义一个异常的泛型方法来执行最终的异常抛出。

/// <summary>
/// 验证指定值的断言<paramref name="assertion"/>是否为真，如果不为真，抛出指定消息<paramref name="message"/>的指定类型<typeparamref name="TException"/>异常
/// </summary>
/// <typeparam name="TException">异常类型</typeparam>
/// <param name="assertion">要验证的断言。</param>
/// <param name="message">异常消息。</param>
private static void Require<TException>(bool assertion, string message) where TException : Exception
{
if (assertion)
{
return;
}
TException exception = (TException)Activator.CreateInstance(typeof(TException), message);
throw exception;
}

　　定义了一个bool参数assertion来接收是是否要抛出异常的判断结果，同时还需要抛出异常消息。看到上面这段代码，有人就坐不住了，这里使用的反射来实例化异常实例，会带来性能问题吗？大可不必，试想，都异常了，还需要在乎这个的性能问题吗？

　　前面的ArgumentNullException异常，可以定义如下的扩展方法

/// <summary>
/// 检查参数不能为空引用，否则抛出<see cref="ArgumentNullException"/>异常。
/// </summary>
/// <param name="value"></param>
/// <param name="paramName">参数名称</param>
/// <exception cref="ArgumentNullException"></exception>
public static void CheckNotNull<T>(this T value, string paramName) where T : class
{
Require<ArgumentNullException>(value != null, string.Format(Resources.ParameterCheck_NotNull, paramName));
}

　　这样，要对 input 参数进行检查，就相当的简单了： input.CheckNotNull("input");

引用类型的参数检查

　　类似的，对于引用类型，我们可以定义出如下扩展方法：

/// <summary>
/// 检查字符串不能为空引用或空字符串，否则抛出<see cref="ArgumentNullException"/>异常或<see cref="ArgumentException"/>异常。
/// </summary>
/// <param name="value"></param>
/// <param name="paramName">参数名称。</param>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="ArgumentException"></exception>
public static void CheckNotNullOrEmpty(this string value, string paramName)
{
value.CheckNotNull(paramName);
Require<ArgumentException>(value.Length > 0, string.Format(Resources.ParameterCheck_NotNullOrEmpty_String, paramName));
}

/// <summary>
/// 检查Guid值不能为Guid.Empty，否则抛出<see cref="ArgumentException"/>异常。
/// </summary>
/// <param name="value"></param>
/// <param name="paramName">参数名称。</param>
/// <exception cref="ArgumentException"></exception>
public static void CheckNotEmpty(this Guid value, string paramName)
{
Require<ArgumentException>(value != Guid.Empty, string.Format(Resources.ParameterCheck_NotEmpty_Guid, paramName));
}

/// <summary>
/// 检查集合不能为空引用或空集合，否则抛出<see cref="ArgumentNullException"/>异常或<see cref="ArgumentException"/>异常。
/// </summary>
/// <typeparam name="T">集合项的类型。</typeparam>
/// <param name="collection"></param>
/// <param name="paramName">参数名称。</param>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="ArgumentException"></exception>
public static void CheckNotNullOrEmpty<T>(this IEnumerable<T> collection, string paramName)
{
collection.CheckNotNull(paramName);
Require<ArgumentException>(collection.Any(), string.Format(Resources.ParameterCheck_NotNullOrEmpty_Collection, paramName));
}

值类型的参数检查

　　对于值类型，可以定义出如下扩展方法：

/// <summary>
/// 检查参数必须小于[或可等于，参数canEqual]指定值，否则抛出<see cref="ArgumentOutOfRangeException"/>异常。
/// </summary>
/// <typeparam name="T">参数类型。</typeparam>
/// <param name="value"></param>
/// <param name="paramName">参数名称。</param>
/// <param name="target">要比较的值。</param>
/// <param name="canEqual">是否可等于。</param>
/// <exception cref="ArgumentOutOfRangeException"></exception>
public static void CheckLessThan<T>(this T value, string paramName, T target, bool canEqual = false) where T : IComparable<T>
{
bool flag = canEqual ? value.CompareTo(target) <= 0 : value.CompareTo(target) < 0;
string format = canEqual ? Resources.ParameterCheck_NotLessThanOrEqual : Resources.ParameterCheck_NotLessThan;
Require<ArgumentOutOfRangeException>(flag, string.Format(format, paramName, target));
}

/// <summary>
/// 检查参数必须大于[或可等于，参数canEqual]指定值，否则抛出<see cref="ArgumentOutOfRangeException"/>异常。
/// </summary>
/// <typeparam name="T">参数类型。</typeparam>
/// <param name="value"></param>
/// <param name="paramName">参数名称。</param>
/// <param name="target">要比较的值。</param>
/// <param name="canEqual">是否可等于。</param>
/// <exception cref="ArgumentOutOfRangeException"></exception>
public static void CheckGreaterThan<T>(this T value, string paramName, T target, bool canEqual = false) where T : IComparable<T>
{
bool flag = canEqual ? value.CompareTo(target) >= 0 : value.CompareTo(target) > 0;
string format = canEqual ? Resources.ParameterCheck_NotGreaterThanOrEqual : Resources.ParameterCheck_NotGreaterThan;
Require<ArgumentOutOfRangeException>(flag, string.Format(format, paramName, target));
}

/// <summary>
/// 检查参数必须在指定范围之间，否则抛出<see cref="ArgumentOutOfRangeException"/>异常。
/// </summary>
/// <typeparam name="T">参数类型。</typeparam>
/// <param name="value"></param>
/// <param name="paramName">参数名称。</param>
/// <param name="start">比较范围的起始值。</param>
/// <param name="end">比较范围的结束值。</param>
/// <param name="startEqual">是否可等于起始值</param>
/// <param name="endEqual">是否可等于结束值</param>
/// <exception cref="ArgumentOutOfRangeException"></exception>
public static void CheckBetween<T>(this T value, string paramName, T start, T end, bool startEqual = false, bool endEqual = false)
where T : IComparable<T>
{
bool flag = startEqual ? value.CompareTo(start) >= 0 : value.CompareTo(start) > 0;
string message = startEqual
? string.Format(Resources.ParameterCheck_BetweenNotEqual, paramName, start, end, start)
: string.Format(Resources.ParameterCheck_Between, paramName, start, end);
Require<ArgumentOutOfRangeException>(flag, message);

flag = endEqual ? value.CompareTo(end) <= 0 : value.CompareTo(end) < 0;
message = endEqual
? string.Format(Resources.ParameterCheck_BetweenNotEqual, paramName, start, end, end)
: string.Format(Resources.ParameterCheck_Between, paramName, start, end);
Require<ArgumentOutOfRangeException>(flag, message);
}

文件相关检查

　　常用的参数检查还有文件夹与文件是否存在的检查：

/// <summary>
/// 检查指定路径的文件夹必须存在，否则抛出<see cref="DirectoryNotFoundException"/>异常。
/// </summary>
/// <param name="directory"></param>
/// <param name="paramName">参数名称。</param>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="DirectoryNotFoundException"></exception>
public static void CheckDirectoryExists(this string directory, string paramName = null)
{
CheckNotNull(directory, paramName);
Require<DirectoryNotFoundException>(Directory.Exists(directory), string.Format(Resources.ParameterCheck_DirectoryNotExists, directory));
}

/// <summary>
/// 检查指定路径的文件必须存在，否则抛出<see cref="FileNotFoundException"/>异常。
/// </summary>
/// <param name="filename"></param>
/// <param name="paramName">参数名称。</param>
/// <exception cref="ArgumentNullException">当文件路径为null时</exception>
/// <exception cref="FileNotFoundException">当文件路径不存在时</exception>
public static void CheckFileExists(this string filename, string paramName = null)
{
CheckNotNull(filename, paramName);
Require<FileNotFoundException>(File.Exists(filename), string.Format(Resources.ParameterCheck_FileNotExists, filename));
}

其他参数检查

　　当然，还可能会有其他的情况，抛出其他类型的异常，定义如下两个通用的扩展：

/// <summary>
/// 验证指定值的断言表达式是否为真，不为值抛出<see cref="Exception"/>异常
/// </summary>
/// <param name="value"></param>
/// <param name="assertionFunc">要验证的断言表达式</param>
/// <param name="message">异常消息</param>
public static void Required<T>(this T value, Func<T, bool> assertionFunc, string message)
{
Require<Exception>(assertionFunc(value), message);
}

/// <summary>
/// 验证指定值的断言表达式是否为真，不为真抛出<typeparam name="TException>"/>异常
/// </summary>
/// <typeparam name="T">要判断的值的类型</typeparam>
/// <typeparam name="TException">抛出的异常类型</typeparam>
/// <param name="value">要判断的值</param>
/// <param name="assertionFunc">要验证的断言表达式</param>
/// <param name="message">异常消息</param>
public static void Required<T, TException>(this T value, Func<T, bool> assertionFunc, string message) where TException : Exception
{
Require<TException>(assertionFunc(value), message);
}

Expression表达式扩展

　　在使用Expression进行linq查询时，有时候需要对表达式进行 And，Or 等组合，可定义如下扩展方法来简化操作

/// <summary>
/// 以特定的条件运行组合两个Expression表达式
/// </summary>
/// <typeparam name="T">表达式的主实体类型</typeparam>
/// <param name="first">第一个Expression表达式</param>
/// <param name="second">要组合的Expression表达式</param>
/// <param name="merge">组合条件运算方式</param>
/// <returns>组合后的表达式</returns>
public static Expression<T> Compose<T>(this Expression<T> first, Expression<T> second, Func<Expression, Expression, Expression> merge)
{
Dictionary<ParameterExpression, ParameterExpression> map =
first.Parameters.Select((f, i) => new { f, s = second.Parameters[i] }).ToDictionary(p => p.s, p => p.f);
Expression secondBody = ParameterRebinder.ReplaceParameters(map, second.Body);
return Expression.Lambda<T>(merge(first.Body, secondBody), first.Parameters);
}

/// <summary>
/// 以 Expression.AndAlso 组合两个Expression表达式
/// </summary>
/// <typeparam name="T">表达式的主实体类型</typeparam>
/// <param name="first">第一个Expression表达式</param>
/// <param name="second">要组合的Expression表达式</param>
/// <returns>组合后的表达式</returns>
public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
{
return first.Compose(second, Expression.AndAlso);
}

/// <summary>
/// 以 Expression.OrElse 组合两个Expression表达式
/// </summary>
/// <typeparam name="T">表达式的主实体类型</typeparam>
/// <param name="first">第一个Expression表达式</param>
/// <param name="second">要组合的Expression表达式</param>
/// <returns>组合后的表达式</returns>
public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
{
return first.Compose(second, Expression.OrElse);
}

private class ParameterRebinder : ExpressionVisitor
{
private readonly Dictionary<ParameterExpression, ParameterExpression> _map;

private ParameterRebinder(Dictionary<ParameterExpression, ParameterExpression> map)
{
_map = map ?? new Dictionary<ParameterExpression, ParameterExpression>();
}

public static Expression ReplaceParameters(Dictionary<ParameterExpression, ParameterExpression> map, Expression exp)
{
return new ParameterRebinder(map).Visit(exp);
}

protected override Expression VisitParameter(ParameterExpression node)
{
ParameterExpression replacement;
if (_map.TryGetValue(node, out replacement))
{
node = replacement;
}
return base.VisitParameter(node);
}
}

使用示例：

// And
Expression<Func<TestEntity, bool>> predicate = m => m.IsDeleted;
Expression<Func<TestEntity, bool>> actual = m => m.IsDeleted && m.Id > 500;
predicate = predicate.And(m => m.Id > 500);
List<TestEntity> list1 = Entities.Where(predicate.Compile()).ToList();
List<TestEntity> list2 = Entities.Where(actual.Compile()).ToList();
Assert.IsTrue(list1.SequenceEqual(list2));

//Or
Expression<Func<TestEntity, bool>> predicate = m => m.IsDeleted;
Expression<Func<TestEntity, bool>> actual = m => m.IsDeleted || m.Id > 500;
predicate = predicate.Or(m => m.Id > 500);
List<TestEntity> list1 = Entities.Where(predicate.Compile()).ToList();
List<TestEntity> list2 = Entities.Where(actual.Compile()).ToList();
Assert.IsTrue(list1.SequenceEqual(list2));

集合操作扩展

　　集合操作扩展，主要是对IEnumerable<T>与IQueryable<T>两个集合进行扩展

/// <summary>
/// 集合扩展方法类
/// </summary>
public static class CollectionExtensions
{
#region IEnumerable的扩展

/// <summary>
/// 将集合展开并分别转换成字符串，再以指定的分隔符衔接，拼成一个字符串返回。默认分隔符为逗号
/// </summary>
/// <param name="collection"> 要处理的集合 </param>
/// <param name="separator"> 分隔符，默认为逗号 </param>
/// <returns> 拼接后的字符串 </returns>
public static string ExpandAndToString<T>(this IEnumerable<T> collection, string separator = ",")
{
return collection.ExpandAndToString(t => t.ToString(), separator);
}

/// <summary>
/// 循环集合的每一项，调用委托生成字符串，返回合并后的字符串。默认分隔符为逗号
/// </summary>
/// <param name="collection">待处理的集合</param>
/// <param name="itemFormatFunc">单个集合项的转换委托</param>
/// <param name="separetor">分隔符，默认为逗号</param>
/// <typeparam name="T">泛型类型</typeparam>
/// <returns></returns>
public static string ExpandAndToString<T>(this IEnumerable<T> collection, Func<T, string> itemFormatFunc, string separetor = ",")
{
collection = collection as IList<T> ?? collection.ToList();
itemFormatFunc.CheckNotNull("itemFormatFunc");
if (!collection.Any())
{
return null;
}
StringBuilder sb = new StringBuilder();
int i = 0;
int count = collection.Count();
foreach (T t in collection)
{
if (i == count - 1)
{
sb.Append(itemFormatFunc(t));
}
else
{
sb.Append(itemFormatFunc(t) + separetor);
}
i++;
}
return sb.ToString();
}

/// <summary>
/// 集合是否为空
/// </summary>
/// <param name="collection"> 要处理的集合 </param>
/// <typeparam name="T"> 动态类型 </typeparam>
/// <returns> 为空返回True，不为空返回False </returns>
public static bool IsEmpty<T>(this IEnumerable<T> collection)
{
collection = collection as IList<T> ?? collection.ToList();
return !collection.Any();
}

/// <summary>
/// 根据第三方条件是否为真来决定是否执行指定条件的查询
/// </summary>
/// <param name="source"> 要查询的源 </param>
/// <param name="predicate"> 查询条件 </param>
/// <param name="condition"> 第三方条件 </param>
/// <typeparam name="T"> 动态类型 </typeparam>
/// <returns> 查询的结果 </returns>
public static IEnumerable<T> WhereIf<T>(this IEnumerable<T> source, Func<T, bool> predicate, bool condition)
{
predicate.CheckNotNull("predicate");
source = source as IList<T> ?? source.ToList();

return condition ? source.Where(predicate) : source;
}

/// <summary>
/// 根据指定条件返回集合中不重复的元素
/// </summary>
/// <typeparam name="T">动态类型</typeparam>
/// <typeparam name="TKey">动态筛选条件类型</typeparam>
/// <param name="source">要操作的源</param>
/// <param name="keySelector">重复数据筛选条件</param>
/// <returns>不重复元素的集合</returns>
public static IEnumerable<T> DistinctBy<T, TKey>(this IEnumerable<T> source, Func<T, TKey> keySelector)
{
keySelector.CheckNotNull("keySelector");
source = source as IList<T> ?? source.ToList();

return source.GroupBy(keySelector).Select(group => group.First());
}

#endregion

#region IQueryable的扩展

/// <summary>
/// 根据第三方条件是否为真来决定是否执行指定条件的查询
/// </summary>
/// <param name="source"> 要查询的源 </param>
/// <param name="predicate"> 查询条件 </param>
/// <param name="condition"> 第三方条件 </param>
/// <typeparam name="T"> 动态类型 </typeparam>
/// <returns> 查询的结果 </returns>
public static IQueryable<T> WhereIf<T>(this IQueryable<T> source, Expression<Func<T, bool>> predicate, bool condition)
{
source.CheckNotNull("source");
predicate.CheckNotNull("predicate");

return condition ? source.Where(predicate) : source;
}

/// <summary>
/// 把<see cref="IQueryable{T}"/>集合按指定字段与排序方式进行排序
/// </summary>
/// <param name="source">要排序的数据集</param>
/// <param name="propertyName">排序属性名</param>
/// <param name="sortDirection">排序方向</param>
/// <typeparam name="T">动态类型</typeparam>
/// <returns>排序后的数据集</returns>
public static IOrderedQueryable<T> OrderBy<T>(this IQueryable<T> source,
string propertyName,
ListSortDirection sortDirection = ListSortDirection.Ascending)
{
source.CheckNotNull("source");
propertyName.CheckNotNullOrEmpty("propertyName");

return QueryablePropertySorter<T>.OrderBy(source, propertyName, sortDirection);
}

/// <summary>
/// 把<see cref="IQueryable{T}"/>集合按指定字段排序条件进行排序
/// </summary>
/// <typeparam name="T">动态类型</typeparam>
/// <param name="source">要排序的数据集</param>
/// <param name="sortCondition">列表字段排序条件</param>
/// <returns></returns>
public static IOrderedQueryable<T> OrderBy<T>(this IQueryable<T> source, SortCondition sortCondition)
{
source.CheckNotNull("source");
sortCondition.CheckNotNull("sortCondition");

return source.OrderBy(sortCondition.SortField, sortCondition.ListSortDirection);
}

/// <summary>
/// 把<see cref="IOrderedQueryable{T}"/>集合继续按指定字段排序方式进行排序
/// </summary>
/// <typeparam name="T">动态类型</typeparam>
/// <param name="source">要排序的数据集</param>
/// <param name="propertyName">排序属性名</param>
/// <param name="sortDirection">排序方向</param>
/// <returns></returns>
public static IOrderedQueryable<T> ThenBy<T>(this IOrderedQueryable<T> source,
string propertyName,
ListSortDirection sortDirection = ListSortDirection.Ascending)
{
source.CheckNotNull("source");
propertyName.CheckNotNullOrEmpty("propertyName");

return QueryablePropertySorter<T>.ThenBy(source, propertyName, sortDirection);
}

/// <summary>
/// 把<see cref="IOrderedQueryable{T}"/>集合继续指定字段排序方式进行排序
/// </summary>
/// <typeparam name="T">动态类型</typeparam>
/// <param name="source">要排序的数据集</param>
/// <param name="sortCondition">列表字段排序条件</param>
/// <returns></returns>
public static IOrderedQueryable<T> ThenBy<T>(this IOrderedQueryable<T> source, SortCondition sortCondition)
{
source.CheckNotNull("source");
sortCondition.CheckNotNull("sortCondition");

return source.ThenBy(sortCondition.SortField, sortCondition.ListSortDirection);
}

#endregion
}

　　使用示例：

//ExpandAndToString
List<int> source = new List<int>();
//当为空集合时，返回null
Assert.AreEqual(source.ExpandAndToString(), null);
source.AddRange(new List<int>() { 1, 2, 3, 4, 5, 6 });
//没有分隔符时，默认为逗号
Assert.AreEqual(source.ExpandAndToString(), "1,2,3,4,5,6");
Assert.AreEqual(source.ExpandAndToString(null), "123456");
Assert.AreEqual(source.ExpandAndToString(""), "123456");
Assert.AreEqual(source.ExpandAndToString("|"), "1|2|3|4|5|6");

List<int> source = new List<int> { 1, 2, 3, 4, 5, 6 };

//转换委托不能为空
ExceptionAssert.IsException<ArgumentNullException>(() => source.ExpandAndToString(null));
//没有分隔符时，默认为逗号
Assert.AreEqual(source.ExpandAndToString(item => (item + 1).ToString()), "2,3,4,5,6,7");
Assert.AreEqual(source.ExpandAndToString(item => (item + 1).ToString(), "|"), "2|3|4|5|6|7");

List<int> source = new List<int>();
Assert.IsTrue(source.IsEmpty());

source.Add(1);
Assert.IsFalse(source.IsEmpty());

List<int> source = new List<int> { 1, 2, 3, 4, 5, 6, 7 };
CollectionAssert.AreEqual(source.WhereIf(m => m > 5, false).ToList(), source);
List<int> actual = new List<int> { 6, 7 };
CollectionAssert.AreEqual(source.WhereIf(m => m > 5, true).ToList(), actual);

List<int> source = new List<int> { 1, 2, 3, 3, 4, 4, 5, 6, 7, 7 };
List<int> actual = new List<int> { 1, 2, 3, 4, 5, 6, 7 };
CollectionAssert.AreEqual(source.DistinctBy(m => m).ToList(), actual);

开源说明

github.com

　　OSharp项目已在github.com上开源，地址为：https://github.com/i66soft/osharp，欢迎阅读代码，欢迎 Fork，如果您认同 OSharp 项目的思想，欢迎参与 OSharp 项目的开发。

　　在Visual Studio 2013中，可直接获取 OSharp 的最新源代码，获取方式如下，地址为：https://github.com/i66soft/osharp.git

　　

nuget

　　OSharp的相关类库已经发布到nuget上，欢迎试用，直接在nuget上搜索 “osharp” 关键字即可找到
　　

系列导航