C# 常用方法扩展

最新推荐文章于 2024-08-09 17:33:04 发布
置顶瓜哥丿
最新推荐文章于 2024-08-09 17:33:04 发布
阅读量555
点赞数 2
分类专栏： c# 文章标签： MD5 ToCast ToInt Each DataTableToList
本文链接：https://blog.csdn.net/zhuovi/article/details/80604203
版权
c# 专栏收录该内容
18 篇文章 0 订阅
订阅专栏
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Reflection;
using System.Xml;
using System.Collections;
using System.Security.Cryptography;
using System.Data;
namespace XiaoFeng
{
    /// <summary>
    /// 附加属性方法操作类
    /// Version : 1.1.2
    /// Author : jacky
    /// Site : www.zhuovi.com
    /// QQ : 7092734
    /// Email : jacky@zhuovi.com
    /// </summary>
    public static partial class PrototypeHelper
    {
        #region 数据表转换对象列表
        /// <summary>
        /// 数据表转换对象列表
        /// </summary>
        /// <typeparam name="T">对象</typeparam>
        /// <param name="_">数据表</param>
        /// <returns></returns>
        public static List<T> ToList<T>(this DataTable _)
        {
            List<T> list = new List<T>();
            if (_ == null || _.Rows.Count == 0) return list;
            T model = default(T);
            Type _t = typeof(T);
            _.Rows.Each<DataRow>(dr =>
            {
                int f = 0;
                if (_t.IsValueType)
                {
                    if (_t.IsEnum)
                        list.Add(dr[0].ToEnum<T>());
                    else if (_t.Namespace == "System" && _t.IsPublic)
                        list.Add(dr[0].ToString().ToCast<T>());
                    else
                        f = 1;
                }
                else if (_t.Name == "String")
                    list.Add(dr[0].ToString().ToCast<T>());
                else if (_t.IsClass) f = 2;
                if (f > 0)
                {
                    model = Activator.CreateInstance<T>();
                    foreach (DataColumn dc in dr.Table.Columns)
                    {
                        object drValue = dr[dc.ColumnName];
                        if (drValue == null || Convert.IsDBNull(drValue)) continue;
                        PropertyInfo pi = model.GetType().GetProperty(dc.ColumnName, BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);
                        if (pi == null)
                        {
                            object m = model;
                            FieldInfo fi = model.GetType().GetField(dc.ColumnName, BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);
                            if (fi != null && fi.IsPublic)
                            {
                                fi.SetValue(m, drValue);
                                model = (T)m;
                            }
                        }
                        else
                            if (pi.CanWrite) pi.SetValue(model, drValue, null);
                    }
                    list.Add(model);
                }
            });
            return list;
        }
        /// <summary>
        /// 数据表转换对象列表
        /// </summary>
        /// <typeparam name="T">对象</typeparam>
        /// <param name="_">数据表</param>
        /// <returns></returns>
        public static T ToEntity<T>(this DataTable _)
        {
            if (_ == null || _.Rows.Count == 0) return default(T);
            DataTable table = _.Clone();
            table.ImportRow(_.Rows[0]);
            var list = table.ToList<T>();
            if (list == null || list.Count == 0) return default(T);
            return list[0];
        }
        #endregion

        #region 数组转换成字符
        /// <summary>
        /// 数组转换成字符
        /// </summary>
        /// <param name="_">数组对象</param>
        /// <param name="s">中间值</param>
        /// <returns></returns>
        public static String Joins(this object[] _, String s = "") { return String.Join(s, _); }
        #endregion

        #region 键值对转换成对象
        /// <summary>
        /// 键值对转换成对象
        /// </summary>
        /// <typeparam name="T">对象 可以是class 也可以是struct</typeparam>
        /// <param name="d">键值对</param>
        /// <returns></returns>
        public static T DictionaryToObject<T>(this IDictionary<string, string> d)
        {
            Type _t = typeof(T);
            T t = Activator.CreateInstance<T>();
            if (d == null || d.Count == 0) return t;
            if (_t.IsClass)
            {
                foreach (PropertyInfo p in t.GetType().GetProperties())
                {
                    if (p == null) continue;
                    string _value = d.ContainsKey(p.Name) ? d[p.Name] : "";
                    object value = null;
                    if (p.PropertyType == typeof(int) || p.PropertyType == typeof(Int32))
                        value = _value.ToCast<Int32>();
                    else if (p.PropertyType == typeof(Int64))
                        value = _value.ToCast<Int64>();
                    else if (p.PropertyType == typeof(float))
                        value = _value.ToCast<float>();
                    else if (p.PropertyType == typeof(Double))
                        value = _value.ToCast<Double>();
                    else if (p.PropertyType == typeof(Decimal))
                        value = _value.ToCast<Decimal>();
                    else if (p.PropertyType == typeof(DateTime))
                        value = _value.ToCast<DateTime>();
                    else if (p.PropertyType == typeof(Guid))
                        value = _value.ToCast<Guid>();
                    else
                        value = _value;
                    p.SetValue(t, value, null);
                }
            }
            else if (_t.IsValueType && !_t.IsEnum && !_t.IsPublic)
            {
                object s = t;
                foreach (FieldInfo f in _t.GetFields())
                {
                    if (f == null) continue;
                    string _value = d.ContainsKey(f.Name) ? d[f.Name] : "";
                    object value = null;
                    if (f.FieldType == typeof(int) || f.FieldType == typeof(Int32))
                        value = _value.ToCast<Int32>();
                    else if (f.FieldType == typeof(Int64))
                        value = _value.ToCast<Int64>();
                    else if (f.FieldType == typeof(float))
                        value = _value.ToCast<float>();
                    else if (f.FieldType == typeof(Double))
                        value = _value.ToCast<Double>();
                    else if (f.FieldType == typeof(Decimal))
                        value = _value.ToCast<Decimal>();
                    else if (f.FieldType == typeof(DateTime))
                        value = _value.ToCast<DateTime>();
                    else if (f.FieldType == typeof(Guid))
                        value = _value.ToCast<Guid>();
                    else
                        value = _value;
                    f.SetValue(s, value);
                }
                t = (T)s;
            }
            return t;
        }
        #endregion

