.NET 一些常用的类型转换扩展

走着看着忘着

记录下在开发中经常用到的类型转换

1.     /// <summary>
2.     /// 转换扩展类
3.     /// </summary>
4.     public static partial class Extensions
5.     {
6.         #region 转换为long
8.         /// <summary>
9.         /// 将object转换为long，若转换失败，则返回0。不抛出异常。  
10.         /// </summary>
11.         /// <param name="obj"></param>
12.         /// <returns></returns>
13.         public static long ParseToLong(this object obj)
14.         {
15.             try
16.             {
17.                 return long.Parse(obj.ToString() ?? string.Empty);
18.             }
19.             catch
20.             {
21.                 return 0L;
22.             }
23.         }
25.         /// <summary>
26.         /// 将object转换为long，若转换失败，则返回指定值。不抛出异常。  
27.         /// </summary>
28.         /// <param name="str"></param>
29.         /// <param name="defaultValue"></param>
30.         /// <returns></returns>
31.         public static long ParseToLong(this string str, long defaultValue)
32.         {
33.             try
34.             {
35.                 return long.Parse(str);
36.             }
37.             catch
38.             {
39.                 return defaultValue;
40.             }
41.         }
43.         #endregion
45.         #region 转换为int
47.         /// <summary>
48.         /// 将object转换为int，若转换失败，则返回0。不抛出异常。  
49.         /// </summary>
50.         /// <param name="str"></param>
51.         /// <returns></returns>
52.         public static int ParseToInt(this object str)
53.         {
54.             try
55.             {
56.                 return Convert.ToInt32(str);
57.             }
58.             catch
59.             {
60.                 return 0;
61.             }
62.         }
64.         /// <summary>
65.         /// 将object转换为int，若转换失败，则返回指定值。不抛出异常。
66.         /// null返回默认值
67.         /// </summary>
68.         /// <param name="str"></param>
69.         /// <param name="defaultValue"></param>
70.         /// <returns></returns>
71.         public static int ParseToInt(this object str, int defaultValue)
72.         {
73.             if (str == null)
74.             {
75.                 return defaultValue;
76.             }
78.             try
79.             {
80.                 return Convert.ToInt32(str);
81.             }
82.             catch
83.             {
84.                 return defaultValue;
85.             }
86.         }
88.         #endregion
90.         #region 转换为short
92.         /// <summary>
93.         /// 将object转换为short，若转换失败，则返回0。不抛出异常。  
94.         /// </summary>
95.         /// <param name="obj"></param>
96.         /// <returns></returns>
97.         public static short ParseToShort(this object obj)
98.         {
99.             try
100.             {
101.                 return short.Parse(obj.ToString() ?? string.Empty);
102.             }
103.             catch
104.             {
105.                 return 0;
106.             }
107.         }
109.         /// <summary>
110.         /// 将object转换为short，若转换失败，则返回指定值。不抛出异常。  
111.         /// </summary>
112.         /// <param name="str"></param>
113.         /// <param name="defaultValue"></param>
114.         /// <returns></returns>
115.         public static short ParseToShort(this object str, short defaultValue)
116.         {
117.             try
118.             {
119.                 return short.Parse(str.ToString() ?? string.Empty);
120.             }
121.             catch
122.             {
123.                 return defaultValue;
124.             }
125.         }
127.         #endregion
129.         #region 转换为demical
131.         /// <summary>
132.         /// 将object转换为demical，若转换失败，则返回指定值。不抛出异常。  
133.         /// </summary>
134.         /// <param name="str"></param>
135.         /// <param name="defaultValue"></param>
136.         /// <returns></returns>
137.         public static decimal ParseToDecimal(this object str, decimal defaultValue)
138.         {
139.             try
140.             {
141.                 return decimal.Parse(str.ToString() ?? string.Empty);
142.             }
143.             catch
144.             {
145.                 return defaultValue;
146.             }
147.         }
149.         /// <summary>
150.         /// 将object转换为demical，若转换失败，则返回0。不抛出异常。  
151.         /// </summary>
152.         /// <param name="str"></param>
153.         /// <returns></returns>
154.         public static decimal ParseToDecimal(this object str)
155.         {
156.             try
157.             {
158.                 return decimal.Parse(str.ToString() ?? string.Empty);
159.             }
160.             catch
161.             {
162.                 return 0;
163.             }
164.         }
166.         #endregion
168.         #region 转化为bool
170.         /// <summary>
171.         /// 将object转换为bool，若转换失败，则返回false。不抛出异常。  
172.         /// </summary>
173.         /// <param name="str"></param>
174.         /// <returns></returns>
175.         public static bool ParseToBool(this object str)
176.         {
177.             try
178.             {
179.                 return bool.Parse(str.ToString() ?? string.Empty);
180.             }
181.             catch
182.             {
183.                 return false;
184.             }
185.         }
187.         /// <summary>
188.         /// 将object转换为bool，若转换失败，则返回指定值。不抛出异常。  
189.         /// </summary>
190.         /// <param name="str"></param>
191.         /// <param name="result"></param>
192.         /// <returns></returns>
193.         public static bool ParseToBool(this object str, bool result)
194.         {
195.             try
196.             {
197.                 return bool.Parse(str.ToString() ?? string.Empty);
198.             }
199.             catch
200.             {
201.                 return result;
202.             }
203.         }
205.         #endregion
207.         #region 转换为float
209.         /// <summary>
210.         /// 将object转换为float，若转换失败，则返回0。不抛出异常。  
211.         /// </summary>
212.         /// <param name="str"></param>
213.         /// <returns></returns>
214.         public static float ParseToFloat(this object str)
215.         {
216.             try
217.             {
218.                 return float.Parse(str.ToString() ?? string.Empty);
219.             }
220.             catch
221.             {
222.                 return 0;
223.             }
224.         }
226.         /// <summary>
227.         /// 将object转换为float，若转换失败，则返回指定值。不抛出异常。  
228.         /// </summary>
229.         /// <param name="str"></param>
230.         /// <param name="result"></param>
231.         /// <returns></returns>
232.         public static float ParseToFloat(this object str, float result)
233.         {
234.             try
235.             {
236.                 return float.Parse(str.ToString() ?? string.Empty);
237.             }
238.             catch
239.             {
240.                 return result;
241.             }
242.         }
244.         #endregion
246.         #region 转换为Guid
248.         /// <summary>
249.         /// 将string转换为Guid，若转换失败，则返回Guid.Empty。不抛出异常。  
250.         /// </summary>
251.         /// <param name="str"></param>
252.         /// <returns></returns>
253.         public static Guid ParseToGuid(this string str)
254.         {
255.             try
256.             {
257.                 return new Guid(str);
258.             }
259.             catch
260.             {
261.                 return Guid.Empty;
262.             }
263.         }
265.         #endregion
267.         #region 转换为string
269.         /// <summary>
270.         /// 将object转换为string，若转换失败，则返回""。不抛出异常。  
271.         /// </summary>
272.         /// <param name="obj"></param>
273.         /// <returns></returns>
274.         public static string ParseToString(this object obj)
275.         {
276.             try
277.             {
278.                 return obj == null ? string.Empty : obj.ToString();
279.             }
280.             catch
281.             {
282.                 return string.Empty;
283.             }
284.         }
286.         /// <summary>
287.         ///
288.         /// </summary>
289.         /// <typeparam name="T"></typeparam>
290.         /// <param name="obj"></param>
291.         /// <returns></returns>
292.         public static string ParseToStrings<T>(this object obj)
293.         {
294.             try
295.             {
296.                 if (obj is IEnumerable<T> list)
297.                 {
298.                     return string.Join(",", list);
299.                 }
301.                 return obj.ToString();
302.             }
303.             catch
304.             {
305.                 return string.Empty;
306.             }
307.         }
309.         #endregion
311.         #region 转换为double
313.         /// <summary>
314.         /// 将object转换为double，若转换失败，则返回0。不抛出异常。  
315.         /// </summary>
316.         /// <param name="obj"></param>
317.         /// <returns></returns>
318.         public static double ParseToDouble(this object obj)
319.         {
320.             try
321.             {
322.                 return double.Parse(obj.ToString() ?? string.Empty);
323.             }
324.             catch
325.             {
326.                 return 0;
327.             }
328.         }
330.         /// <summary>
331.         /// 将object转换为double，若转换失败，则返回指定值。不抛出异常。  
332.         /// </summary>
333.         /// <param name="str"></param>
334.         /// <param name="defaultValue"></param>
335.         /// <returns></returns>
336.         public static double ParseToDouble(this object str, double defaultValue)
337.         {
338.             try
339.             {
340.                 return double.Parse(str.ToString() ?? string.Empty);
341.             }
342.             catch
343.             {
344.                 return defaultValue;
345.             }
346.         }
348.         #endregion
350.         #region 强制转换类型
352.         /// <summary>
353.         /// 强制转换类型
354.         /// </summary>
355.         /// <typeparam name="TResult"></typeparam>
356.         /// <param name="source"></param>
357.         /// <returns></returns>
358.         public static IEnumerable<TResult> CastSuper<TResult>(this IEnumerable source)
359.         {
360.             return from object item in source select (TResult)Convert.ChangeType(item, typeof(TResult));
361.         }
363.         #endregion
365.         #region 转换为ToUnixTime
367.         public static long ParseToUnixTime(this DateTime nowTime)
368.         {
369.             var startTime = new DateTime(1970, 1, 1, 0, 0, 0, 0);
370.             return (long)Math.Round((nowTime - startTime).TotalMilliseconds, MidpointRounding.AwayFromZero);
371.         }
373.         #endregion
375.         #region List转DataTable
376.         /// <summary>
377.         /// List转DataTable
378.         /// </summary>
379.         /// <typeparam name="T"></typeparam>
380.         /// <param name="list"></param>
381.         /// <returns></returns>
382.         public static DataTable ListToDataTable<T>(IEnumerable<T> list)
383.         {
384.             //创建属性的集合
385.             List<PropertyInfo> pList = new List<PropertyInfo>();
386.             //获得反射的入口
387.             Type type = typeof(T);
388.             DataTable dt = new DataTable();
389.             //把所有的public属性加入到集合 并添加DataTable的列
390.             Array.ForEach<PropertyInfo>(type.GetProperties(), p =>
391.             {
392.                 pList.Add(p);
393.                 var theType = p.PropertyType;
394.                 //处理可空类型
395.                 if (theType.IsGenericType && theType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
396.                 {
397.                     dt.Columns.Add(p.Name, Nullable.GetUnderlyingType(theType));
398.                 }
399.                 else
400.                 {
401.                     dt.Columns.Add(p.Name, theType);
402.                 }
403.             });
404.             foreach (var item in list)
405.             {
406.                 //创建一个DataRow实例
407.                 DataRow row = dt.NewRow();
408.                 //给row 赋值
409.                 pList.ForEach(p =>
410.                 {
411.                     var v = p.GetValue(item, null);
412.                     row[p.Name] = v == null ? DBNull.Value : v;
413.                 });
414.                 //加入到DataTable
415.                 dt.Rows.Add(row);
416.             }
417.             return dt;
418.         }
421.         /// <summary>
422.         /// List转DataTable
423.         /// </summary>
424.         /// <param name="list"></param>
425.         /// <returns></returns>
426.         public static DataTable ListToDataTableNew(List<dynamic> list)
427.         {
428.             Dictionary<string, string> dic = new Dictionary<string, string>();
429.             DataTable dt = new DataTable();
430.             if (list != null && list.Count > 0)
431.             {
432.                 foreach (var item in list[0])
433.                 {
434.                     string text = item.ToString();
435.                     string key = text.Substring(1, text.IndexOf(',') - 1);
436.                     string value = text.Substring(text.IndexOf(',') + 1, text.Length - text.IndexOf(',') - 2);
437.                     dt.Columns.Add(key);
438.                 }
439.             }
440.             foreach (var vlist in list)
441.             {
442.                 DataRow row = dt.NewRow();
443.                 foreach (var item in vlist)
444.                 {
445.                     string text = item.ToString();
446.                     string key = text.Substring(1, text.IndexOf(',') - 1);
447.                     string value = text.Substring(text.IndexOf(',') + 1, text.Length - text.IndexOf(',') - 2);
448.                     //创建一个DataRow实例
449.                     row[key] = value;
450.                 }
451.                 //加入到DataTable
452.                 dt.Rows.Add(row);
453.             }
454.             return dt;
455.         }
456.         #endregion
458.         #region 处理Excel单元格特殊字符
459.         /// <summary>
460.         /// 处理Excel单元格特殊字符
461.         /// </summary>
462.         /// <param name="str"></param>
463.         /// <returns></returns>
464.         public static string ExcelCellHandle(string str)
465.         {
466.             return ToSBC(str.Replace("\n", string.Empty).Replace("_", string.Empty).Replace(" ", string.Empty).Replace("'", string.Empty));
467.         }
469.         /// <summary>
470.         /// 转化为半角字符串（扩展方法）
471.         /// </summary>
472.         /// <param name="input">要转化的字符串</param>
473.         /// <returns>半角字符串</returns>
474.         public static string ToSBC(string input)//single byte charactor
475.         {
476.             char[] c = input.ToCharArray();
477.             for (int i = 0; i < c.Length; i++)
478.             {
479.                 if (c[i] == 12288)//全角空格为12288，半角空格为32
480.                 {
481.                     c[i] = (char)32;
482.                     continue;
483.                 }
484.                 if (c[i] > 65280 && c[i] < 65375)//其他字符半角(33-126)与全角(65281-65374)的对应关系是：均相差65248
485.                     c[i] = (char)(c[i] - 65248);
486.             }
487.             return new string(c);
488.         }
489.         #endregion
491.         #region 删除最后一个字符之后的字符
492.         /// <summary>
493.         /// 删除最后结尾的一个逗号
494.         /// </summary>
495.         public static string DelLastComma(string str)
496.         {
497.             return str.Substring(0, str.LastIndexOf(","));
498.         }
499.         /// <summary>
500.         /// 删除最后结尾的指定字符后的字符
501.         /// </summary>
502.         public static string DelLastChar(string str, string strchar)
503.         {
504.             return str.Substring(0, str.LastIndexOf(strchar));
505.         }
506.         /// <summary>
507.         /// 删除最后结尾的长度
508.         /// </summary>
509.         /// <param name="str"></param>
510.         /// <param name="Length"></param>
511.         /// <returns></returns>
512.         public static string DelLastLength(string str, int Length)
513.         {
514.             if (string.IsNullOrEmpty(str))
515.                 return "";
516.             str = str.Substring(0, str.Length - Length);
517.             return str;
518.         }
519.         #endregion
520.     }

复制代码

 

来源:https://www.cnblogs.com/caojiming/archive/2023/10/16/17767080.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！