C#擴展方法（語法糖）

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Web.Script.Serialization;
using System.Xml.Serialization;

namespace KN.Utility
{
    /// <summary>
    ///     [擴展類]對象級別擴展類
    /// </summary>
    public static class ObjExtension
    {
        /// <summary>
        ///     對輸入字符串進行MD5加密，返回小寫形式的加密字符串，字符串爲32字符的十六進制格式
        /// </summary>
        /// <param name="input">待加密的字符串</param>
        /// <returns>加密後的字符串</returns>
        public static string ToMD5(this string input)
        {
            using (var md5 = new MD5CryptoServiceProvider())
            {
                var data = md5.ComputeHash(Encoding.UTF8.GetBytes(input));
                return BitConverter.ToString(data).Replace("-", string.Empty).ToLower(CultureInfo.CurrentCulture);
            }
        }

        /// <summary>
        ///     判斷路徑是不是圖片, true 是，false 不是
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static bool IsImage(this string input)
        {
            var extesion = new[] { "jpg", "jpeg", "png", "tiff", "gif", "bmp" };
            return extesion.Any(s => input.ToLower().EndsWith("." + s));
        }

        /// <summary>
        ///     合併拼接路徑
        /// </summary>
        /// <param name="path"></param>
        /// <param name="append"></param>
        /// <returns></returns>
        public static string Combine(this string path, string append)
        {
            if (path.EndsWith("/") && append.StartsWith("/")) path = path.TrimEnd('/');
            if (path.EndsWith("\\") && append.StartsWith("\\")) path = path.TrimEnd('\\');
            return Path.Combine(path, append);
        }

        /// <summary>
        ///     DataTable轉Json文本
        /// </summary>
        /// <param name="dataTable"></param>
        /// <returns></returns>
        public static string ToJson(this DataTable dataTable)
        {
            var javaScriptSerializer = new JavaScriptSerializer { MaxJsonLength = int.MaxValue };
            var arrayList = new ArrayList();
            foreach (DataRow dataRow in dataTable.Rows)
            {
                var dictionary =
                    dataTable.Columns.Cast<DataColumn>().ToDictionary<DataColumn, string, object>(
                        dataColumn => dataColumn.ColumnName, dataColumn => dataRow[dataColumn.ColumnName].ToStr());
                //實例化一個參數集合
                arrayList.Add(dictionary); //ArrayList集合中添加鍵值
            }

            return javaScriptSerializer.Serialize(arrayList);
        }