        #region 转换成Enum类型
        /// <summary>
        /// 转换成Enum类型
        /// </summary>
        /// <typeparam name="T">Enum</typeparam>
        /// <param name="o">常量，整型，无符号整型,长整型，无符号长整型，短整型，无符号短整型，字节</param>
        /// <param name="ignoreCase">True 忽略大小写 False考虑大小写</param>
        /// <returns></returns>
        public static T ToEnum<T>(this object o, Boolean ignoreCase = true)
        {
            if (!typeof(T).IsEnum || o == null) return default(T);
            Type _t = o.GetType();
            if (_t == typeof(String))
            {
                if (ignoreCase)
                {
                    string[] _ = Enum.GetNames(typeof(T));
                    foreach (string __ in _)
                        if (__.ToLower() == o.ToString().ToLower()) return (T)Enum.Parse(typeof(T), o.ToString(), ignoreCase);
                    return default(T);
                }
                else
                    return Enum.IsDefined(typeof(T), o) ? (T)Enum.Parse(typeof(T), o.ToString(), ignoreCase) : default(T);
            }
            return (_t.IsPublic && _t.IsValueType) ? (Enum.IsDefined(typeof(T), o) ? (T)Enum.ToObject(typeof(T), o) : default(T)) : default(T);
        }
        #endregion

        #region 设置节点属性值
        /// <summary>
        /// 设置节点属性值
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="elm">节点</param>
        /// <param name="attributeName">属性名</param>
        /// <param name="attributeValue">属性值</param>
        /// <returns></returns>
        public static XmlElement SetAttributeValue<T>(this XmlElement elm, string attributeName, T attributeValue)
        {
            if (elm != null)
            {
                if (attributeValue == null || attributeValue.ToString().IsNullOrEmpty()) { if (elm.HasAttribute(attributeName)) elm.RemoveAttribute(attributeName); return elm; }
                string value = "";
                if (attributeValue.GetType() == typeof(int))
                    value = attributeValue.ToString();
                else if (attributeValue.GetType() == typeof(Boolean))
                    value = attributeValue.ToString().ToUpperFirst();
                else if (attributeValue.GetType().IsEnum)
                    value = attributeValue.ToString();
                else if (attributeValue.GetType() == typeof(DateTime))
                    value = attributeValue.ToString().ToDateTime().ToString("yyyy-MM-dd HH:mm:ss.fff");
                else if (attributeValue.GetType() == typeof(Guid))
                    value = attributeValue.ToString().ToGUID().ToString("N");
                else
                    value = attributeValue.ToString();
                elm.SetAttribute(attributeName, value);
            }
            return elm;
        }
        /// <summary>
        /// 设置节点属性值
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="elm">节点</param>
        /// <param name="attributeName">属性名</param>
        /// <param name="attributeValue">属性值</param>
        /// <returns></returns>
        public static XmlNode SetAttributeValue<T>(this XmlNode elm, string attributeName, T attributeValue)
        {
            return ((XmlElement)elm).SetAttributeValue<T>(attributeName, attributeValue) as XmlNode;
        }
        #endregion

        #region 循环遍历数据 For
        /// <summary>
        /// 循环遍历数据 For
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="enumerable">对象</param>
        /// <param name="start">数组开始</param>
        /// <param name="end">数组结束</param>
        /// <param name="action">委托事件</param>
        /// <returns>返回对象</returns>
        public static IEnumerable<T> For<T>(this IEnumerable<T> enumerable, int start, int end, Action<int> action)
        {
            return enumerable.For(action, start, end);
        }
        /// <summary>
        /// 循环遍历数据 For
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="enumerable">对象</param>
        /// <param name="action">委托事件</param>
        /// <param name="start">数组开始</param>
        /// <param name="end">数组结束</param>
        /// <returns>返回对象</returns>
        public static IEnumerable<T> For<T>(this IEnumerable<T> enumerable, Action<int> action, int start = 0, int end = 0)
        {
            if (enumerable == null || action == null) return enumerable;
            int Count = enumerable.Count();
            if (Count > 0)
            {
                if (start < 0) start = 0;
                if (end == 0 || end > Count) end = Count;
                for (int i = start; i < end; i++)
                    action(i);
            }
            return enumerable;
        }
        /// <summary>
        /// 循环遍历数据 For
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="enumerable">对象</param>
        /// <param name="start">数组开始</param>
        /// <param name="end">数组结束</param>
        /// <param name="action">委托事件</param>
        /// <returns>返回对象</returns>
        public static T[] For<T>(this T[] enumerable, int start, int end, Action<int, T[]> action)
        {
            return enumerable.For(action, start, end);
        }
        /// <summary>
        /// 循环遍历数据 For
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="enumerable">对象</param>
        /// <param name="action">委托事件</param>
        /// <param name="start">数组开始</param>
        /// <param name="end">数组结束</param>
        /// <returns>返回对象</returns>
        public static T[] For<T>(this T[] enumerable, Action<int, T[]> action, int start = 0, int end = 0)
        {
            if (enumerable == null || action == null) return enumerable;
            int Count = enumerable.Count();
            if (Count > 0)
            {
                if (start < 0) start = 0;
                if (end == 0 || end > Count) end = Count;
                for (int i = start; i < end; i++)
                    action(i, enumerable);
            }
            return enumerable;
        }
        /// <summary>
        /// 循环遍历数据 For
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="enumerable">对象</param>
        /// <param name="start">数组开始</param>
        /// <param name="end">数组结束</param>
        /// <param name="func">委托事件</param>
        /// <returns>返回对象</returns>
        public static IEnumerable<T> For<T>(this IEnumerable<T> enumerable, int start, int end, Func<int, Boolean> func)
        {
            return enumerable.For(func, start, end);
        }
        /// <summary>
        /// 循环遍历数据 For
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="enumerable">对象</param>
        /// <param name="func">委托事件</param>
        /// <param name="start">数组开始</param>
        /// <param name="end">数组结束</param>
        /// <returns>返回对象</returns>
        public static IEnumerable<T> For<T>(this IEnumerable<T> enumerable, Func<int, Boolean> func, int start = 0, int end = 0)
        {
            if (enumerable == null || func == null) return enumerable;
            int Count = enumerable.Count();
            if (Count > 0)
            {
                if (start < 0) start = 0;
                if (end == 0 || end > Count) end = Count;
                for (int i = start; i < end; i++)
                    if (!func(i)) break;
            }
            return enumerable;
        }
        /// <summary>
        /// 循环遍历数据 For
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="enumerable">对象</param>
        /// <param name="start">数组开始</param>
        /// <param name="end">数组结束</param>
        /// <param name="func">委托事件</param>
        /// <returns>返回对象</returns>
        public static T[] For<T>(this T[] enumerable, int start, int end, Func<int, T[], Boolean> func)
        {
            return enumerable.For(func, start, end);
        }
        /// <summary>
        /// 循环遍历数据 For
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="enumerable">对象</param>
        /// <param name="func">委托事件</param>
        /// <param name="start">数组开始</param>
        /// <param name="end">数组结束</param>
        /// <returns>返回对象</returns>
        public static T[] For<T>(this T[] enumerable, Func<int, T[], Boolean> func, int start = 0, int end = 0)
        {
            if (enumerable == null || func == null) return enumerable;
            int Count = enumerable.Count();
            if (Count > 0)
            {
                if (start < 0) start = 0;
                if (end == 0 || end > Count) end = Count;
                for (int i = start; i < end; i++)
                    if (!func(i, enumerable)) break;
            }
            return enumerable;
        }
        #endregion

