/*******************************************************************************
 * Copyright © 2017-2020 Znyc.Recruitment.Admin.Framework 版权所有
 * Author: Znyc
 * Description: Znyc快速开发平台
 * Website：http://www.Znyc.Recruitment.Admin.com
*********************************************************************************/

using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Text.RegularExpressions;
using System.Web;
using System.Xml;
using System.Xml.Linq;

namespace Znyc.Recruitment.Admin.Commons.Extensions
{
    /// <summary>
    ///     对象自定义扩展类
    /// </summary>
    public static class ObjectExtension
    {
        private static readonly Regex BoolRegex =
            new("(?<info>(true|false))", RegexOptions.IgnoreCase | RegexOptions.Singleline);

        private static readonly Regex IntRegex =
            new("(?<info>-?\\d+)", RegexOptions.IgnoreCase | RegexOptions.Singleline);

        private static readonly Regex DecimalRegex =
            new("(?<info>-?\\d+(\\.\\d+)?)", RegexOptions.IgnoreCase | RegexOptions.Singleline);

        private static readonly Regex DateTimeRegex = new(
            "(?<info>(((\\d+)[/年-](0?[13578]|1[02])[/月-](3[01]|[12]\\d|0?\\d)[日]?)|((\\d+)[/年-](0?[469]|11)[/月-](30|[12]\\d|0?\\d)[日]?)|((\\d+)[/年-]0?2[/月-](2[0-8]|1\\d|0?\\d)[日]?))(\\s((2[0-3]|[0-1]\\d)):[0-5]\\d:[0-5]\\d)?)"
            ,
            RegexOptions.IgnoreCase | RegexOptions.Singleline);

        private static readonly Regex TimeSpanRegex =
            new(
                "(?<info>-?(\\d+\\.(([0-1]\\d)|(2[0-3])):[0-5]\\d:[0-5]\\d)|((([0-1]\\d)|(2[0-3])):[0-5]\\d:[0-5]\\d)|(\\d+))"
                ,
                RegexOptions.IgnoreCase | RegexOptions.Singleline);

        private static readonly Regex GuidRegex =
            new(
                "(?<info>\\{{0,1}([0-9a-fA-F]){8}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){12}\\}{0,1})"
                ,
                RegexOptions.IgnoreCase | RegexOptions.Singleline);

        private static readonly Regex MobileRegex = new("^1[3|4|5|7|8][0-9]\\d{4,8}$");

        private static readonly Regex EmailRegex =
            new("^([a-zA-Z0-9_-])+@([a-zA-Z0-9_-])+((\\.[a-zA-Z0-9_-]{2,3}){1,2})$");

        /// <summary>
        ///     将集合转换为数据集。
        /// </summary>
        /// <typeparam name="T">转换的元素类型。</typeparam>
        /// <param name="list">集合。</param>
        /// <param name="generic">是否生成泛型数据集。</param>
        /// <returns>数据集。</returns>
        public static DataSet ToDataSet<T>(this IEnumerable<T> list, bool generic = true)
        {
            return ListToDataSet(list, generic);
        }

        /// <summary>
        ///     将集合转换为数据集。
        /// </summary>
        /// <param name="list">集合。</param>
        /// <param name="generic">是否生成泛型数据集。</param>
        /// <returns>数据集。</returns>
        public static DataSet ToDataSet(this IEnumerable list, bool generic = true)
        {
            return ListToDataSet(list, generic);
        }

        /// <summary>
        ///     将集合转换为数据集。
        /// </summary>
        /// <typeparam name="T">转换的元素类型。</typeparam>
        /// <param name="list">集合。</param>
        /// <param name="generic">是否生成泛型数据集。</param>
        /// <returns>数据集。</returns>
        public static DataSet ToDataSet<T>(this IEnumerable list, bool generic = true)
        {
            return ListToDataSet(list, typeof(T), generic);
        }

        /// <summary>
        ///     将实例转换为集合数据集。
        /// </summary>
        /// <typeparam name="T">实例类型。</typeparam>
        /// <param name="o">实例。</param>
        /// <param name="generic">是否生成泛型数据集。</param>
        /// <returns>数据集。</returns>
        public static DataSet ToListSet<T>(this T o, bool generic = true)
        {
            if (o is IEnumerable)
            {
                return ListToDataSet(o as IEnumerable, generic);
            }

            return ListToDataSet(new[] { o }, generic);
        }

        /// <summary>
        ///     将可序列化实例转换为XmlDocument。
        /// </summary>
        /// <typeparam name="T">实例类型。</typeparam>
        /// <param name="o">实例。</param>
        /// <returns>XmlDocument。</returns>
        public static XmlDocument ToXmlDocument<T>(this T o)
        {
            XmlDocument xmlDocument = new XmlDocument
            {
                InnerXml = o.ToListSet().GetXml()
            };
            return xmlDocument;
        }

        public static object ChangeType(this object convertibleValue, Type type)
        {
            if (null == convertibleValue)
            {
                return null;
            }

