自己总结的C#通用方法（收藏）

using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace Tools
{
    class Program
    {
        static void Main(string[] args)
        {
        }
        #region datatable To List
        /// <summary>
        /// 将Datatable转换为List
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="table">需要转换的datatable</param>
        /// <returns></returns>
        public static List<T> DataTableToModelList<T>(this DataTable table) where T : new()
        {
            List<T> entities = new List<T>();

            foreach (DataRow row in table.Rows)
            {
                T entity = new T();
                foreach (var item in entity.GetType().GetProperties())
                {
                    if (row.Table.Columns.Contains(item.Name.ToUpper()))
                    {
                        if (DBNull.Value != row[item.Name])
                        {
                            item.SetValue(entity, ChangeType(row[item.Name], item.PropertyType), null);
                        }
                    }
                }
                entities.Add(entity);
            }
            if (table.Rows.Count == 0)
            {
                return null;
            }
            return entities;
        }
        /// <summary>
        /// 改变类型
        /// </summary>
        /// <param name="value"></param>
        /// <param name="conversionType"></param>
        /// <returns></returns>
        private static object ChangeType(object value, Type conversionType)
        {
            if (conversionType == null)
            {
                throw new ArgumentNullException("conversionType");
            }
            if (conversionType.IsGenericType && conversionType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
            {
                if (value == null)
                {
                    return null;
                }
                System.ComponentModel.NullableConverter nullableConverter = new System.ComponentModel.NullableConverter(conversionType);
                conversionType = nullableConverter.UnderlyingType;
            }
            try
            {
                return Convert.ChangeType(value, conversionType);
            }
            catch
            {
                return null;
            }

        }
        #endregion
        /// <summary>
        /// 全角转半角
        /// </summary>
        /// <param name="input">输入的值</param>
        /// <returns>转换以后的值</returns>
        public static string ToDBC(string input)
        {
            input = Regex.Replace(input, @"\s", "").Trim();
            char[] array = input.ToCharArray();
            for (int i = 0; i < array.Length; i++)
            {
                if (array[i] == 12288)
                {
                    array[i] = (char)32;
                    continue;
                }
                if (array[i] > 65280 && array[i] < 65375)
                    array[i] = (char)(array[i] - 65248);
            }
            return new string(array);
        }
        /// <summary>
        /// 特殊字符串处理
        /// </summary>
        /// <param name="inputStr">输入的字符串</param>
        /// <returns>处理后的字符串</returns>
        public static string SpecialStringHandle(string inputStr)
        {
            //特殊符号转换： //将•转换成· //将（转换成( //将）转换成) //将—转换成-  //将：转换成:  //将１转换成1，以此类推０到９全部转换成0到9  
            //将Ａ转换成A，以此类推Ａ到Ｚ全部转换成A到Z //将＜转换成<  //将＞转换成>  //去除换行符
            if (!string.IsNullOrEmpty(inputStr))
            {
                inputStr = ToDBC(inputStr);
                inputStr = inputStr.Replace("•", "·").Replace("（", "(").Replace("）", ")").Replace("—", "-").Replace("：", ":").Replace("＜", "<").Replace("＞", ">").Replace(System.Environment.NewLine, "");
            }
            else
                inputStr = "";
            return inputStr;
        }
        /// <summary>
        /// 科学计数法转decimal
        /// </summary>
        /// <param name="strData"></param>
        /// <returns></returns>
        public static Decimal ChangeDataToD(string strData)
        {
            Decimal dData = 0.0M;
            if (string.IsNullOrEmpty(strData)) return dData;
            if (strData.Contains("E"))
                dData = Convert.ToDecimal(Decimal.Parse(strData, System.Globalization.NumberStyles.Float));
            else
            {
                try
                {
                    dData = Decimal.Parse(strData, System.Globalization.NumberStyles.Float);
                }
                catch
                { }
            }
            return dData;
        }
        /// <summary>
        /// object to Int 大于10亿以后的数值
        /// </summary>
        /// <param name="input"></param>
        /// <returns>返回64位long值类型</returns>
        public static long ObjectToInt(object input)
        {
            long num = 0;
            string pattern = @"[^\d\.]";
            try
            {
                if (Regex.IsMatch(input.ToString(), pattern))
                    num = Int64.Parse(Regex.Replace(input.ToString(), pattern, ""));
                else
                    num = Int64.Parse(input.ToString());
            }
            catch
            { }
            return num;
        }
        /// <summary>
        /// 需求:   利用分组原理去除
        /// 1.中文之间的空格要去掉
        /// 2.英文数字之家的空格，多个空格转换为一个空格
        /// 3.数字字母，中间是空格，右边是非数字字母;需要去除空格
        /// </summary>
        /// <param name="value">传入需要处理的对象</param>
        /// <returns>返回处理后的字符串</returns>
        public static string FormatMultiSpaceValue(object value)
        {
            //去掉多空格为一个空格
            // shareHolderName = Regex.Replace(shareHolderName.ToString(), "[\\s]+", " ");
            //去掉换行
            value = value.ToString().Replace(System.Environment.NewLine, "");
            //匹配左侧是数字字母，中间是空格，右边是非数字字母;需要去除空格
            string pattern1 = @"([a-zA-Z\d]+)(\s+)([^a-zA-Z\d\s])";
            //匹配左侧是非数字字母，中间是空格，右侧是数字字母
            string pattern2 = @"([^a-zA-Z\d\s])(\s+)([a-zA-Z\d]+)";
            //匹配字母之间的多个空格，多个空格替换成为一个空格
            string pattern3 = @"([a-zA-Z\d]+)(\s{2,})([a-zA-Z\d]+)";
            if (Regex.IsMatch(value.ToString(), pattern3))
                value = Regex.Replace(value.ToString(), pattern3, "$1 $3");
            if (Regex.IsMatch(value.ToString(), pattern2))
                value = Regex.Replace(value.ToString(), pattern2, "$1$3");
            if (Regex.IsMatch(value.ToString(), pattern1))
                value = Regex.Replace(value.ToString(), pattern1, "$1$3");
            return value.ToString();
        }
        /// <summary>
        /// 移除Datatable中是空行的部分
        /// </summary>
        /// <param name="dt">传入的datatable</param>
        /// <returns>返回处理后的datatable</returns>
        public static DataTable RemoveNullRow(DataTable dt)
        {
            //定义一个存储需要被移除行的集合
            List<DataRow> removeLise = new List<DataRow>();
            for (int row = 0; row < dt.Rows.Count; row++)
            {
                bool isNull = true;
                for (int column = 0; column < dt.Columns.Count; column++)
                {
                    //判断是否该单元格为空
                    if (!string.IsNullOrEmpty(dt.Rows[row][column].ToString()))
                    {
                        isNull = false;
                        break;
                    }
                }
                //如果该行全为空，则需要被移除
                if (isNull)
                    removeLise.Add(dt.Rows[row]);
            }
            //开始移除
            for (int i = 0; i < removeLise.Count; i++)
            {
                dt.Rows.Remove(removeLise[i]);
            }
            return dt;
        }
        /// <summary>
        /// 移除datatable中空列的部分
        /// </summary>
        /// <param name="dt">传入的datatable</param>
        /// <returns>处理以后的datatable</returns>
        public static DataTable RemoveNullColumn(DataTable dt)
        {
            //定义一个int类型的的数组存储需要被移除列的索引
            List<int> columnIndex = new List<int>();
            for (int column = 0; column < dt.Columns.Count; column++)
            {
                bool isNull = true;
                for (int row = 0; row < dt.Rows.Count; row++)
                {
                    if (!string.IsNullOrEmpty(dt.Rows[row][column].ToString()))
                    {
                        isNull = false;
                        break;
                    }
                }
                //如果该列全部到都为空，则需要被移除
                if (isNull)
                    columnIndex.Add(column);
            }
            //将游标降序排列，移除的时候，按照游标从大到小进行移除，这样移除的时候就不会出现列移位，而出现超出索引 的范围错误
            columnIndex = (from p in columnIndex orderby p descending select p).ToList();
            foreach (int item in columnIndex)
            {
                dt.Columns.RemoveAt(item);
            }
            return dt;
        }
        /// <summary>
        /// 合并datatable中每一行第index列为空的行
        /// </summary>
        /// <param name="dt">传入的datatable</param>
        /// <param name="index">列的索引</param>
        /// <returns>返回处理后datatable</returns>
        public static DataTable MergeColumnIndexIsNull(DataTable dt, int index)
        {
            DataTable ds = dt.Clone();
            foreach (DataRow dr in dt.Rows)
            {
                //定义一个新行
                DataRow drCenter = dt.NewRow();
                //判断第index列是否是空
                if (string.IsNullOrEmpty(dr[index].ToString()))
                {
                    //为空就将上一行与该行合并
                    //ds.Rows.Count - 1需要大于或者等于0
                    if (ds.Rows.Count > 0)
                    {
                        for (int i = 0; i < dt.Columns.Count; i++)
                        {
                            //将ds的最后一行，与是指定列为空的行合并
                            drCenter[i] = string.Format("{0}{1}", ds.Rows[ds.Rows.Count - 1][i], dr[i]);//这里面只考虑字符串拼接，如果有数字相加就需要判断相应的列转换为int相加
                        }
                    }
                    //移除掉原先的最后一行，因为已经得到了合并的新行
                    ds.Rows.Remove(ds.Rows[ds.Rows.Count - 1]);
                }
                else
                {
                    //不为空直接加上去
                    drCenter = dr;
                }
                //添加其他表的行的时候，已经要进行ItemArray
                ds.Rows.Add(drCenter.ItemArray);
            }
            return ds;
        }
        public static DataTable MergeRowByColumnIndexValueEquation(DataTable dt, int index)
        {
            DataTable ds = dt.Clone();
            foreach (DataRow dr in dt.Rows)
            {
                DataRow drDataRow = ds.NewRow();
                string strCondition = string.Format("{0}='{1}'", dt.Columns[index].ColumnName, dr[dt.Columns[index].ColumnName]);
                //已经包含有相同的
                if (ds.Select(strCondition).Length > 0)
                {
                    DataRow dscenter = ds.Select(strCondition)[0];
                    for (int i = 0; i < dt.Columns.Count; i++)
                    {
                        if (i == index)
                            drDataRow[dt.Columns[index].ColumnName] = dscenter[dt.Columns[index].ColumnName];
                        else//单纯进行字符串拼接，如果需要数字相加需要做下一步处理
                            drDataRow[dt.Columns[index].ColumnName] = string.Format("{0}{1}", dscenter[dt.Columns[index].ColumnName], dr[dt.Columns[index].ColumnName]);
                    }
                    foreach (DataRow item in ds.Select(strCondition))
                    {
                        ds.Rows.Remove(dscenter);
                    }
                }
                else
                {
                    //没有包含有相同的
                    drDataRow = dr;
                }
                ds.Rows.Add(drDataRow.ItemArray);
            }
            return ds;
        }
        /// <summary>
        /// 处理数字
        /// </summary>
        /// <param name="input">传入的对象</param>
        /// <returns>返回处理后的</returns>
        public static string FormatNum(object input)
        {
            if (input == null)
                return "";
            string pattern = @"[^\d\.]";
            if (Regex.IsMatch(input.ToString(), pattern))
                input = Regex.Replace(input.ToString(), pattern, "");
            return input.ToString();
        }
        /// <summary>
        /// 返回一个字符串中包含某个关键字的索引
        /// 股份质押$股份冻结 =strInput
        /// split='$'
        /// keyWord='冻结' 寻找冻结
        /// </summary>
        /// <param name="strInput">字符串</param>
        /// <param name="split">包含split</param>
        /// <param name="keyWord">关键字</param>
        /// <returns>返回包含关键字的索引</returns>
        public static int GetIndex(string strInput, char split, string keyWord)
        {
            return strInput.Split(split).Select((v, i) => new { word = v, index = i }).FirstOrDefault(s => s.word.Contains(keyWord)).index;
        }
        /// <summary>
        /// 字符串去掉重复部分
        /// </summary>
        /// <param name="strInput">输入的字符串</param>
        /// <param name="split">字符串分隔符</param>
        /// <returns>处理后的字符串</returns>
        public static string StrDuplicateremoval(string strInput, char split)
        {
            string[] strReason = strInput.Split(split);
            string strCenter = "";
            foreach (string item1 in strReason.ToList())
            {
                if (!strCenter.Contains(item1))
                    strCenter += item1 + split;
            }
            return strCenter;
        }
        /// <summary>
        /// 数组添加元素
        /// </summary>
        /// <param name="strArray">原数组</param>
        /// <param name="element">元素</param>
        /// <returns>后面的数组</returns>
        public static string[] arrayAddElement(string[] strArray, string element)
        {
            List<string> strList = strArray.ToList();
            strList.Add(element);
            strArray = strList.ToArray();
            return strArray;
        }
        /// <summary>
        /// 获取匹配后得到的数组
        /// </summary>
        /// <param name="strContent">匹配字符串</param>
        /// <param name="pattern">匹配正则表达式</param>
        /// <returns>匹配后得到的数组</returns>
        public static List<string> GetMatch(string strContent, string pattern)
        {
            List<string> listMatch = new List<string>();
            if (Regex.IsMatch(strContent, pattern))
            {
                GroupCollection colls = Regex.Match(strContent, pattern).Groups;
                for (int i = 1; i <= colls.Count; i++)
                {
                    listMatch.Add(colls[i].ToString());
                }
            }
            return listMatch;
        }
        /// <summary>
        /// 获得分组名对应的键值对
        /// </summary>
        /// <param name="strContent">传入的字符串</param>
        /// <param name="pattern">正则表达式</param>
        /// <returns>返回分组键值对</returns>
        public static Dictionary<string, string> GetMatch(string strContent, string pattern)
        {
            Dictionary<string, string> matchDic = new Dictionary<string, string>();
            Regex regex = new Regex(pattern);
            Match result = Regex.Match(strContent, pattern);
            if (result.Success)
            {
                foreach (var groupName in regex.GetGroupNames())
                {
                    matchDic.Add(groupName, result.Groups[groupName].Value);
                }
            }
            return matchDic;
        }
        /// <summary>
        /// 需求 转义特殊正则表达式字符
        /// 1.在对某个词进行正则查询的时候，查询内容里面本身就有正则特殊字符影响查询
        /// 2.因此拼接之前需要特殊处理
        /// 处理拼接字符串的时候里面的特殊正则字符
        /// </summary>
        /// <param name="strInput">字符串</param>
        /// <returns>处理过后的字符串</returns>
        public static string TransFerredMeaning(string strInput)
        {
            //所有正则表达式字符
            string strPatter = @"* . ? + $ ^ [ ] ( ) { } | \ /";
            Char[] charArray = strInput.ToCharArray();
            strInput = "";
            foreach (char cha in charArray)
            {
                if (cha != ' ' && strPatter.IndexOf(cha) > -1)
                    strInput += @"\" + cha;
                else
                    strInput += cha;
            }
            return strInput;
        }

        /// <summary>
        /// 获取截取日期的算法
        /// </summary>
        public static void GetEndDate()
        {
            List<string> dateList = new List<string>();
            GetDateList(dateList);           
            foreach (string date in dateList)
            {
                List<string> dateItem = new List<string>();
                dateItem.Add(date);
            }
           string dateTime = dateList[0];
            
        }
        /// <summary>
        /// 根据条件获取时间列表
        /// </summary>
        /// <param name="dateList">时间列表</param>
        public static void GetDateList(List<string> dateList)
        {
            int year = DateTime.Now.Year;
            int month = DateTime.Now.Month;
            string[] date = new string[] { "03-31", "06-30", "09-30", "12-31" };
            for (int i = 0; i < date.Length; i++)
            {
                //
                int key = (month - 1) / 3;
                if (key == 0)
                    dateList.Add(string.Format("{0}-{1}", year - 1, date[i]));
                else
                {
                    if (i < key)
                        dateList.Add(string.Format("{0}-{1}", year, date[i]));
                    else
                        dateList.Add(string.Format("{0}-{1}", year - 1, date[i]));
                }
            }
            dateList = dateList.OrderByDescending(s => int.Parse(s.Replace("-", ""))).ToList();
        }
    }
}