        #region 循环遍历数据 ForEach
        /// <summary>
        /// 循环遍历数据
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="enumerable">类型对象</param>
        /// <param name="action">无返回值Lambda</param>
        /// <returns></returns>
        public static IEnumerable<T> Each<T>(this IEnumerable<T> enumerable, Action<T> action)
        {
            if (enumerable != null && action != null)
                foreach (T t in enumerable) action(t);
            return enumerable;
        }
        /// <summary>
        /// 循环遍历数据
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="enumerable">类型对象</param>
        /// <param name="func">有返回值Lambda</param>
        /// <returns></returns>
        public static IEnumerable<T> Each<T>(this IEnumerable<T> enumerable, Func<T, Boolean> func)
        {
            if (enumerable != null && func != null)
                foreach (T t in enumerable) if (!func(t)) break;
            return enumerable;
        }
        /*/// <summary>
        /// 循环遍历数据
        /// </summary>
        /// <param name="enumerable">对象</param>
        /// <param name="action">无返回值Lambda</param>
        /// <returns></returns>
        public static IEnumerable Each(this IEnumerable enumerable, Action<object> action)
        {
            if (enumerable != null)
                foreach (object o in enumerable) action(o);
            return enumerable;
        }*/
        /// <summary>
        /// 循环遍历数据
        /// </summary>
        /// <param name="enumerable">对象</param>
        /// <param name="action">无返回值Lambda</param>
        /// <returns></returns>
        public static IEnumerable Each<T>(this IEnumerable enumerable, Action<T> action)
        {
            if (enumerable != null && action != null)
                foreach (T o in enumerable) action(o);
            return enumerable;
        }
        /// <summary>
        /// 循环遍历数据
        /// </summary>
        /// <param name="enumerable">对象</param>
        /// <param name="func">有返回值Lambda</param>
        /// <returns></returns>
        public static IEnumerable Each<T>(this IEnumerable enumerable, Func<T, Boolean> func)
        {
            if (enumerable != null && func != null)
                foreach (T o in enumerable) if (!func(o)) break;
            return enumerable;
        }
        #endregion

        #region 获取IDictionary值
        /// <summary>
        /// 值是否在键值对中
        /// </summary>
        /// <typeparam name="TKey">类型</typeparam>
        /// <typeparam name="TValue">类型</typeparam>
        /// <param name="_">对象</param>
        /// <param name="value">值</param>
        /// <returns></returns>
        public static Boolean ContainsValue<TKey, TValue>(this IDictionary<TKey, TValue> _, TValue value = default(TValue))
        {
            Boolean _f = false;
            _.Each(kv =>
            {
                if (kv.Value.Equals(value))
                {
                    _f = true; return false;
                }
                else
                    return true;
            });
            return _f;
            /*foreach (KeyValuePair<K, V> kValue in _)
            {
                if (kValue.Value.Equals(Value)) return true;
            }
            return false;*/
        }
        /// <summary>
        /// 获取Dictionary值 Value
        /// </summary>
        /// <typeparam name="TKey">Key 类型</typeparam>
        /// <typeparam name="TValue">Value 类型</typeparam>
        /// <param name="_">Dictionary对象</param>
        /// <param name="key">Key 值</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static TValue getValue<TKey, TValue>(this IDictionary<TKey, TValue> _, TKey key, TValue defaultValue = default(TValue))
        {
            TValue val = defaultValue;
            return _.TryGetValue(key, out val) ? val : defaultValue;
        }
        /// <summary>
        /// 获取Dictionary值 Value
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="_">Dictionary对象</param>
        /// <param name="key">Key</param>
        /// <returns></returns>
        public static T getValue<T>(this IDictionary<T, T> _, T key)
        {
            return _.getValue<T, T>(key, default(T));
        }
        /// <summary>
        /// 获取Dictionary值 Key
        /// </summary>
        /// <typeparam name="TKey">Key 类型</typeparam>
        /// <typeparam name="TValue">Value 类型</typeparam>
        /// <param name="_">Dictionary对象</param>
        /// <param name="value">Value</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static TKey getKey<TKey, TValue>(this IDictionary<TKey, TValue> _, TValue value, TKey defaultValue = default(TKey))
        {
            return _.ContainsValue(value) ? _.FindByValue<TKey, TValue>(value).Key : defaultValue;
        }
        /// <summary>
        /// 获取Dictionary值 Key
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="_">Dictionary对象</param>
        /// <param name="value">Value</param>
        /// <returns></returns>
        public static T getKey<T>(this IDictionary<T, T> _, T value)
        {
            return _.getKey<T, T>(value, value);
        }
        /// <summary>
        /// 获取Dictionary值 KeyValuePair
        /// </summary>
        /// <typeparam name="TKey">Key 类型</typeparam>
        /// <typeparam name="TValue">Value 类型</typeparam>
        /// <param name="_">Dictionary对象</param>
        /// <param name="value">Value</param>
        /// <returns></returns>
        public static KeyValuePair<TKey, TValue> FindByValue<TKey, TValue>(this IDictionary<TKey, TValue> _, TValue value)
        {
            if (_ == null) return new KeyValuePair<TKey, TValue>();
            if (_.ContainsValue(value))
                foreach (KeyValuePair<TKey, TValue> item in _)
                    if (item.Value.Equals(value)) return item;
            return new KeyValuePair<TKey, TValue>();
        }
        #endregion