            try
            {
                if (type == typeof(Guid) || type == typeof(Guid?))
                {
                    string value = convertibleValue.ToString();
                    if (value == "")
                    {
                        return null;
                    }

                    return Guid.Parse(value);
                }

                if (!type.IsGenericType)
                {
                    return Convert.ChangeType(convertibleValue, type);
                }

                if (type.ToString() == "System.Nullable`1[System.Boolean]" || type.ToString() == "System.Boolean")
                {
                    if (convertibleValue.ToString() == "0")
                    {
                        return false;
                    }

                    return true;
                }

                Type genericTypeDefinition = type.GetGenericTypeDefinition();
                if (genericTypeDefinition == typeof(Nullable<>))
                {
                    return Convert.ChangeType(convertibleValue, Nullable.GetUnderlyingType(type));
                }
            }
            catch
            {
                return null;
            }

            return null;
        }

        /// <summary>
        ///     获取对象里指定成员名称
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <param name="properties"> 格式 Expression<Func<entityt, object>> exp = x => new { x.字段1, x.字段2 };或x=>x.Name</param>
        /// <returns></returns>
        public static string[] GetExpressionProperty<TEntity>(this Expression<Func<TEntity, object>> properties)
        {
            if (properties == null)
            {
                return new string[] { };
            }

            if (properties.Body is NewExpression)
            {
                return ((NewExpression)properties.Body).Members.Select(x => x.Name).ToArray();
            }

            if (properties.Body is MemberExpression)
            {
                return new[] { ((MemberExpression)properties.Body).Member.Name };
            }

            if (properties.Body is UnaryExpression)
            {
                return new[] { ((properties.Body as UnaryExpression).Operand as MemberExpression).Member.Name };
            }

            throw new Exception("未实现的表达式");
        }

        /// <summary>
        ///     将集合转换为数据集。
        /// </summary>
        /// <param name="list">集合。</param>
        /// <param name="t">转换的元素类型。</param>
        /// <param name="generic">是否生成泛型数据集。</param>
        /// <returns>转换后的数据集。</returns>
        private static DataSet ListToDataSet(IEnumerable list, Type t, bool generic)
        {
            DataSet ds = new DataSet("Data");
            if (t == null)
            {
                if (list != null)
                {
                    foreach (object i in list)
                    {
                        if (i == null)
                        {
                            continue;
                        }

                        t = i.GetType();
                        break;
                    }
                }

                if (t == null)
                {
                    return ds;
                }
            }

            ds.Tables.Add(t.Name);
            //如果集合中元素为DataSet扩展涉及到的基本类型时，进行特殊转换。
            if (t.IsValueType || t == typeof(string))
            {
                ds.Tables[0].TableName = "Info";
                ds.Tables[0].Columns.Add(t.Name);
                if (list != null)
                {
                    foreach (object i in list)
                    {
                        DataRow addRow = ds.Tables[0].NewRow();
                        addRow[t.Name] = i;
                        ds.Tables[0].Rows.Add(addRow);
                    }
                }

                return ds;
            }

            //处理模型的字段和属性。
            FieldInfo[] fields = t.GetFields();
            PropertyInfo[] properties = t.GetProperties();
            foreach (FieldInfo j in fields)
            {
                if (!ds.Tables[0].Columns.Contains(j.Name))
                {
                    if (generic)
                    {
                        ds.Tables[0].Columns.Add(j.Name, j.FieldType);
                    }
                    else
                    {
                        ds.Tables[0].Columns.Add(j.Name);
                    }
                }
            }

            foreach (PropertyInfo j in properties)
            {
                if (!ds.Tables[0].Columns.Contains(j.Name))
                {
                    if (generic)
                    {
                        ds.Tables[0].Columns.Add(j.Name, j.PropertyType);
                    }
                    else
                    {
                        ds.Tables[0].Columns.Add(j.Name);
                    }
                }
            }

            if (list == null)
            {
                return ds;
            }
            //读取list中元素的值。
            foreach (object i in list)
            {
                if (i == null)
                {
                    continue;
                }

                DataRow addRow = ds.Tables[0].NewRow();
                foreach (FieldInfo j in fields)
                {
                    MemberExpression field = Expression.Field(Expression.Constant(i), j.Name);
                    LambdaExpression lambda = Expression.Lambda(field);
                    Delegate func = lambda.Compile();
                    object value = func.DynamicInvoke();
                    addRow[j.Name] = value;
                }

                foreach (PropertyInfo j in properties)
                {
                    MemberExpression property = Expression.Property(Expression.Constant(i), j);
                    LambdaExpression lambda = Expression.Lambda(property);
                    Delegate func = lambda.Compile();
                    object value = func.DynamicInvoke();
                    addRow[j.Name] = value;
                }

                ds.Tables[0].Rows.Add(addRow);
            }

            return ds;
        }

