yl
2023-03-04 f355af6d5f8a6c8e80ec48b4458e9b33042f198e
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Web;
 
namespace VueWebApi.Util
{
    /// <summary>
    /// 值转换器
    /// </summary>
    /// <typeparam name="T">指定值的类型</typeparam>
    /// <param name="obj">取值来源</param>
    /// <returns>返回指定类型的值</returns>
    [Serializable]
    public delegate T ObjectValueParser<out T>(object obj);
    /// <summary>
    /// 尝试将值转换成指定类型 返回转换结果
    /// </summary>
    /// <typeparam name="T">指定值的类型</typeparam>
    /// <param name="obj">取值来源</param>
    /// <param name="valueOutput">若转换成功 则out转换结果 否则 out默认T类型值</param>
    /// <returns></returns>
    public delegate bool ObjectValueTryParser<T>(object obj, out T valueOutput);
    /// <summary>
    /// 尝试将值转换成指定类型 返回转换结果
    /// </summary>
    /// <typeparam name="T">指定值的类型</typeparam>
    /// <param name="str">取值来源字符串</param>
    /// <returns>返回指定类型的值</returns>
    [Serializable]
    public delegate T StringValueParser<out T>(string str);
    /// <summary>
    /// 尝试将值转换成指定类型 返回转换成功与否
    /// </summary>
    /// <typeparam name="T">指定值的类型</typeparam>
    /// <param name="str">取值来源字符串</param>
    /// <param name="valueOutput">若转换成功 则out转换结果 否则 out默认T类型值</param>
    /// <returns></returns>
    [Serializable]
    public delegate bool StringValueTryParser<T>(string str, out T valueOutput);
    /// <summary>
    /// 实体帮助类
    /// </summary>
    public class EntityHelper
    {
        /// <summary>
        /// 从一行数据中尝试获取指定列名的值
        /// </summary>
        /// <param name="dr">源数据行</param>
        /// <param name="columnName">指定列名</param>
        /// <returns>若指定的列名存在并有效则返回取到的对象,若指定列名不存在或者为无效数据则返回null</returns>
        public static object GetObject(DataRow dr, string columnName)
        {
            if (dr != null && dr.Table.Columns.Contains(columnName) && dr[columnName] != null && dr[columnName] != DBNull.Value)
                return dr[columnName];
            return null;
        }
        /// <summary>
        /// 从一行数据中尝试获取指定引用类型的值
        /// </summary>
        /// <typeparam name="T">指定类型的值</typeparam>
        /// <param name="dr">源数据行</param>
        /// <param name="columnName">列名</param>
        /// <param name="defVal">列无效时返回的默认值</param>
        /// <param name="parser">值转换器 若给定的值转换器为null,则使用as强制转换,若as转换为null 则返回默认值</param>
        /// <returns></returns>
        public static T GetT<T>(DataRow dr, string columnName, T defVal, ObjectValueParser<T> parser = null) where T : class
        {
            var obj = GetObject(dr, columnName);
            return Get(obj, defVal, parser);
        }
        /// <summary>
        /// 将对象转换为指定类型数据 转换失败返回设置的默认值
        /// </summary>
        /// <typeparam name="T">指定的类型</typeparam>
        /// <param name="source">数据源</param>
        /// <param name="defVal">列无效时返回的默认值</param>
        /// <param name="parser">值转换器 若给定的值转换器为null,则使用as强制转换,若as转换为null 则返回默认值</param>
        /// <returns></returns>
        public static T Get<T>(object source, T defVal, ObjectValueParser<T> parser = null) where T : class
        {
            if (source == null) return defVal;
            if (parser != null)
            {
                return parser(source);
            }
            return source as T ?? defVal;
        }
        /// <summary>
        /// 从一行数据中尝试获取指定引用类型的值
        /// </summary>
        /// <typeparam name="T">指定的类型</typeparam>
        /// <param name="dr">源数据行</param>
        /// <param name="columnName">列名</param>
        /// <param name="defVal">列无效时返回的默认值</param>
        /// <param name="parser">值转换器 若给定的值转换器为null,则使用as强制转换,若as转换为null 则返回默认值</param>
        /// <returns></returns>
        public static T TryGetT<T>(DataRow dr, string columnName, T defVal, ObjectValueTryParser<T> parser = null) where T : class
        {
            var obj = GetObject(dr, columnName);
            return TryGetT(obj, defVal, parser);
        }
        /// <summary>
        /// 将对象尝试转换为指定类型的数据 转换失败返回指定的默认值
        /// </summary>
        /// <typeparam name="T">指定的类型</typeparam>
        /// <param name="source">数据源</param>
        /// <param name="defVal">默认值</param>
        /// <param name="parser">值转换器 若给定的值转换器为null,则使用as强制转换,若as转换为null 则返回默认值</param>
        /// <returns></returns>
        public static T TryGetT<T>(object source, T defVal, ObjectValueTryParser<T> parser = null) where T : class
        {
            if (source == null) return defVal;
            if (parser == null) return source as T ?? defVal;
            T temp;
            if (parser(source, out temp))
            {
                return temp;
            }
            return source as T ?? defVal;
        }
 