        /// <summary>
        ///     重寫ToString()的方法，該方法首先判斷object是否爲空，如果對象爲空則返回string.Empty，否則返回該對象的字符串表現形式
        /// </summary>
        /// <param name="obj">需要轉換的對象</param>
        /// <returns>字符串</returns>
        public static string ToStr(this object obj)
        {
            return obj == null ? string.Empty : obj.ToString();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="def"></param>
        /// <returns></returns>
        public static string ToStr(this object obj, string def)
        {
            return obj == null ? def : obj.ToString();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="html"></param>
        /// <returns></returns>
        public static string RemoveHtml(this string html)
        {
            var strText = Regex.Replace(html, "<[^>]+>", "");
            strText = Regex.Replace(strText, "&[^;]+;", "");
            return strText;
        }

        /// <summary>
        ///     將此實例的字符串轉換爲它的有效數字表現形式，轉換失敗後默認返回0
        /// </summary>
        /// <param name="obj">需要轉換的字符串</param>
        /// <returns>整數</returns>
        public static int ToInt(this object obj)
        {
            return ToInt32(obj, 0);
        }

        /// <summary>
        ///     將日期轉換爲字符串，默認格式：yyyy-MM-dd
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="format"></param>
        /// <returns></returns>
        public static string ToDateString(this object obj, string format = "yyyy-MM-dd")
        {
            return obj.ToDateTime().ToString(format);
        }

        /// <summary>
        ///     將時間轉換爲字符串，默認格式：yyyy-MM-dd HH:ss
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="format"></param>
        /// <returns></returns>
        public static string ToDateTimeString(this object obj, string format = "yyyy-MM-dd HH:ss")
        {
            return obj.ToDateTime().ToString(format);
        }

        /// <summary>
        ///     Json格式驗證
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static string ToSafeJSON(this string input)
        {
            var stringBuilder = new StringBuilder(input.Length);
            foreach (var c in input)
                if (char.IsControl(c) || c == 39)
                {
                    int num = c;
                    stringBuilder.Append("\\u" + num.ToString("x4"));
                }
                else
                {
                    if (c == 34 || c == 92 || c == 47)
                        stringBuilder.Append('\\');
                    stringBuilder.Append(c);
                }

            return stringBuilder.ToString();
        }

        /// <summary>
        ///     將此實例的字符串轉換爲它的有效數字表現形式，轉換失敗後默認返回“0”
        /// </summary>
        /// <param name="obj">需要轉換的字符串</param>
        /// <param name="defaultVal">轉換失敗後的默認返回值</param>
        /// <returns>整數</returns>
        public static int ToInt(this object obj, int defaultVal)
        {
            return ToInt32(obj, defaultVal);
        }

        /// <summary>
        ///     將此實例的字符串轉換爲它的有效數字表現形式，轉換失敗後默認返回“0”
        /// </summary>
        /// <param name="str">需要轉換的字符串</param>
        /// <returns>返回轉換後的數字表現形式</returns>
        public static int ToInt32(this object str)
        {
            return ToInt32(str, 0);
        }

        /// <summary>
        ///     將此實例的字符串轉換爲它的有效數字表現形式，轉換失敗後默認返回“0”
        /// </summary>
        /// <param name="str">需要轉換的字符串</param>
        /// <param name="defaultVal">轉換失敗後的默認返回值</param>
        /// <returns>返回轉換後的數字表現形式</returns>
        public static int ToInt32(this object str, int defaultVal)
        {
            if (str == null) return defaultVal;

            var result = defaultVal;

            result = int.TryParse(str.ToString(), out defaultVal) ? defaultVal : result;

            return result;
        }

        /// <summary>
        ///     將此實例的字符串轉換爲它的有效長整型表現形式，轉換失敗後默認返回“0”
        /// </summary>
        /// <param name="str">需要轉換的對象</param>
        /// <returns>長整型數字表現形式</returns>
        public static long ToInt64(this object str)
        {
            long defaultVal;
            if (str == null) return 0;
            long.TryParse(str.ToString(), out defaultVal);
            return defaultVal;
        }

        /// <summary>
        ///     將此實例的字符串轉換爲它的有效十進制數表現形式
        /// </summary>
        /// <param name="str">需要轉換的字符串</param>
        /// <returns>返回轉換後的數字表現形式</returns>
        public static decimal ToDecimal(this object str)
        {
            return ToDecimal(str, 0);
        }

        /// <summary>
        ///     將此實例的字符串轉換爲它的有效十進制數表現形式
        /// </summary>
        /// <param name="str">需要轉換的字符串</param>
        /// <param name="defaultVal">轉換失敗後的默認返回值</param>
        /// <returns>返回轉換後的數字表現形式</returns>
        public static decimal ToDecimal(this object str, decimal defaultVal)
        {
            if (str.ToStr().IsEmpty()) return defaultVal;

            decimal.TryParse(str.ToStr(), out defaultVal);

            return defaultVal;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static double ToDouble(this object str)
        {
            return ToDouble(str, 0.0);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="str"></param>
        /// <param name="defaultVal"></param>
        /// <returns></returns>
        public static double ToDouble(this object str, double defaultVal)
        {
            if (str.ToStr().IsEmpty()) return defaultVal;

            double.TryParse(str.ToStr(), out defaultVal);

            return defaultVal;
        }

        /// <summary>
        ///     四捨五入格式化貨幣，默認保留兩位小數，格式不對將返回0.00
        ///     格式前: 163.2545 格式結果: 163.25
        /// </summary>
        /// <param name="dDecimal">需要轉換的貨幣數字</param>
        /// <returns>返回轉換後的數字表現形式</returns>
        public static decimal ToDecimalFormat(this object dDecimal)
        {
            return Math.Round(dDecimal.ToDecimal(), 2, MidpointRounding.AwayFromZero).ToString("F2").ToDecimal();
        }

        /// <summary>
        ///     四捨五入格式化貨幣，指定小數位數，格式不對將返回0.小數點位數
        ///     格式前: 163.2545 格式結果: 163.25
        /// </summary>
        /// <param name="dDecimal">需要轉換的貨幣數字</param>
        /// <param name="decimals">小數位置</param>
        /// <returns>返回轉換後的數字表現形式</returns>
        public static decimal ToDecimalFormat(this string dDecimal, int decimals)
        {
            return
                Math.Round(dDecimal.ToDecimal(), decimals, MidpointRounding.AwayFromZero).ToString("F" + decimals)
                    .ToDecimal();
        }

        /// <summary>
        ///     將此實例的字符串轉換爲它的有效數字表現形式
        /// </summary>
        /// <param name="str">需要轉換的字符串</param>
        /// <returns>返回轉換後的數字表現形式</returns>
        public static long ToLong(this object str)
        {
            return ToLong(str, 0);
        }

        /// <summary>
        ///     將此實例的字符串轉換爲它的有效數字表現形式
        /// </summary>
        /// <param name="str">需要轉換的字符串</param>
        /// <param name="defaultVal">轉換失敗後的默認返回值</param>
        /// <returns>返回轉換後的數字表現形式</returns>
        public static long ToLong(this object str, long defaultVal)
        {
            if (str == null) return defaultVal;

            long.TryParse(str.ToString(), out defaultVal);

            return defaultVal;
        }

        /// <summary>
        ///     將此實例的字符串轉換爲它的有效日期時間表現形式
        /// </summary>
        /// <param name="str">需要轉換的字符串</param>
        /// <returns>返回轉換後的數字表現形式</returns>
        public static DateTime ToDateTime(this object str)
        {
            var dt = new DateTime(1900, 1, 1);

            return string.IsNullOrEmpty(str.ToStr()) ? dt : ToDateTime(str, dt);
        }

        /// <summary>
        ///     將此實例的字符串轉換爲它的有效日期時間表現形式
        /// </summary>
        /// <param name="str">需要轉換的字符串</param>
        /// <param name="defaultVal">轉換失敗後的默認返回值</param>
        /// <returns>返回轉換後的數字表現形式</returns>
        public static DateTime ToDateTime(this object str, DateTime defaultVal)
        {
            if (str == null || str.ToStr().IsEmpty()) return defaultVal;
            var result = defaultVal;
            if (!DateTime.TryParse(str.ToString(), out result)) result = defaultVal;
            return result;
        }

        /// <summary>
        ///     將此實例的字符串轉換爲它的有效布爾值表現形式，默認中(不區分大小寫) True，1，Y 都爲True類型
        /// </summary>
        /// <param name="str">需要轉換的字符串</param>
        /// <returns>返回轉換後的數字表現形式</returns>
        public static bool ToBoolean(this object str)
        {
            return ToBoolean(str, false);
        }

        /// <summary>
        ///     將此實例的字符串轉換爲它的有效布爾值表現形式，默認中(不區分大小寫) True，1，Y 都爲True類型
        /// </summary>
        /// <param name="str">需要轉換的字符串</param>
        /// <param name="defaultVal">轉換失敗後的默認返回值</param>
        /// <returns>返回轉換後的數字表現形式</returns>
        public static bool ToBoolean(this object str, bool defaultVal)
        {
            if (string.IsNullOrEmpty(str.ToStr()))
                return defaultVal;

            return str.ToString().ToLower() == "true" || str.ToString().ToLower() == "1" ||
                   str.ToString().ToLower() == "y" || str.ToString() == "是";
        }

        /// <summary>
        ///     將對象序列化爲Xml串
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static string ToXml(this object obj)
        {
            try
            {
                using (var sw = new StringWriter())
                {
                    var xz = new XmlSerializer(obj.GetType());
                    xz.Serialize(sw, obj);
                    return sw.ToString();
                }
            }
            catch (Exception ex)
            {
                return ex.Message;
            }
        }

        /// <summary>
        ///     將一個對象轉成JSON字符串。
        /// </summary>
        /// <param name="obj">需要轉成JSON的對象。</param>
        /// <returns>返回JSON格式字符串。</returns>
        public static string ToJson(this object obj)
        {
            return JsonSerialize(obj);
        }

        /// <summary>
        ///     Json序列化對象
        /// </summary>
        /// <typeparam name="T">對象類型</typeparam>
        /// <param name="t">對象</param>
        /// <returns></returns>
        public static string JsonSerialize<T>(T t)
        {
            try
            {
                var serializer = new JavaScriptSerializer { MaxJsonLength = int.MaxValue };
                return serializer.Serialize(t);
            }
            catch (Exception ex)
            {
            }

            return string.Empty;
        }


        /// <summary>
        ///     獲取字段描述
        /// </summary>
        /// <param name="enumVal"></param>
        /// <returns></returns>
        public static string GetDescription(this Enum enumVal)
        {
            var field = enumVal.GetType().GetField(enumVal.ToString());
            if (field != null)
                foreach (DescriptionAttribute desc in field.GetCustomAttributes(typeof(DescriptionAttribute), false))
                    return desc.Description;
            return "";
        }


        /// <summary>
        /// 
        /// </summary>
        /// <param name="val"></param>
        /// <returns></returns>
        public static bool IsEmpty(this object val)
        {
            if (val == null) return true;
            return string.IsNullOrEmpty(val.ToString());
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="val"></param>
        /// <returns></returns>
        public static bool IsNotEmpty(this object val)
        {
            return !IsEmpty(val);
        }

        /// <summary>
        /// 過濾sql字符串
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static string FilterSql(this string input)
        {
            if (string.IsNullOrEmpty(input))
            {
                return "";
            }
            input = input.Trim();
            input = SqlTextFilter.Filter(input);
            input = SqlTextFilter.FilterSqlStr(input);
            input = SqlTextFilter.ReplaceSqlChar(input);
            input = SqlTextFilter.SqlFilter(input);
            return input;
        }
    }
}