ObjectExtensions.cs
4.95 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
using NCC.Dependency;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Dynamic;
using System.Linq;
using System.Reflection;
namespace NCC.Common.Extension
{
/// <summary>
/// 基类型<see cref="Object"/>扩展辅助操作类
/// </summary>
[SuppressSniffer]
public static class ObjectExtensions
{
#region 公共方法
/// <summary>
/// 把对象类型转化为指定类型
/// </summary>
/// <typeparam name="T"> 动态类型 </typeparam>
/// <param name="value"> 要转化的源对象 </param>
/// <returns> 转化后的指定类型的对象，转化失败引发异常。 </returns>
public static T CastTo<T>(this object value)
{
if (value == null && default(T) == null)
{
return default(T);
}
if (value.GetType() == typeof(T))
{
return (T)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;
}
}
/// <summary>
/// 判断当前值是否介于指定范围内
/// </summary>
/// <typeparam name="T"> 动态类型 </typeparam>
/// <param name="value"> 动态类型对象 </param>
/// <param name="start"> 范围起点 </param>
/// <param name="end"> 范围终点 </param>
/// <param name="leftEqual"> 是否可等于上限（默认等于） </param>
/// <param name="rightEqual"> 是否可等于下限（默认等于） </param>
/// <returns> 是否介于 </returns>
public static bool IsBetween<T>(this IComparable<T> value, T start, T end, bool leftEqual = true, bool rightEqual = true) where T : IComparable
{
bool flag = leftEqual ? value.CompareTo(start) >= 0 : value.CompareTo(start) > 0;
return flag && (rightEqual ? value.CompareTo(end) <= 0 : value.CompareTo(end) < 0);
}
/// <summary>
/// 判断当前值是否介于指定范围内
/// </summary>
/// <typeparam name="T"> 动态类型 </typeparam>
/// <param name="value"> 动态类型对象 </param>
/// <param name="min">范围小值</param>
/// <param name="max">范围大值</param>
/// <param name="minEqual">是否可等于小值（默认等于）</param>
/// <param name="maxEqual">是否可等于大值（默认等于）</param>
public static bool IsInRange<T>(this IComparable<T> value, T min, T max, bool minEqual = true, bool maxEqual = true) where T : IComparable
{
bool flag = minEqual ? value.CompareTo(min) >= 0 : value.CompareTo(min) > 0;
return flag && (maxEqual ? value.CompareTo(max) <= 0 : value.CompareTo(max) < 0);
}
/// <summary>
/// 是否存在于
/// </summary>
public static bool IsIn<T>(this T value, params T[] source)
{
return source.Contains(value);
}
/// <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 != null && property.PropertyType.FullName.StartsWith("<>f__AnonymousType"))
{
dynamic dval = val.ToDynamic();
expando.Add(property.Name, dval);
}
else
{
expando.Add(property.Name, val);
}
}
return (ExpandoObject)expando;
}
private static readonly ConcurrentDictionary<Type, ConcurrentDictionary<PropertyInfo, ValidationAttribute[]>> ValidationDict
= new ConcurrentDictionary<Type, ConcurrentDictionary<PropertyInfo, ValidationAttribute[]>>();
#endregion
}
}