        /// <summary>
        ///     将集合转换为数据集。
        /// </summary>
        /// <typeparam name="T">转换的元素类型。</typeparam>
        /// <param name="list">集合。</param>
        /// <param name="generic">是否生成泛型数据集。</param>
        /// <returns>数据集。</returns>
        private static DataSet ListToDataSet<T>(IEnumerable<T> list, bool generic)
        {
            return ListToDataSet(list, typeof(T), generic);
        }

        /// <summary>
        ///     将集合转换为数据集。
        /// </summary>
        /// <param name="list">集合。</param>
        /// <param name="generic">是否转换为字符串形式。</param>
        /// <returns>转换后的数据集。</returns>
        private static DataSet ListToDataSet(IEnumerable list, bool generic)
        {
            return ListToDataSet(list, null, generic);
        }

        /// <summary>
        ///     获取DataSet第一表，第一行，第一列的值。
        /// </summary>
        /// <param name="ds">DataSet数据集。</param>
        /// <returns>值。</returns>
        public static object GetData(this DataSet ds)
        {
            if (
                ds == null
                || ds.Tables.Count == 0
            )
            {
                return string.Empty;
            }

            return ds.Tables[0].GetData();
        }

        /// <summary>
        ///     获取DataTable第一行，第一列的值。
        /// </summary>
        /// <param name="dt">DataTable数据集表。</param>
        /// <returns>值。</returns>
        public static object GetData(this DataTable dt)
        {
            if (
                dt.Columns.Count == 0
                || dt.Rows.Count == 0
            )
            {
                return string.Empty;
            }

            return dt.Rows[0][0];
        }

        /// <summary>
        ///     获取DataSet第一个匹配columnName的值。
        /// </summary>
        /// <param name="ds">数据集。</param>
        /// <param name="columnName">列名。</param>
        /// <returns>值。</returns>
        public static object GetData(this DataSet ds, string columnName)
        {
            if (
                ds == null
                || ds.Tables.Count == 0
            )
            {
                return string.Empty;
            }

            foreach (DataTable dt in ds.Tables)
            {
                object o = dt.GetData(columnName);
                if (!string.IsNullOrEmpty(o.ToString()))
                {
                    return o;
                }
            }

            return string.Empty;
        }

        /// <summary>
        ///     获取DataTable第一个匹配columnName的值。
        /// </summary>
        /// <param name="dt">数据表。</param>
        /// <param name="columnName">列名。</param>
        /// <returns>值。</returns>
        public static object GetData(this DataTable dt, string columnName)
        {
            if (string.IsNullOrEmpty(columnName))
            {
                return GetData(dt);
            }

            if (
                dt.Columns.Count == 0
                || dt.Columns.IndexOf(columnName) == -1
                || dt.Rows.Count == 0
            )
            {
                return string.Empty;
            }

            return dt.Rows[0][columnName];
        }

        /// <summary>
        ///     将object转换为string类型信息。
        /// </summary>
        /// <param name="o">object。</param>
        /// <param name="t">默认值。</param>
        /// <returns>string。</returns>
        public static string ToString(this object o, string t)
        {
            string info = string.Empty;
            if (o == null)
            {
                info = t;
            }
            else
            {
                info = o.ToString();
            }

            return info;
        }

        /// <summary>
        ///     将DateTime?转换为string类型信息。
        /// </summary>
        /// <param name="o">DateTime?。</param>
        /// <param name="format">标准或自定义日期和时间格式的字符串。</param>
        /// <param name="t">默认值。</param>
        /// <returns>string。</returns>
        public static string ToString(this DateTime? o, string format, string t)
        {
            string info = string.Empty;
            if (o == null)
            {
                info = t;
            }
            else
            {
                info = o.Value.ToString(format);
            }

            return info;
        }

        /// <summary>
        ///     将TimeSpan?转换为string类型信息。
        /// </summary>
        /// <param name="o">TimeSpan?。</param>
        /// <param name="format">标准或自定义时间格式的字符串。</param>
        /// <param name="t">默认值。</param>
        /// <returns>string。</returns>
        public static string ToString(this TimeSpan? o, string format, string t)
        {
            string info = string.Empty;
            if (o == null)
            {
                info = t;
            }
            else
            {
                info = o.Value.ToString(format);
            }

            return info;
        }

        /// <summary>
        ///     将object转换为截取后的string类型信息。
        /// </summary>
        /// <param name="o">object。</param>
        /// <param name="startIndex">此实例中子字符串的起始字符位置（从零开始）。</param>
        /// <param name="length">子字符串中的字符数。</param>
        /// <param name="suffix">后缀。如果没有截取则不添加。</param>
        /// <returns>截取后的string类型信息。</returns>
        public static string ToSubString(this object o, int startIndex, int length, string suffix = null)
        {
            string inputString = o.ToString(string.Empty);
            startIndex = Math.Max(startIndex, 0);
            startIndex = Math.Min(startIndex, inputString.Length - 1);
            length = Math.Max(length, 1);
            if (startIndex + length > inputString.Length)
            {
                length = inputString.Length - startIndex;
            }

            if (inputString.Length == startIndex + length)
            {
                return inputString;
            }

            return inputString.Substring(startIndex, length) + suffix;
        }