        #region IDictionary 转换成参数写法
        /// <summary>
        /// IDictionary 转换成参数写法
        /// </summary>
        /// <typeparam name="TKey">键类型</typeparam>
        /// <typeparam name="TValue">值类型</typeparam>
        /// <param name="_">IDictionary对象</param>
        /// <returns></returns>
        public static string ToQuery<TKey, TValue>(this IDictionary<TKey, TValue> _)
        {
            string __ = "";
            _.Each(k => __ += "{0}={1}&".format(k.Key, k.Value));
            return __.Trim('&');
        }
        #endregion

        #region 转换首字母大小
        /// <summary>
        /// 转换首字母大小
        /// </summary>
        /// <param name="_">字符串对象</param>
        /// <returns></returns>
        public static string ToUpperFirst(this string _)
        {
            return _.ReplacePattern(@"(?<a>(\r|\t|\n|\s|\b))(?<b>[a-z])", m =>
            {
                return m.Groups["a"].Value + m.Groups["b"].Value.ToUpper();
            }, RegexOptions.Multiline);
        }
        #endregion

        #region 字符串加密解密
        /// <summary>
        /// 字符串加密
        /// </summary>
        /// <param name="_">字符串对象</param>
        /// <param name="key">Key</param>
        /// <returns></returns>
        public static string ToEncrypt(this string _, string key = "www.zhuovi.com")
        {
            return XiaoFeng.EncryptHelper.Encrypt(_, key);
        }
        /// <summary>
        /// 字符串解密
        /// </summary>
        /// <param name="_">字符串对象</param>
        /// <param name="key">Key</param>
        /// <returns></returns>
        public static string ToDecrypt(this string _, string key = "www.zhuovi.com")
        {
            try
            {
                return XiaoFeng.EncryptHelper.Decrypt(_, key);
            }
            catch
            {
                return _;
            }
        }
        #endregion

        #region 字符串md5加密
        /// <summary>
        /// 字符串md5加密
        /// </summary>
        /// <param name="_">字符串</param>
        /// <param name="length">长度 16或32</param>
        /// <param name="ignoreCase">大写小写 true为小写 false 为大写</param>
        /// <returns></returns>
        public static string MD5(this string _, int length = 32, Boolean ignoreCase = true)
        {
            MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
            byte[] data = md5.ComputeHash(Encoding.Default.GetBytes(_));
            string _data = (length == 16 ? BitConverter.ToString(data, 4, 8) : BitConverter.ToString(data, 0, 16)).Replace("-", "");
            return ignoreCase ? _data.ToLower() : _data;
            /*if (i == 16)
            {
                string s = BitConverter.ToString(data, 4, 8);
                EnPswdStr = s;
            }
            else
            {
                EnPswdStr = System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(Str , "MD5");
                StringBuilder sBuilder = new StringBuilder();
                for (int m = 0; m < data.Length; m++)
                    sBuilder.Append(data[m].ToString("x2"));
                EnPswdStr = sBuilder.ToString();
            }*/
        }
        #endregion

        #region 转义字符串
        /// <summary>
        /// 通过替换为转义码来转义最小的字符集（\、*、+、?、|、{、[、(、)、^、$、.、# 和空白）。 这将指示正则表达式引擎按原义解释这些字符而不是解释为元字符。
        /// </summary>
        /// <param name="_">包含要转换的文本的输入字符串</param>
        /// <returns>由转换为转义形式的元字符组成的字符串</returns>
        public static String ToRegexEscape(this String _) { return Regex.Escape(_); }
        /// <summary>
        /// 转换输入字符串中的任何转义字符
        /// </summary>
        /// <param name="_">包含要转换的文本的输入字符串</param>
        /// <returns>包含任何转换为非转义形式的转义字符的字符串</returns>
        public static String ToRegexUnescape(this String _) { return Regex.Unescape(_); }
        #endregion

        #region 字符串匹配模式
        /// <summary>
        /// 字符串匹配模式
        /// </summary>
        /// <param name="_">字符串</param>
        /// <param name="pattern">格式</param>
        /// <param name="options">表达式选项</param>
        /// <returns></returns>
        public static Boolean isPattern(this string _, string pattern, RegexOptions options = RegexOptions.IgnoreCase)
        {
            if (pattern.IsNullOrEmpty()) return true;
            if (String.IsNullOrEmpty(_)) return false;
            return Regex.IsMatch(_, pattern, options);
        }
        /// <summary>
        /// 字符串匹配模式
        /// </summary>
        /// <param name="_">字符串</param>
        /// <param name="pattern">格式</param>
        /// <param name="options">表达式选项</param>
        /// <returns></returns>
        public static Boolean isMatch(this string _, string pattern, RegexOptions options = RegexOptions.IgnoreCase)
        {
            return _.isPattern(pattern, options);
        }
        #endregion

