.NET 实用扩展方法
.NET 实用扩展方法(持续更新...)
1. 字符串转换为可空数值类型(int, long, float...类似)
/// <summary>
/// 将字符串转换成32位整数,转换失败返回null
/// </summary>
/// <param name="str">转换的字符串</param>
/// <returns>转换之后的整数,或null</returns>
public static int? TryParseToInt32(this string str)
{
if (string.IsNullOrWhiteSpace(str))
return null;
var result = 0;
if (int.TryParse(str, out result))
return result;
else
return null;
}
2. 去除子字符串
/// <summary>
/// 去除子字符串
/// </summary>
/// <param name="str">原字符串</param>
/// <param name="substring">要去除的字符串</param>
/// <returns>去除子字符串之后的结果</returns>
public static string DeSubstring(this string str, string substring)
{
if (string.IsNullOrEmpty(str) || string.IsNullOrEmpty(substring) || !str.Contains(substring))
{
return str;
}
return Regex.Replace(str, Regex.Escape(substring), string.Empty);
}
/// <summary>
/// 去除子字符串
/// </summary>
/// <param name="str">原字符串</param>
/// <param name="substrings">要去除的子字符串</param>
/// <returns>去除子字符串之后的结果</returns>
public static string DeSubstring(this string str, params string[] substrings)
{
if (string.IsNullOrEmpty(str))
return str;
if (substrings == null)
return str;
var newStr = str;
foreach (var item in substrings)
{
newStr = newStr.DeSubstring(item);
}
return newStr;
}
3. 获取子序列
/// <summary>
/// 获取子序列
/// </summary>
/// <typeparam name="T">序列中元素类型</typeparam>
/// <param name="source">源数据</param>
/// <param name="startIndex">开始索引(返回时包括)</param>
/// <param name="endIndex">结束索引(返回时包括)</param>
/// <returns>子序列</returns>
public static IEnumerable<T> SubEnumerable<T>(this IEnumerable<T> source, int startIndex, int endIndex)
{
if (source == null)
yield return default(T);
var length = source.Count();
if (startIndex < 0 || endIndex < startIndex || startIndex >= length || endIndex >= length)
throw new ArgumentOutOfRangeException();
var index = -1;
foreach (var item in source)
{
index++;
if (index < startIndex)
continue;
if (index > endIndex)
yield break;
yield return item;
}
}
4. 通过指定键对序列去重, 不必实现IEqualityComparer接口
/// <summary>
/// 通过对指定的值进行比较返回序列中的非重复元素。
/// </summary>
/// <typeparam name="T">序列中元素类型</typeparam>
/// <typeparam name="TResult">指定的比较属性类型</typeparam>
/// <param name="source">源数据</param>
/// <param name="selector">应用于每个元素的转换函数</param>
/// <returns>一个包含源序列中的按指定属性非重复元素</returns>
public static IEnumerable<T> Distinct<T, TResult>(this IEnumerable<T> source, Func<T, TResult> selector)
{
if (source == null)
throw new ArgumentNullException(nameof(source));
if (selector == null)
throw new ArgumentNullException(nameof(selector));
var set = new HashSet<TResult>();
foreach (var item in source)
{
var result = selector(item);
if (set.Add(result))
{
yield return item;
}
}
}
5. 获取序列中重复的元素序列, 原理和去重类似
/// <summary>
/// 通过对指定的值进行比较返回序列中重复的元素
/// </summary>
/// <typeparam name="T">序列中的数据类型</typeparam>
/// <typeparam name="TResult">指定的比较属性类型</typeparam>
/// <param name="source">源数据</param>
/// <param name="selector">应用于每个元素的转换函数</param>
/// <returns>一个包含源序列中的按指定元素的重复元素</returns>
public static IEnumerable<T> Identical<T>(this IEnumerable<T> source)
{
if (source == null)
throw new ArgumentNullException(nameof(source));
var setT = new HashSet<T>();
foreach (var item in source)
{
if (!setT.Add(item))
{
yield return item;
}
}
}
/// <summary>
/// 通过对指定的值进行比较返回序列中重复的元素
/// </summary>
/// <typeparam name="T">序列中的数据类型</typeparam>
/// <typeparam name="TResult">指定的比较属性类型</typeparam>
/// <param name="source">源数据</param>
/// <param name="selector">应用于每个元素的转换函数</param>
/// <returns>一个包含源序列中的按指定元素的重复元素</returns>
public static IEnumerable<T> Identical<T, TResult>(this IEnumerable<T> source, Func<T, TResult> selector)
{
if (source == null)
throw new ArgumentNullException(nameof(source));
if (selector == null)
throw new ArgumentNullException(nameof(selector));
var setTResult = new HashSet<TResult>();
foreach (var item in source)
{
var result = selector(item);
if (!setTResult.Add(result))
{
yield return item;
}
}
}
6. 使用注解对实体进行验证, 可用在除ASP.NET MVC之外的任一框架中(MVC已内置), 需引用System.ComponentModel.DataAnnotations类库及命名空间
/// <summary>
/// 通过使用验证上下文和验证结果结合, 确定指定的对象是否有效
/// </summary>
/// <param name="instance">要验证的对象</param>
/// <param name="validationResults">用于包含每个失败的验证的集合</param>
/// <returns>如果对象有效,为 true, 否则为 false</returns>
public static bool TryValidate(this object instance, ICollection<ValidationResult> validationResults = null)
{
var context = new ValidationContext(instance);
return Validator.TryValidateObject(instance, context, validationResults, true);
}
/// <summary>
/// 通过使用验证上下文和验证结果结合, 确定指定的方法参数是否有效
/// </summary>
/// <param name="instance">要验证的方法所属对象</param>
/// <param name="methodName">类中要验证的方法名称</param>
/// <param name="values">方法参数的值</param>
/// <param name="validationResults">用于包含每个失败的验证的集合</param>
/// <returns>如果参数有效,为 true, 否则为 false</returns>
public static bool TryValidate(this object instance, string methodName, object[] values, ICollection<ValidationResult> validationResults = null)
{
var typeOfInstance = instance.GetType();
var methodInfo = typeOfInstance.GetMethod(methodName, values.Select(p => p?.GetType() ?? typeof(object)).ToArray());
if (methodInfo == null)
{
//查找可能存在的泛型方法
methodInfo = typeOfInstance
.GetMethods()
.FirstOrDefault(p => p.Name == methodName
&& p.IsGenericMethod
&& p.GetParameters().Length == values.Length);
}
if (methodInfo == null)
throw new ArgumentException("找不到指定的方法,请检查方法名或者参数数组是否存在匹配");
var paramInfos = methodInfo.GetParameters();
bool isValid = true;
for (var i = 0; i < values.Length; i++)
{
var value = values[i];
var paramInfo = paramInfos.ElementAt(i);
var context = new ValidationContext(paramInfo);
context.DisplayName = paramInfo.Name;
var attrs = paramInfo.GetCustomAttributes<ValidationAttribute>();
isValid = isValid & Validator.TryValidateValue(value, context, validationResults, attrs);
}
return isValid;
}
/// <summary>
/// 通过使用验证上下文和验证结果结合, 确定指定的方法参数是否有效
/// </summary>
/// <param name="instance">要验证的方法所属对象</param>
/// <param name="methodName">类中要验证的方法名称</param>
/// <param name="values">方法参数值</param>
public static void Validate(this object instance, string methodName, object[] values)
{
var typeOfInstance = instance.GetType();
var methodInfo = typeOfInstance.GetMethod(methodName, values.Select(p => p?.GetType() ?? typeof(object)).ToArray());
if (methodInfo == null)
{
//查找可能存在的泛型方法
methodInfo = typeOfInstance
.GetMethods()
.FirstOrDefault(p => p.Name == methodName
&& p.IsGenericMethod
&& p.GetParameters().Length == values.Length);
}
if (methodInfo == null)
throw new ArgumentException("找不到指定的方法,请检查方法名或者参数数组是否存在匹配");
var paramInfos = methodInfo.GetParameters();
for (var i = 0; i < values.Length; i++)
{
var value = values[i];
var paramInfo = paramInfos.ElementAt(i);
var context = new ValidationContext(paramInfo);
Validator.ValidateValue(value, context, paramInfo.GetCustomAttributes<ValidationAttribute>());
}
}
验证的目标实体:
public class User
{
[Required] //表示此字段不能为null或空字符串
[StringLength(3)] //表示此字段能接收的最大字符串长度
public string Name { get; set; }
[Range(0, 120)] //表示数据字段的最小最大范围
public int Age { get; set; }
}
实体验证:
User user = new User() { Name = "A,ning", Age = 140 };
ICollection<ValidationResult> errors = new List<ValidationResult>();
//如果不关注验证结果, 可不传入 errors 参数, 验证失败将只返回false
if (user.TryValidate(errors))
{
Console.WriteLine("验证通过");
}
else
{
Console.WriteLine("验证失败");
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(string.Join(Environment.NewLine, errors.Select(p => p.ErrorMessage)));
}
方法参数验证(支持泛型方法):
public void SayHello<T>([Required][StringLength(3)] T name, [Range(0, 120)] int age)
{
var errors = new List<ValidationResult>();
if (this.TryValidate(nameof(SayHello), new object[] { name, age }, errors))
{
Console.WriteLine("验证通过");
}
else
{
Console.WriteLine("验证失败");
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(string.Join(Environment.NewLine, errors.Select(p => p.ErrorMessage)));
}
}
7. 判断Type是否为.NET Framework内置类型
/// <summary>
/// 判断<see cref="Type"/>是否为用户自定义类型
/// </summary>
/// <param name="type">type</param>
/// <returns>如果为 .NET 内置类型返回false,否则返回true</returns>
public static bool IsCustomType(this Type type)
{
return (type != typeof(object) && Type.GetTypeCode(type) == TypeCode.Object);
}