        /// <summary>
        ///     将object转换为byte类型信息。
        /// </summary>
        /// <param name="o">object。</param>
        /// <param name="t">默认值。</param>
        /// <returns>byte。</returns>
        public static byte ToByte(this object o, byte t = default)
        {
            if (!byte.TryParse(o.ToString(string.Empty), out byte info))
            {
                info = t;
            }

            return info;
        }

        /// <summary>
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static byte[] ToBytes(this object obj)
        {
            if (obj == null)
            {
                return null;
            }

            BinaryFormatter bf = new BinaryFormatter();
            using (MemoryStream ms = new MemoryStream())
            {
                bf.Serialize(ms, obj);
                return ms.ToArray();
            }
        }

        /// <summary>
        /// </summary>
        /// <param name="source"></param>
        /// <returns></returns>
        public static object ToObject(this byte[] source)
        {
            using (MemoryStream memStream = new MemoryStream())
            {
                BinaryFormatter bf = new BinaryFormatter();
                memStream.Write(source, 0, source.Length);
                memStream.Seek(0, SeekOrigin.Begin);
                object obj = bf.Deserialize(memStream);
                return obj;
            }
        }

        /// <summary>
        ///     将object转换为char类型信息。
        /// </summary>
        /// <param name="o">object。</param>
        /// <param name="t">默认值。</param>
        /// <returns>char。</returns>
        public static char ToChar(this object o, char t = default)
        {
            if (!char.TryParse(o.ToString(string.Empty), out char info))
            {
                info = t;
            }

            return info;
        }

        /// <summary>
        ///     将object转换为int类型信息。
        /// </summary>
        /// <param name="o">object。</param>
        /// <param name="t">默认值。</param>
        /// <returns>int。</returns>
        public static int ToInt(this object o, int t = default)
        {
            if (!int.TryParse(o.ToString(string.Empty), out int info))
            {
                info = t;
            }

            return info;
        }

        /// <summary>
        ///     将object转换为double类型信息。
        /// </summary>
        /// <param name="o">object。</param>
        /// <param name="t">默认值。</param>
        /// <returns>double。</returns>
        public static double ToDouble(this object o, double t = default)
        {
            if (!double.TryParse(o.ToString(string.Empty), out double info))
            {
                info = t;
            }

            return info;
        }

        /// <summary>
        ///     将object转换为decimal类型信息。
        /// </summary>
        /// <param name="o">object。</param>
        /// <param name="t">默认值。</param>
        /// <returns>decimal。</returns>
        public static decimal ToDecimal(this object o, decimal t = default)
        {
            if (!decimal.TryParse(o.ToString(string.Empty), out decimal info))
            {
                info = t;
            }

            return info;
        }

        /// <summary>
        ///     将object转换为float类型信息。
        /// </summary>
        /// <param name="o">object。</param>
        /// <param name="t">默认值。</param>
        /// <returns>float。</returns>
        public static float ToFloat(this object o, float t = default)
        {
            if (!float.TryParse(o.ToString(string.Empty), out float info))
            {
                info = t;
            }

            return info;
        }

        /// <summary>
        ///     将object转换为long类型信息。
        /// </summary>
        /// <param name="o">object。</param>
        /// <param name="t">默认值。</param>
        /// <returns>long。</returns>
        public static long ToLong(this object o, long t = default)
        {
            if (!long.TryParse(o.ToString(string.Empty), out long info))
            {
                info = t;
            }

            return info;
        }

        /// <summary>
        ///     将object转换为bool类型信息。
        /// </summary>
        /// <param name="o">object。</param>
        /// <param name="t">默认值。</param>
        /// <returns>bool。</returns>
        public static bool ToBool(this object o, bool t = default)
        {
            if (!bool.TryParse(o.ToString(string.Empty), out bool info))
            {
                info = t;
            }

            return info;
        }

        /// <summary>
        ///     将object转换为sbyte类型信息。
        /// </summary>
        /// <param name="o">object。</param>
        /// <param name="t">默认值。</param>
        /// <returns>sbyte。</returns>
        public static sbyte ToSbyte(this object o, sbyte t = default)
        {
            if (!sbyte.TryParse(o.ToString(string.Empty), out sbyte info))
            {
                info = t;
            }

            return info;
        }

        /// <summary>
        ///     将object转换为short类型信息。
        /// </summary>
        /// <param name="o">object。</param>
        /// <param name="t">默认值。</param>
        /// <returns>short。</returns>
        public static short ToShort(this object o, short t = default)
        {
            if (!short.TryParse(o.ToString(string.Empty), out short info))
            {
                info = t;
            }

            return info;
        }