        #region 提取符合模式的数据
        /// <summary>
        /// 提取符合模式的数据
        /// </summary>
        /// <param name="_">字符串</param>
        /// <param name="pattern">模式</param>
        /// <param name="options">表达式选项</param>
        /// <returns></returns>
        public static List<string> getPatterns(this string _, string pattern, RegexOptions options = RegexOptions.IgnoreCase)
        {
            List<string> list = new List<string>();
            if (String.IsNullOrEmpty(_) || pattern.IsNullOrEmpty()) return list;
            _.getMatches(pattern, options).Each(d => list.Add(d.Count > 0 ? d.ContainsKey("a") ? d["a"] : d.ContainsKey("1") ? d["1"] : d.FirstOrDefault().Value : ""));
            /*MatchCollection mc = Regex.Matches(_, Pattern, Options);
            if (mc.Count == 0) return list;
            foreach (Match m in mc)
                list.Add(m.Groups["a"].Value);*/
            return list;
        }
        /// <summary>
        /// 提取符合模式的数据
        /// </summary>
        /// <param name="_">字串</param>
        /// <param name="pattern">模式</param>
        /// <param name="options">表达式选项</param>
        /// <returns></returns>
        public static List<Dictionary<string, string>> getMatches(this String _, string pattern, RegexOptions options = RegexOptions.IgnoreCase)
        {
            List<Dictionary<string, string>> list = new List<Dictionary<string, string>>();
            if (_.IsNullOrEmpty() || pattern.IsNullOrEmpty()) return list;
            Regex regex = new Regex(pattern, options);
            MatchCollection mc = regex.Matches(_);
            if (mc.Count == 0) return list;
            mc.Each<Match>(m =>
            {
                Dictionary<string, string> d = new Dictionary<string, string>();
                regex.GetGroupNames().Each(o => d.Add(o, m.Groups[o].Value));
                list.Add(d);
            });
            return list;
        }
        /// <summary>
        /// 提取符合模式的数据
        /// </summary>
        /// <param name="_">字符串</param>
        /// <param name="pattern">模式</param>
        /// <param name="options">表达式选项</param>
        /// <returns></returns>
        public static Dictionary<string, string> getMatchs(this String _, string pattern, RegexOptions options = RegexOptions.IgnoreCase)
        {
            List<Dictionary<string, string>> list = _.getMatches(pattern, options);
            return list.Count == 0 ? new Dictionary<string, string>() : list[0];
        }
        /// <summary>
        /// 提取符合模式的数据
        /// </summary>
        /// <param name="_">字符串</param>
        /// <param name="pattern">模式</param>
        /// <param name="options">表达式选项</param>
        /// <returns></returns>
        public static string getMatch(this String _, String pattern, RegexOptions options = RegexOptions.IgnoreCase)
        {
            Dictionary<string, string> d = _.getMatchs(pattern, options);
            return d.Count > 0 ? d.ContainsKey("a") ? d["a"] : d.ContainsKey("1") ? d["1"] : d.FirstOrDefault().Value : "";
        }
        /// <summary>
        /// 提取符合模式的数据
        /// </summary>
        /// <param name="_">字符串</param>
        /// <param name="pattern">模式</param>
        /// <param name="options">表达式选项</param>
        /// <returns></returns>
        public static string getPattern(this String _, string pattern, RegexOptions options = RegexOptions.IgnoreCase)
        {
            return _.getMatch(pattern, options);
        }
        #endregion

        #region 获取参数值
        /// <summary>
        /// 获取参数值 正则
        /// </summary>
        /// <param name="_">网址或参数集</param>
        /// <param name="key">Key</param>
        /// <returns></returns>
        public static string getQuery(this string _, string key)
        {
            if (string.IsNullOrEmpty(_) || String.IsNullOrEmpty(key)) return "";
            return _.getPattern(@"(^|[?&#])" + key + @"=(?<a>[^?&#]*)($|[&#])");
        }
        /// <summary>
        /// 获取参数值 参数组
        /// </summary>
        /// <param name="_">网址或参数集</param>
        /// <param name="key">Key</param>
        /// <returns></returns>
        public static string getParam(this string _, string key)
        {
            if (string.IsNullOrEmpty(_) || String.IsNullOrEmpty(key)) return "";
            SortedDictionary<string, string> d = _.getQuerys();
            return d.ContainsKey(key) ? d[key] : "";
        }
        /// <summary>
        /// 获取参数键值对
        /// </summary>
        /// <param name="_">字符串</param>
        /// <returns></returns>
        public static SortedDictionary<string, string> getQuerys(this string _)
        {
            if (String.IsNullOrEmpty(_)) return new SortedDictionary<string, string>();
            return new QueryHelper(_).data;
        }
        #endregion

        #region 替换移除模式
        /// <summary>
        /// 替换模式
        /// </summary>
        /// <param name="_">字符串</param>
        /// <param name="pattern">模式</param>
        /// <param name="replaceMent">替换值</param>
        /// <param name="options">模式选项</param>
        /// <returns></returns>
        public static string ReplacePattern(this string _, string pattern = "", string replaceMent = "", RegexOptions options = RegexOptions.IgnoreCase)
        {
            if (String.IsNullOrEmpty(_) || String.IsNullOrEmpty(pattern)) return _;
            return Regex.Replace(_, pattern, replaceMent, options);
        }
        /// <summary>
        /// 替换模式
        /// </summary>
        /// <param name="_">字符串</param>
        /// <param name="pattern">模式</param>
        /// <param name="m">方法操作过程中每当找到正则表达式匹配时都调用的方法</param>
        /// <param name="options">模式选项</param>
        /// <returns></returns>
        public static string ReplacePattern(this string _, string pattern, MatchEvaluator m, RegexOptions options = RegexOptions.IgnoreCase)
        {
            if (String.IsNullOrEmpty(_) || String.IsNullOrEmpty(pattern)) return _;
            return Regex.Replace(_, pattern, m, options);
        }
        /// <summary>
        /// 移除模式
        /// </summary>
        /// <param name="_">字符串</param>
        /// <param name="pattern">模式</param>
        /// <param name="options">模式选项</param>
        /// <returns></returns>
        public static string RemovePattern(this string _, string pattern, RegexOptions options = RegexOptions.IgnoreCase)
        {
            return _.ReplacePattern(pattern, "", options);
        }
        #endregion

        #region 拆分字符串为数组
        /// <summary>
        /// 拆分字符串为数组
        /// </summary>
        /// <param name="_">字符串</param>
        /// <param name="pattern">模式</param>
        /// <param name="options">模式选项</param>
        /// <returns></returns>
        public static string[] SplitPattern(this String _, string pattern, RegexOptions options = RegexOptions.IgnoreCase)
        {
            return Regex.Split(_, pattern, options);
        }
        /// <summary>
        /// 拆分字符串为数组
        /// </summary>
        /// <param name="_">字符串</param>
        /// <param name="pattern">模式</param>
        /// <param name="options">模式选项</param>
        /// <param name="matchTimeOut">超时间隔，或 System.Text.RegularExpressions.Regex.InfiniteMatchTimeout 指示该方法不应超时</param>
        /// <returns></returns>
        public static string[] SplitPattern(this String _, string pattern, RegexOptions options, TimeSpan matchTimeOut)
        {
            return Regex.Split(_, pattern, options, matchTimeOut);
        }
        #endregion