        /// <summary>
        /// 从一行数据中尝试获取指定值类型的值
        /// </summary>
        /// <typeparam name="T">指定类型的值</typeparam>
        /// <param name="dr">源数据行</param>
        /// <param name="columnName">列名</param>
        /// <param name="defVal">列无效时返回的默认值</param>
        /// <param name="parser">值转换器</param>
        /// <returns></returns>
        public static T GetT<T>(DataRow dr, string columnName, T defVal, StringValueParser<T> parser) where T : struct
        {
            var obj = GetObject(dr, columnName);
            return GetT(obj, defVal, parser);
        }
        /// <summary>
        /// 将对象转换为指定类型数据 转换失败返回设置的默认值
        /// </summary>
        /// <typeparam name="T">指定的类型</typeparam>
        /// <param name="source">数据源</param>
        /// <param name="defVal">列无效时返回的默认值</param>
        /// <param name="parser">值转换器</param>
        /// <returns></returns>
        public static T GetT<T>(object source, T defVal, StringValueParser<T> parser) where T : struct
        {
            return source != null ? parser(source.ToString()) : defVal;
        }
 
        /// <summary>
        /// 从一行数据中尝试获取指定值类型的值
        /// </summary>
        /// <typeparam name="T">指定类型的值</typeparam>
        /// <param name="dr">源数据行</param>
        /// <param name="columnName">列名</param>
        /// <param name="defVal">列无效时返回的默认值</param>
        /// <param name="parser">值转换器</param>
        /// <returns></returns>
        public static T TryGetT<T>(DataRow dr, string columnName, T defVal, StringValueTryParser<T> parser) where T : struct
        {
            var obj = GetObject(dr, columnName);
            return TryGetT(obj, defVal, parser);
        }
 
        /// <summary>
        /// 将对象尝试转换为指定类型的数据 转换失败返回指定的默认值
        /// </summary>
        /// <typeparam name="T">指定的类型</typeparam>
        /// <param name="obj">数据源</param>
        /// <param name="defVal">默认值</param>
        /// <param name="parser">值转换器</param>
        /// <returns></returns>
        public static T TryGetT<T>(object obj, T defVal, StringValueTryParser<T> parser) where T : struct
        {
            if (obj != null)
            {
                T val;
                if (parser(obj.ToString(), out val))
                {
                    return val;
                }
            }
            return defVal;
        }
        /// <summary>
        /// 从一行数据中尝试获取字符串
        /// </summary>
        /// <param name="dr">源数据行</param>
        /// <param name="columnName">列名</param>
        /// <param name="defVal">列无效时返回的默认值</param>
        /// <returns></returns>
        public static string GetString(DataRow dr, string columnName, string defVal)
        {
            var obj = GetObject(dr, columnName);
            return obj != null ? obj.ToString() : defVal;
        }
        /// <summary>
        /// 获取字符串 检测  数据源为空时返回默认值
        /// </summary>
        /// <param name="source">数据源</param>
        /// <param name="defVal">默认值</param>
        /// <returns></returns>
        public static string GetString(object source, string defVal)
        {
            if (source != null)
            {
                return source as string ?? source.ToString();
            }
            return defVal;
        }
        /// <summary>
        /// 从一行数据中尝试获取整数
        /// </summary>
        /// <param name="dr">源数据行</param>
        /// <param name="columnName">列名</param>
        /// <param name="defVal">列无效时返回的默认值</param>
        /// <returns></returns>
        public static int GetInt(DataRow dr, string columnName, int defVal)
        {
            return TryGetT(dr, columnName, defVal, int.TryParse);
        }
        /// <summary>
        /// 从数据员获取整数
        /// </summary>
        /// <param name="source">数据源</param>
        /// <param name="defVal">获取失败时的默认值</param>
        /// <returns></returns>
        public static int GetInt(object source, int defVal)
        {
            return TryGetT(source, defVal, int.TryParse);
        }
        /// <summary>
        /// 从一行数据中尝试获取日期
        /// </summary>
        /// <param name="dr">源数据行</param>
        /// <param name="columnName">列名</param>
        /// <param name="defVal">列无效时返回的默认值</param>
        /// <returns></returns>
        public static DateTime GetDateTime(DataRow dr, string columnName, DateTime defVal)
        {
            return TryGetT(dr, columnName, defVal, DateTime.TryParse);
        }
        /// <summary>
        /// 从数据源中 获取日期
        /// </summary>
        /// <param name="source">数据源</param>
        /// <param name="defVal">获取失败时的默认值</param>
        /// <returns></returns>
        public static DateTime GetDateTime(object source, DateTime defVal)
        {
            return TryGetT(source, defVal, DateTime.TryParse);
        }
    }
}