        /// <summary>
        ///     将object转换为ushort类型信息。
        /// </summary>
        /// <param name="o">object。</param>
        /// <param name="t">默认值。</param>
        /// <returns>ushort。</returns>
        public static ushort ToUShort(this object o, ushort t = default)
        {
            if (!ushort.TryParse(o.ToString(string.Empty), out ushort info))
            {
                info = t;
            }

            return info;
        }

        /// <summary>
        ///     将object转换为ulong类型信息。
        /// </summary>
        /// <param name="o">object。</param>
        /// <param name="t">默认值。</param>
        /// <returns>ulong。</returns>
        public static ulong ToULong(this object o, ulong t = default)
        {
            if (!ulong.TryParse(o.ToString(string.Empty), out ulong info))
            {
                info = t;
            }

            return info;
        }

        /// <summary>
        ///     将object转换为Enum[T]类型信息。
        /// </summary>
        /// <param name="o">object。</param>
        /// <param name="t">默认值。</param>
        /// <returns>Enum[T]。</returns>
        public static T ToEnum<T>(this object o, T t = default)
            where T : struct
        {
            if (!Enum.TryParse(o.ToString(string.Empty), out T info))
            {
                info = t;
            }

            return info;
        }

        /// <summary>
        ///     将object转换为DateTime类型信息。
        /// </summary>
        /// <param name="o">object。</param>
        /// <param name="t">默认值。</param>
        /// <returns>DateTime。</returns>
        public static DateTime ToDateTime(this object o, DateTime t = default)
        {
            if (t == default)
            {
                t = new DateTime(1753, 1, 1);
            }

            if (!DateTime.TryParse(o.ToString(string.Empty), out DateTime info))
            {
                info = t;
            }

            return info;
        }

        /// <summary>
        ///     将object转换为TimeSpan类型信息。
        /// </summary>
        /// <param name="o">object。</param>
        /// <param name="t">默认值。</param>
        /// <returns>TimeSpan。</returns>
        public static TimeSpan ToTimeSpan(this object o, TimeSpan t = default)
        {
            if (t == default)
            {
                t = new TimeSpan(0, 0, 0);
            }

            if (!TimeSpan.TryParse(o.ToString(string.Empty), out TimeSpan info))
            {
                info = t;
            }

            return info;
        }

        /// <summary>
        ///     将object转换为Guid类型信息。
        /// </summary>
        /// <param name="o">object。</param>
        /// <param name="t">默认值。</param>
        /// <returns>Guid。</returns>
        public static Guid ToGuid(this object o, Guid t = default)
        {
            if (!Guid.TryParse(o.ToString(string.Empty), out Guid info))
            {
                info = t;
            }

            return info;
        }

        /// <summary>
        ///     从object中获取bool类型信息。
        /// </summary>
        /// <param name="o">object。</param>
        /// <returns>bool。</returns>
        public static bool? GetBool(this object o)
        {
            if (!bool.TryParse(BoolRegex.Match(o.ToString(string.Empty)).Groups["info"].Value, out bool info))
            {
                return null;
            }

            return info;
        }

        /// <summary>
        ///     从object中获取int类型信息。
        /// </summary>
        /// <param name="o">object。</param>
        /// <returns>int。</returns>
        public static int? GetInt(this object o)
        {
            if (!int.TryParse(IntRegex.Match(o.ToString(string.Empty)).Groups["info"].Value, out int info))
            {
                return null;
            }

            return info;
        }

        /// <summary>
        ///     从object中获取decimal类型信息。
        /// </summary>
        /// <param name="o">object。</param>
        /// <returns>decimal。</returns>
        public static decimal? GetDecimal(this object o)
        {
            if (!decimal.TryParse(DecimalRegex.Match(o.ToString(string.Empty)).Groups["info"].Value, out decimal info))
            {
                return null;
            }

            return info;
        }

        /// <summary>
        ///     从object中获取double类型信息。
        /// </summary>
        /// <param name="o">object。</param>
        /// <returns>double。</returns>
        public static double? GetDouble(this object o)
        {
            if (!double.TryParse(DecimalRegex.Match(o.ToString(string.Empty)).Groups["info"].Value, out double info))
            {
                return null;
            }

            return info;
        }

        /// <summary>
        ///     从object中获取正数信息。
        /// </summary>
        /// <param name="o">object。</param>
        /// <returns>decimal。</returns>
        public static decimal? GetPositiveNumber(this object o)
        {
            if (!decimal.TryParse(DecimalRegex.Match(o.ToString(string.Empty)).Groups["info"].Value, out decimal info))
            {
                return null;
            }

            return Math.Abs(info);
        }

        /// <summary>
        ///     从object中获取DateTime?类型信息。
        /// </summary>
        /// <param name="o">object。</param>
        /// <returns>DateTime?。</returns>
        public static DateTime? GetDateTime(this object o)
        {
            if (!DateTime.TryParse(
                DateTimeRegex.Match(o.ToString(string.Empty)).Groups["info"].Value.Replace("年", "-").Replace("月", "-")
                    .Replace("/", "-").Replace("日", ""), out DateTime info))
            {
                return null;
            }

            return info;
        }