        #region 格式化数据
        /// <summary>
        /// 格式化数据 显示用
        /// </summary>
        /// <param name="_">对象</param>
        /// <returns></returns>
        public static string getValue(this object _)
        {
            if (_ == null) return "";
            string v = "";
            Type T = _.GetType();
            if (T == typeof(String)) return v = _.ToString().ReplacePattern(@"'", "''");
            else if (T == typeof(int) || T == typeof(Int16) || T == typeof(Int32) || T == typeof(Int64) || T == typeof(float) || T == typeof(Double) || T == typeof(Decimal)) v = _.ToString();
            else if (T == typeof(Guid)) v = _.ToString().ToGUID().ToString("N");
            else if (T == typeof(DateTime)) v = v = _.ToString().ToDateTime().ToString("yyyy-MM-dd HH:mm:ss.fff");
            else v = _.ToString();
            return v;
        }
        /// <summary>
        /// 格式化数据 数据库用
        /// </summary>
        /// <param name="_">对象</param>
        /// <returns></returns>
        public static string GetValue(this object _)
        {
            if (_ == null) return "";
            string v = "";
            Type T = _.GetType();
            if (T == typeof(String)) return v = _.ToString();
            else if (T == typeof(int) || T == typeof(Int16) || T == typeof(Int32) || T == typeof(Int64) || T == typeof(float) || T == typeof(Double) || T == typeof(Decimal)) v = _.ToString();
            else if (T == typeof(Guid)) v = _.ToString().ToGUID().ToString("D");
            else if (T == typeof(DateTime)) v = v = _.ToString().ToDateTime().ToString("yyyy-MM-dd HH:mm:ss.fff");
            else if (T == typeof(Boolean)) v = Convert.ToInt32(_).ToString();
            else v = _.ToString();
            return v;
        }
        #endregion

        #region 字符从一个编码转换成另一种编码
        /// <summary>
        /// 字符从一个编码转换成另一种编码
        /// </summary>
        /// <param name="_">字符串</param>
        /// <param name="From">编码</param>
        /// <param name="To">目标编码</param>
        /// <returns></returns>
        public static string ToEncode(this String _, string From, string To)
        {
            Encoding from = Encoding.GetEncoding(From), to = Encoding.GetEncoding(To);
            return to.GetString(Encoding.Convert(from, to, from.GetBytes(_)));
        }
        #endregion

        #region 实现String.Format的扩展
        /// <summary>
        /// 实现String.Format的扩展
        /// </summary>
        /// <param name="_">字符串</param>
        /// <param name="args">参数集</param>
        /// <returns></returns>
        public static String format(this String _, params object[] args)
        {
            var len = _.getMatches(@"\{\d+\}").Count;
            object[] arg = new object[Math.Max(len, args.Length)];
            args.CopyTo(arg, 0);
            if (len > args.Length) for (int i = args.Length; i < len; i++) arg[i] = "";
            return String.Format(_, arg);
        }
        /// <summary>
        /// 实现String.Format的扩展
        /// </summary>
        /// <param name="_">字符串 自定义变量转换 {key}或${key}</param>
        /// <param name="d">Dictionary集</param>
        /// <returns></returns>
        public static String format(this String _, IDictionary<String, String> d)
        {
            d.Each(KValue => _ = _.ReplacePattern(@"\$?{{{0}}}".format(KValue.Key), KValue.Value));
            return _;
        }
        #endregion

        #region 字符串转换成对象

        #region 字符串转换成Int16
        /// <summary>
        /// 字符串转换成Int16
        /// </summary>
        /// <param name="_">字符串</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static Int16 ToInt16(this String _, Int16 defaultValue = 0)
        {
            Int16 _result = 0;
            if (_.isFloat())
                return Convert.ToInt16(_.ToFloat(Convert.ToSingle(defaultValue)));
            else
                return Int16.TryParse(_, out _result) ? _result : defaultValue;
        }
        /// <summary>
        /// 字符串转换成UInt16
        /// </summary>
        /// <param name="_">字符串</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static UInt16 ToUInt16(this String _, UInt16 defaultValue = 0)
        {
            return (UInt16)Math.Abs(_.ToInt16(Int16.Parse(defaultValue.ToString())));
        }
        #endregion

        #region 字符串转换成Int32
        /// <summary>
        /// 字符串转换成Int32
        /// </summary>
        /// <param name="_">字符串</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static Int32 ToInt32(this String _, Int32 defaultValue = 0)
        {
            int _result = 0;
            if (_.isFloat())
                return Convert.ToInt32(_.ToFloat(Convert.ToSingle(defaultValue)));
            else
                return Int32.TryParse(_, out _result) ? _result : defaultValue;
        }
        /// <summary>
        /// 字符串转换成UInt32
        /// </summary>
        /// <param name="_">字符串</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static UInt32 ToUInt32(this String _, UInt32 defaultValue = 0)
        {
            return (UInt32)Math.Abs(_.ToInt32(Int32.Parse(defaultValue.ToString())));
        }
        #endregion

        #region 字符串转换成Int64
        /// <summary>
        /// 字符串转换成Int64
        /// </summary>
        /// <param name="_">字符串</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static Int64 ToInt64(this String _, Int64 defaultValue = 0)
        {
            Int64 _result = 0;
            if (_.isNumberic())
                return Int64.TryParse(_, out _result) ? _result : defaultValue;
            else
                return Convert.ToInt64(_.ToFloat(Convert.ToSingle(defaultValue)));
        }
        /// <summary>
        /// 字符串转换成UInt64
        /// </summary>
        /// <param name="_">字符串</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static UInt64 ToUInt64(this String _, UInt64 defaultValue = 0)
        {
            return (UInt64)Math.Abs(_.ToInt64(Int64.Parse(defaultValue.ToString())));
        }
        #endregion

        #region 字符串转换成Double
        /// <summary>
        /// 字符串转换成Double
        /// </summary>
        /// <param name="_">字符串</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static Double ToDouble(this String _, Double defaultValue = 0)
        {
            double _result = 0;
            return Double.TryParse(_, out _result) ? _result : defaultValue;
        }
        #endregion

        #region 字符串转换成Decimal
        /// <summary>
        /// 字符串转换成Decimal
        /// </summary>
        /// <param name="_">字符串</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static Decimal ToDecimal(this String _, Decimal defaultValue = 0)
        {
            decimal _result = 0;
            return Decimal.TryParse(_, out _result) ? _result : defaultValue;
        }
        #endregion

        #region 字符串转换成float
        /// <summary>
        /// 字符串转换成float
        /// </summary>
        /// <param name="_">字符串</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static float ToFloat(this String _, float defaultValue = 0)
        {
            float _result = 0;
            return float.TryParse(_, out _result) ? _result : defaultValue;
        }
        #endregion

        #region 字符串转换成long
        /// <summary>
        /// 字符串转换成long
        /// </summary>
        /// <param name="_">字符串</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static long ToLong(this String _, long defaultValue = 0)
        {
            long _result = 0;
            return long.TryParse(_, out _result) ? _result : defaultValue;
        }
        #endregion

        #region 字符串转换成Guid
        /// <summary>
        /// 字符串转换成Guid
        /// </summary>
        /// <param name="_">字符串</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static Guid ToGUID(this String _, Guid defaultValue)
        {
            return _.isGUID() ? new Guid(_) : defaultValue;
        }
        /// <summary>
        /// 字符串转换成ToGUID
        /// </summary>
        /// <param name="_">字符串</param>
        /// <returns></returns>
        public static Guid ToGUID(this String _)
        {
            return _.ToGUID(Guid.Empty);
        }
        #endregion

        #region 字符串转换成Boolean
        /// <summary>
        /// 字符串转换成Boolean
        /// </summary>
        /// <param name="_">字符串</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static Boolean ToBoolean(this String _, Boolean defaultValue = false)
        {
            bool f = false;
            if (_.isFloat()) return _.ToFloat() > 0;
            return Boolean.TryParse(_, out f) ? f : defaultValue;
        }
        #endregion

        #region 字符串转换成DateTime
        /// <summary>
        /// 字符串转换成DateTime
        /// </summary>
        /// <param name="_">字符串</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static DateTime ToDateTime(this String _, String defaultValue = "1900-01-01")
        {
            DateTime dt = DateTime.Parse(defaultValue);
            return _.ToDateTime(dt);
        }
        /// <summary>
        /// 字符串转换成DateTime
        /// </summary>
        /// <param name="_">字符串</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static DateTime ToDateTime(this String _, DateTime defaultValue)
        {
            DateTime dt = defaultValue;
            return DateTime.TryParse(_, out dt) ? dt : defaultValue;
        }
        #endregion

        #region 字符串转换数据类型
        /// <summary>
        /// 字符串转换数据类型
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="_">字符串</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static T ToCast<T>(this String _, T defaultValue = default(T))
        {
            Type _t = typeof(T);
            if (_t == typeof(String)) return (T)Convert.ChangeType(_, _t);
            T t = Activator.CreateInstance<T>();
            if (_t == typeof(Int16) || _t == typeof(Int16?))
                t = (T)Convert.ChangeType(_.ToInt16(defaultValue.ToString().ToInt16()), typeof(Int16));
            else if (_t == typeof(UInt16) || _t == typeof(UInt16?))
                t = (T)Convert.ChangeType(_.ToUInt16(defaultValue.ToString().ToUInt16()), typeof(UInt16));
            else if (_t == typeof(int) || _t == typeof(Int32) || _t == typeof(int?) || _t == typeof(Int32?))
                t = (T)Convert.ChangeType(_.ToInt32(defaultValue.ToString().ToInt32()), typeof(Int32));
            else if (_t == typeof(uint) || _t == typeof(UInt32) || _t == typeof(uint?) || _t == typeof(UInt32?))
                t = (T)Convert.ChangeType(_.ToUInt32(defaultValue.ToString().ToUInt32()), typeof(UInt32));
            else if (_t == typeof(Int64) || _t == typeof(Int64?))
                t = (T)Convert.ChangeType(_.ToInt64(defaultValue.ToString().ToInt64()), typeof(Int64));
            else if (_t == typeof(UInt64) || _t == typeof(UInt64?))
                t = (T)Convert.ChangeType(_.ToUInt64(defaultValue.ToString().ToUInt64()), typeof(UInt64));
            else if (_t == typeof(Double) || _t == typeof(Double?))
                t = (T)Convert.ChangeType(_.ToDouble(defaultValue.ToString().ToDouble()), typeof(Double));
            else if (_t == typeof(Decimal) || _t == typeof(Decimal?))
                t = (T)Convert.ChangeType(_.ToDecimal(defaultValue.ToString().ToDecimal()), typeof(Decimal));
            else if (_t == typeof(Guid) || _t == typeof(Guid?))
                t = (T)Convert.ChangeType(_.ToGUID(defaultValue.ToString().ToGUID()), typeof(Guid));
            else if (_t == typeof(float) || _t == typeof(float?))
                t = (T)Convert.ChangeType(_.ToFloat(defaultValue.ToString().ToFloat()), typeof(float));
            else if (_t == typeof(long) || _t == typeof(long?))
                t = (T)Convert.ChangeType(_.ToLong(defaultValue.ToString().ToLong()), typeof(long));
            else if (_t == typeof(Boolean) || _t == typeof(Boolean?))
                t = (T)Convert.ChangeType(_.ToBoolean(defaultValue.ToString().ToBoolean()), typeof(Boolean));
            else if (_t == typeof(DateTime) || _t == typeof(DateTime?))
                t = (T)Convert.ChangeType(_.ToDateTime(defaultValue.ToString().ToDateTime()), typeof(DateTime));
            else
                t = (T)Convert.ChangeType(_, _t);
            return t;
        }
        #endregion

        #region 类型转换
        /// <summary>
        /// 类型转换
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="_">对象</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static T ToCast<T>(this object _, T defaultValue = default(T))
        {
            try
            {
                if (_.GetType() == typeof(String))
                    return _.ToString().ToCast<T>(defaultValue);
                else
                    return (T)Convert.ChangeType(_, typeof(T));
            }
            catch
            {
                return defaultValue;
            }
        }
        #endregion

        #region 字符串与Base64互转
        /// <summary>
        /// 字符串转base64
        /// </summary>
        /// <param name="_">字符串</param>
        /// <param name="encoding">编码</param>
        /// <returns></returns>
        public static string ToBase64String(this String _, string encoding)
        {
            return Convert.ToBase64String(_.GetBytes(encoding ?? "UTF-8"));
            //return Convert.ToBase64String(Encoding.GetEncoding(encoding).GetBytes(_));
        }
        /// <summary>
        /// 字符串转base64
        /// </summary>
        /// <param name="_">字符串</param>
        /// <param name="encoding">编码</param>
        /// <returns></returns>
        public static string ToBase64String(this String _, Encoding encoding = null)
        {
            return Convert.ToBase64String(_.GetBytes(encoding));
            //return Convert.ToBase64String((encoding ?? Encoding.UTF8).GetBytes(_));
        }
        /// <summary>
        /// base64字符串转字符串
        /// </summary>
        /// <param name="_">Base64字符串</param>
        /// <param name="encoding">编码</param>
        /// <returns></returns>
        public static string FromBase64String(this String _, string encoding)
        {
            return Convert.FromBase64String(_).GetString(encoding ?? "UTF-8");
            //return Encoding.GetEncoding(encoding).GetString(Convert.FromBase64String(_));
        }
        /// <summary>
        /// base64字符串转字符串
        /// </summary>
        /// <param name="_">Base64字符串</param>
        /// <param name="encoding">编码</param>
        /// <returns></returns>
        public static string FromBase64String(this String _, Encoding encoding = null)
        {
            return Convert.FromBase64String(_).GetString(encoding);
            //return (encoding ?? Encoding.UTF8).GetString(Convert.FromBase64String(_));
        }
        #endregion