        /// <summary>
        ///     从object中获取TimeSpan?类型信息。
        /// </summary>
        /// <param name="o">object。</param>
        /// <returns>TimeSpan?。</returns>
        public static TimeSpan? GetTimeSpan(this object o)
        {
            if (!TimeSpan.TryParse(TimeSpanRegex.Match(o.ToString(string.Empty)).Groups["info"].Value, out TimeSpan info))
            {
                return null;
            }

            return info;
        }

        /// <summary>
        ///     从object中获取Guid?类型信息。
        /// </summary>
        /// <param name="o">object。</param>
        /// <returns>Guid?。</returns>
        public static Guid? GetGuid(this object o)
        {
            if (!Guid.TryParse(GuidRegex.Match(o.ToString(string.Empty)).Groups["info"].Value, out Guid info))
            {
                return null;
            }

            return info;
        }

        /// <summary>
        ///     将object转换为SqlServer中的DateTime?类型信息。
        /// </summary>
        /// <param name="o">object。</param>
        /// <param name="t">默认值。</param>
        /// <returns>DateTime?。</returns>
        public static DateTime? GetSqlDateTime(this object o, DateTime t = default)
        {
            if (!DateTime.TryParse(o.ToString(string.Empty), out DateTime info))
            {
                info = t;
            }

            if (info < new DateTime(1753, 1, 1) || info > new DateTime(9999, 12, 31))
            {
                return null;
            }

            return info;
        }

        /// <summary>
        ///     读取XElement节点的文本内容。
        /// </summary>
        /// <param name="xElement">XElement节点。</param>
        /// <param name="t">默认值。</param>
        /// <returns>文本内容。</returns>
        public static string Value(this XElement xElement, string t = default)
        {
            if (xElement == null)
            {
                return t;
            }

            return xElement.Value;
        }

        /// <summary>
        ///     获取与指定键相关的值。
        /// </summary>
        /// <typeparam name="TKey">键类型。</typeparam>
        /// <typeparam name="TValue">值类型。</typeparam>
        /// <param name="dictionary">表示键/值对象的泛型集合。</param>
        /// <param name="key">键。</param>
        /// <param name="t">默认值。</param>
        /// <returns>值。</returns>
        public static TValue GetValue<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key,
            TValue t = default)
        {
            if (dictionary == null || key == null)
            {
                return t;
            }

            if (!dictionary.TryGetValue(key, out TValue value))
            {
                value = t;
            }

            return value;
        }