        #region 字符串字节互转
        /// <summary>
        /// 字符串转字节
        /// </summary>
        /// <param name="_">字符串</param>
        /// <param name="encoding">编码</param>
        /// <returns></returns>
        public static byte[] GetBytes(this String _, Encoding encoding = null)
        {
            return (encoding ?? Encoding.UTF8).GetBytes(_);
        }
        /// <summary>
        /// 字符串转字节
        /// </summary>
        /// <param name="_">字符串</param>
        /// <param name="encoding">编码</param>
        /// <returns></returns>
        public static byte[] GetBytes(this String _, string encoding)
        {
            return Encoding.GetEncoding(encoding ?? "UTF-8").GetBytes(_);
        }
        /// <summary>
        /// 字节转字符串
        /// </summary>
        /// <param name="_">字节</param>
        /// <param name="encoding">编码</param>
        /// <param name="index">开始位置</param>
        /// <param name="count">长度</param>
        /// <returns></returns>
        public static string GetString(this byte[] _, Encoding encoding = null, int index = 0, int count = 0)
        {
            return (encoding ?? Encoding.UTF8).GetString(_, index, count == 0 ? _.Length : count);
        }
        /// <summary>
        /// 字节转字符串
        /// </summary>
        /// <param name="_">字节</param>
        /// <param name="encoding">编码</param>
        /// <param name="index">开始位置</param>
        /// <param name="count">长度</param>
        /// <returns></returns>
        public static string GetString(this byte[] _, string encoding = null, int index = 0, int count = 0)
        {
            return Encoding.GetEncoding(encoding ?? "UTF-8").GetString(_, index, count == 0 ? _.Length : count);
        }
        #endregion

        #endregion

        #region 获取HTML文本内容
        /// <summary>
        /// 获取HTML文本内容
        /// </summary>
        /// <param name="_">HTML内容</param>
        /// <returns></returns>
        public static String InnerText(this String _)
        {
            if (_.IsNullOrEmpty()) return "";
            _ = _.RemovePattern(@"<!--[\s\S]*?-->");
            _ = _.RemovePattern(@"<script[^>]*>[\s\S]*?</\s*script>");
            _ = _.RemovePattern(@"<(script|style|textarea)[^>]*>[\s\S]*?</\s*(script|style|textarea)>");
            _ = _.RemovePattern(@"<(!doctype|table|thead|tbody|tr|td|th|div|blockquote|fieldset|legend|font|i|u|h[1-9]|s|b|m|p|strong|meta|iframe|frame|span|layer|link|html|head|body|title|a|ul|ol|li|dl|dt|dd|img|form|select|input|button|canvas|header|nav|footer|select|option|textarea|em|noscript|section|svg|use|label)(\s*[^>]*)?>|<\/\s*(table|thead|tbody|tr|td|th|div|blockquote|fieldset|legend|font|i|u|h[1-9]|s|b|m|p|strong|meta|iframe|frame|span|layer|link|html|head|body|title|a|ul|ol|li|dl|dt|dd|img|form|select|input|button|canvas|header|nav|footer|select|option|textarea|em|noscript|section|svg|use|label)>");
            _ = _.RemovePattern(@"[\r\n\t]");
            _ = _.ReplacePattern(@"&gt;", ">").ReplacePattern(@"&lt;", "<").ReplacePattern(@"&amp;", "&").ReplacePattern(@"&quot;", "\"")
                .ReplacePattern("&nbsp;", " ").ReplacePattern(@"\s+", " ")
                .ReplacePattern(@"&copy;", "©").ReplacePattern(@"&reg;", "®");
            return _;
        }
        #endregion

        #region 截取字符串 一个汉字为两个字符
        /// <summary>
        /// 截取字符串 一个汉字为两个字符
        /// </summary>
        /// <param name="_">字符串</param>
        /// <param name="length">长度</param>
        /// <param name="endString">结束串 如...</param>
        /// <returns></returns>
        public static string SubString(this string _, int length = 0, string endString = "...")
        {
            if (_.IsNullOrEmpty()) return "";
            _ = _.RemovePattern(@"[\s\r\t\n]+", RegexOptions.IgnoreCase);
            if (length <= 0) return _;
            if (Encoding.Default.GetBytes(_).Length <= length) return _;
            int num = 0;
            string str = "";
            for (int i = 0; i < _.Length; i++)
            {
                num += Encoding.Default.GetBytes(_[i].ToString()).Length;
                str = str + _[i].ToString();
                if (num >= length) break;
            }
            return str + endString;
        }
        #endregion

        #region 颜色：16进制转成RGB
        /// <summary>
        /// 颜色：16进制转成RGB
        /// </summary>
        /// <param name="HxColor">16进制颜色</param>
        /// <returns></returns>
        public static System.Drawing.Color ColorHx16toRGB(this string HxColor)
        {
            try
            {
                if (HxColor.Length == 0)
                    return System.Drawing.Color.FromArgb(0, 0, 0);
                else
                    return System.Drawing.Color.FromArgb(System.Int32.Parse(HxColor.Substring(1, 2), System.Globalization.NumberStyles.AllowHexSpecifier), System.Int32.Parse(HxColor.Substring(3, 2), System.Globalization.NumberStyles.AllowHexSpecifier), System.Int32.Parse(HxColor.Substring(5, 2), System.Globalization.NumberStyles.AllowHexSpecifier));
            }
            catch
            {
                return System.Drawing.Color.FromArgb(0, 0, 0);
            }
        }
        #endregion
    }
}
瓜哥丿
关注
2
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
C# 常用方法扩展

using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Text.RegularExpressions;using System.Reflection;using System.Xml;using System.Collections;using S...
复制链接

扫一扫
专栏目录