        /// <summary>
        ///     获取与指定键相关或者第一个的值。
        /// </summary>
        /// <typeparam name="TKey">键类型。</typeparam>
        /// <typeparam name="TValue">值类型。</typeparam>
        /// <param name="dictionary">表示键/值对象的泛型集合。</param>
        /// <param name="key">键。</param>
        /// <param name="t">默认值。</param>
        /// <returns>值。</returns>
        public static TValue GetFirstOrDefaultValue<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key,
            TValue t = default)
        {
            if (dictionary == null || key == null)
            {
                return t;
            }

            if (!dictionary.TryGetValue(key, out TValue value))
            {
                if (dictionary.Count() == 0)
                {
                    value = t;
                }
                else
                {
                    value = dictionary.FirstOrDefault().Value;
                }
            }

            return value;
        }

        /// <summary>
        ///     获取具有指定 System.Xml.Linq.XName 的第一个（按文档顺序）子元素。
        /// </summary>
        /// <param name="xContainer">XContainer。</param>
        /// <param name="xName">要匹配的 System.Xml.Linq.XName。</param>
        /// <param name="t">是否返回同名默认值。</param>
        /// <returns>与指定 System.Xml.Linq.XName 匹配的 System.Xml.Linq.XElement，或者为 null。</returns>
        public static XElement Element(this XContainer xContainer, XName xName, bool t)
        {
            XElement info;
            if (xContainer == null)
            {
                info = null;
            }
            else
            {
                info = xContainer.Element(xName);
            }

            if (t && info == null)
            {
                info = new XElement(xName);
            }

            return info;
        }

        /// <summary>
        ///     按文档顺序返回此元素或文档的子元素集合。
        /// </summary>
        /// <param name="xContainer">XContainer。</param>
        /// <param name="t">是否返回非空默认值。</param>
        /// <returns>System.Xml.Linq.XElement 的按文档顺序包含此System.Xml.Linq.XContainer 的子元素，或者非空默认值。</returns>
        public static IEnumerable<XElement> Elements(this XContainer xContainer, bool t)
        {
            IEnumerable<XElement> info;
            if (xContainer == null)
            {
                info = null;
            }
            else
            {
                info = xContainer.Elements();
            }

            if (t && info == null)
            {
                info = new List<XElement>();
            }

            return info;
        }

        /// <summary>
        ///     按文档顺序返回此元素或文档的经过筛选的子元素集合。集合中只包括具有匹配 System.Xml.Linq.XName 的元素。
        /// </summary>
        /// <param name="xContainer">XContainer。</param>
        /// <param name="xName">要匹配的 System.Xml.Linq.XName。</param>
        /// <param name="t">是否返回非空默认值。</param>
        /// <returns>System.Xml.Linq.XElement 的按文档顺序包含具有匹配System.Xml.Linq.XName 的 System.Xml.Linq.XContainer 的子级，或者非空默认值。</returns>
        public static IEnumerable<XElement> Elements(this XContainer xContainer, XName xName, bool t)
        {
            IEnumerable<XElement> info;
            if (xContainer == null)
            {
                info = null;
            }
            else
            {
                info = xContainer.Elements(xName);
            }

            if (t && info == null)
            {
                info = new List<XElement>();
            }

            return info;
        }

        /// <summary>
        ///     删除html标签。
        /// </summary>
        /// <param name="html">输入的字符串。</param>
        /// <returns>没有html标签的字符串。</returns>
        public static string RemoveHTMLTags(this string html)
        {
            return Regex
                .Replace(
                    Regex.Replace(
                        Regex.Replace(
                            (html ?? string.Empty).Replace("&nbsp;", " ").Replace("\r\n", " ").Replace("\n", " ")
                            .Replace("\r", " ").Replace("\t", " "), "<\\/?[^>]+>", "\r\n"), "(\r\n)+", "\r\n"),
                    "(\\s)+", " ").Trim();
        }

        /// <summary>
        ///     字符串转换为文件名。
        /// </summary>
        /// <param name="s">字符串。</param>
        /// <returns>文件名。</returns>
        public static string ToFileName(this string s)
        {
            return Regex.Replace(s.ToString(string.Empty), @"[\\/:*?<>|]", "_").Replace("\t", " ").Replace("\r\n", " ")
                .Replace("\"", " ");
        }

        /// <summary>
        ///     获取星期一的日期。
        /// </summary>
        /// <param name="dateTime">日期。</param>
        /// <returns>星期一的日期。</returns>
        public static DateTime? GetMonday(this DateTime dateTime)
        {
            return dateTime.AddDays(-1 * (int)dateTime.AddDays(-1).DayOfWeek).ToString("yyyy-MM-dd").GetDateTime();
        }

        /// <summary>
        ///     获取默认非空字符串。
        /// </summary>
        /// <param name="s">首选默认非空字符串。</param>
        /// <param name="args">依次非空字符串可选项。</param>
        /// <returns>默认非空字符串。若无可选项则返回string.Empty。</returns>
        public static string DefaultStringIfEmpty(this string s, params string[] args)
        {
            if (string.IsNullOrEmpty(s))
            {
                foreach (string i in args)
                {
                    if (!string.IsNullOrEmpty(i) && !string.IsNullOrEmpty(i.Trim()))
                    {
                        return i;
                    }
                }
            }

            return s ?? string.Empty;
        }

        /// <summary>
        ///     对 URL 字符串进行编码。
        /// </summary>
        /// <param name="s">要编码的文本。</param>
        /// <param name="regex">匹配要编码的文本。</param>
        /// <param name="encoding">指定编码方案的 System.Text.Encoding 对象。</param>
        /// <returns>一个已编码的字符串。</returns>
        public static string ToUrlEncodeString(this string s, Regex regex = default, Encoding encoding = null)
        {
            if (encoding == null)
            {
                encoding = Encoding.UTF8;
            }

            if (regex == null)
            {
                return HttpUtility.UrlEncode(s, encoding);
            }

            List<string> l = new List<string>();
            foreach (char i in s)
            {
                string t = i.ToString();
                l.Add(regex.IsMatch(t) ? HttpUtility.UrlEncode(t, encoding) : t);
            }

            return string.Join(string.Empty, l);
        }

        /// <summary>
        ///     对 URL 字符串进行编码。
        /// </summary>
        /// <param name="s">要编码的文本。</param>
        /// <param name="regex">匹配要编码的文本。</param>
        /// <param name="encoding">指定编码方案的 System.Text.Encoding 对象。</param>
        /// <returns>一个已编码的字符串。</returns>
        public static string ToUrlEncodeString(this string s, string regex, Encoding encoding = null)
        {
            return ToUrlEncodeString(s, new Regex(regex), encoding);
        }

        /// <summary>
        ///     将日期转换为UNIX时间戳字符串
        /// </summary>
        /// <param name="date"></param>
        /// <returns></returns>
        public static string ToUnixTimeStamp(this DateTime date)
        {
            DateTime startTime = TimeZoneInfo.ConvertTimeToUtc(new DateTime(1970, 1, 1));
            string timeStamp = date.Subtract(startTime).Ticks.ToString();
            return timeStamp.Substring(0, timeStamp.Length - 7);
        }

        public static string Join(this IEnumerable<object> source, string separator)
        {
            return string.Join(separator, source);
        }

        /// <summary>
        ///     判断当前字符串是否是移动电话号码
        /// </summary>
        /// <param name="mobile"></param>
        /// <returns></returns>
        public static bool IsMobile(this string mobile)
        {
            return MobileRegex.IsMatch(mobile);
        }

        /// <summary>
        ///     判断当前字符串是否为邮箱
        /// </summary>
        /// <param name="email"></param>
        /// <returns></returns>
        public static bool IsEmail(this string email)
        {
            return EmailRegex.IsMatch(email);
        }

        /// <summary>
        ///     把对象类型转换为指定类型
        /// </summary>
        /// <param name="value"></param>
        /// <param name="conversionType"></param>
        /// <returns></returns>
        public static object CastTo(this object value, Type conversionType)
        {
            if (value == null)
            {
                return null;
            }

            if (conversionType.IsNullableType())
            {
                conversionType = conversionType.GetUnNullableType();
            }

            if (conversionType.IsEnum)
            {
                return Enum.Parse(conversionType, value.ToString());
            }

            if (conversionType == typeof(Guid))
            {
                return Guid.Parse(value.ToString());
            }

            return Convert.ChangeType(value, conversionType);
        }

        /// <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;
            }

            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>
        ///     将对象保存为csv
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="source"></param>
        /// <param name="csvFullName">文件名称</param>
        /// <param name="separator">分隔符，默认逗号</param>
        public static void SaveToCsv<T>(this IEnumerable<T> source, string csvFullName, string separator = ",")
        {
            if (source == null)
            {
                throw new ArgumentNullException(nameof(source));
            }

            if (string.IsNullOrEmpty(separator))
            {
                separator = ",";
            }

            string csv = string.Join(separator, source);
            using (StreamWriter sw = new StreamWriter(csvFullName, false))
            {
                sw.Write(csv);
                sw.Close();
            }
        }

        public static bool IsImplement(this Type entityType, Type interfaceType)
        {
            return /*entityType.IsClass && !entityType.IsAbstract &&*/ entityType.GetTypeInfo().GetInterfaces().Any(t =>
                t.GetTypeInfo().IsGenericType && t.GetGenericTypeDefinition() == interfaceType);
        }

        /// <summary>
        ///     将对象转为DataTable
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="source"></param>
        /// <returns></returns>
        public static DataTable ToDataTable<T>(this IEnumerable<T> source)
        {
            DataTable dtReturn = new DataTable();

            if (source == null)
            {
                return dtReturn;
            }
            // column names
            PropertyInfo[] oProps = null;

            foreach (T rec in source)
            {
                // Use reflection to get property names, to create table, Only first time, others will follow
                if (oProps == null)
                {
                    oProps = rec.GetType().GetProperties();
                    foreach (PropertyInfo pi in oProps)
                    {
                        Type colType = pi.PropertyType;

                        if (colType.IsNullableType())
                        {
                            colType = colType.GetGenericArguments()[0];
                        }

                        if (colType == typeof(bool))
                        {
                            colType = typeof(int);
                        }

                        dtReturn.Columns.Add(new DataColumn(pi.Name, colType));
                    }
                }

                DataRow dr = dtReturn.NewRow();

                foreach (PropertyInfo pi in oProps)
                {
                    object value = pi.GetValue(rec, null) ?? DBNull.Value;
                    if (value is bool)
                    {
                        dr[pi.Name] = (bool)value ? 1 : 0;
                    }
                    else
                    {
                        dr[pi.Name] = value;
                    }
                }

                dtReturn.Rows.Add(dr);
            }

            return dtReturn;
        }
    }

    /// <summary>
    ///     结果。
    /// </summary>
    /// <typeparam name="T">结果返回值类型。</typeparam>
    public class Result<T>
    {
        /// <summary>
        ///     标记。
        /// </summary>
        public Flag Flag { get; set; }

        /// <summary>
        ///     返回值。
        /// </summary>
        public T Return { get; set; }

        /// <summary>
        ///     消息。
        /// </summary>
        public string Message { get; set; }

        /// <summary>
        ///     异常。
        /// </summary>
        public Exception Exception { get; set; }

        /// <summary>
        ///     时间。
        /// </summary>
        public DateTime DateTime { get; set; }

        /// <summary>
        ///     整型数据。
        /// </summary>
        public int Int { get; set; }

        /// <summary>
        ///     浮点数据。
        /// </summary>
        public decimal Decimal { get; set; }

        /// <summary>
        ///     布尔数据。
        /// </summary>
        public bool Bool { get; set; }

        /// <summary>
        ///     对象。
        /// </summary>
        public object Object { get; set; }
    }

    /// <summary>
    ///     标记。
    /// </summary>
    public enum Flag
    {
        /// <summary>
        ///     默认。
        /// </summary>
        Default,

        /// <summary>
        ///     真。
        /// </summary>
        True,

        /// <summary>
        ///     假。
        /// </summary>
        False
    }
}