学习反射之将List<T>自定义导出

学习反射之将List<T>自定义导出

1.前言：最近有个Task需要操作很多大表(每个表的列名都上百),需要将这些表数据从不同数据源中找到，然后将表导入到数据库，可能还得需要将表部分数据导出成各种文件(csv,txt,excel等)。

 

2.思考：一般像这种需求.先定义一个TemplateInfo，然后去DB为这个TemplateInfo创建一个表。最后封装TemplateManager定义一些操作DB的方法。

现在问题产生了：需要经常导出表中部分数据。有时候导出titles可能有细微变化。由于TemplateInfo有很多属性，每次光复制粘贴TemplateInfo属性赋值那部分代码就够花时间的了，跟不用说让有点强迫症的人每次面对几乎差不多代码了。

　　首先我们是不知道List<T>中T的具体类型，所以只能通过反射获取T的属性和值，在通过传递参数实现自定义，按照不同的参数条件，顺序，得到一组属性和对应值。然后直接生成文件。

 

3.ReflectionUtil类，定义一组反射相关的方法

    public class ReflectionUtil
    {
        /// <summary>
        /// Get template public property name collection
        /// </summary>
        /// <param name="dateType">template type</param>
        /// <returns>property name collection</returns>
        public static List<string> GetPropertyNames<T>(T dateType)
        {
            if (dateType == null)
            {
                throw new Exception("parameter cannot be null.");
            }

            var propertyName = new List<string>();
            Type type = dateType.GetType();
            PropertyInfo[] properties = type.GetProperties();
            foreach (var property in properties)
            {
                propertyName.Add(property.Name.ToString());
            }

            return propertyName;
        }

        /// <summary>
        /// Get property adn set func
        /// </summary>
        /// <param name="dataType">template type</param>
        /// <param name="propertyName">property name</param>
        /// <returns></returns>
        public static Func<object, object> GetPropertySetFunc(Type dataType, string propertyName)
        {
            var propInfo = dataType.GetProperty(propertyName);
            var getMethodInfo = propInfo.GetGetMethod();

            DynamicMethod dynamicGet = CreateGetDynamicMethod(dataType);
            ILGenerator getGenerator = dynamicGet.GetILGenerator();

            getGenerator.Emit(OpCodes.Ldarg_0);
            getGenerator.Emit(OpCodes.Call, getMethodInfo);
            BoxIfNeeded(getMethodInfo.ReturnType, getGenerator);
            getGenerator.Emit(OpCodes.Ret);

            return dynamicGet.CreateDelegate(typeof(Func<object, object>)) as Func<object, object>;
        }

        /// <summary>
        /// Create get dynamic method
        /// </summary>
        /// <param name="type">template type</param>
        /// <returns></returns>
        private static DynamicMethod CreateGetDynamicMethod(Type type)
        {
            return new DynamicMethod("DynamicGet", typeof(object), new[] { typeof(object) }, type, true);
        }

        /// <summary>
        /// Box
        /// </summary>
        /// <param name="type">template type</param>
        /// <param name="generator">il generator</param>
        private static void BoxIfNeeded(Type type, ILGenerator generator)
        {
            if (type.IsValueType)
            {
                generator.Emit(OpCodes.Box, type);
            }
        }
    }

4.CollectionExportUtil类，封装一组重载方法，根据不同参数满足各种文件需求导出。可以减少很多代码量和时间。

    /// <summary>
    /// ExportType can be add by new requirement in the future
    /// </summary>
    public enum ExportType
    {
        TxtFile,
        CsvFile,
        NoSeparator,
        Space,
        Other
    }

    public class CollectionExportUtil
    {
        /// <summary>
        /// export file from property index start
        /// </summary>
        /// <typeparam name="T">template</typeparam>
        /// <param name="dataCollection">template collection</param>
        /// <param name="propertyIndexStart">property index start</param>
        /// <param name="exportType">content type</param>
        /// <returns>content string</returns>
        public static string GenerateExportText<T>(List<T> dataCollection, int propertyIndexStart, ExportType exportType)
        {
            int propertyIndexEnd = ReflectionUtil.GetPropertyNames(dataCollection[0]).Count() - 1;
            return GenerateExportText(dataCollection, propertyIndexStart, propertyIndexEnd, exportType);
        }

        /// <summary>
        /// export file from property index start to index end
        /// </summary>
        /// <typeparam name="T">template</typeparam>
        /// <param name="dataCollection">template collection</param>
        /// <param name="propertyIndexStart">property index start</param>
        /// <param name="propertyIndexEnd">property index end </param>
        /// <param name="exportType">file type</param>
        /// <returns>content string</returns>
        public static string GenerateExportText<T>(List<T> dataCollection, int propertyIndexStart, int propertyIndexEnd, ExportType exportType)
        {
            if (propertyIndexStart == null || propertyIndexEnd == null)
            {
                throw new Exception("property index parameter cannot be null.");
            }

            if (propertyIndexStart.CompareTo(0) < 0)
            {
                throw new Exception("property index start must more than zero.");
            }

            if (propertyIndexStart.CompareTo(propertyIndexEnd) > 0)
            {
                throw new Exception("property index start must less than index end.");
            }

            Dictionary<string, string> columnInfos = new Dictionary<string, string>();
            var columns = ReflectionUtil.GetPropertyNames(dataCollection[0]);

            if (propertyIndexEnd.CompareTo(columns.Count) > 0)
            {
                throw new Exception("index end cannot bigger than column count.");
            }

            for (int i = propertyIndexStart; i <= propertyIndexEnd; i++)
            {
                columnInfos.Add(columns[i], columns[i]);
            }

            return GenerateExportText(dataCollection, columnInfos, exportType);
        }

        /// <summary>
        /// Export by template property index list with property name
        /// </summary>
        /// <typeparam name="T">template</typeparam>
        /// <param name="dataCollection">template collection</param>
        /// <param name="indexs">property index with sequence </param>
        /// <param name="separator">separator</param>
        /// <returns>content string</returns>
        public static string GenerateExportText<T>(List<T> dataCollection, List<int> indexs, ExportType exportType)
        {
            if (indexs == null)
            {
                throw new Exception("parameter cannot be null.");
            }

            Dictionary<string, string> columnInfos = new Dictionary<string, string>();
            var columns = ReflectionUtil.GetPropertyNames(dataCollection[0]);
            for (int i = 0; i < indexs.Count; i++)
            {
                columnInfos.Add(columns[indexs[i]], columns[indexs[i]]);
            }

            return GenerateExportText(dataCollection, columnInfos, exportType);
        }

        /// <summary>
        /// Export by template property index list with sequence
        /// </summary>
        /// <typeparam name="T">template</typeparam>
        /// <param name="dataCollection">template collection</param>
        /// <param name="indexs">property index with sequence </param>
        /// <param name="titles">title of the property with sequence</param>
        /// <param name="separator">separator</param>
        /// <returns>content string</returns>
        public static string GenerateExportText<T>(List<T> dataCollection, List<int> indexs, List<string> titles, ExportType exportType)
        {
            if (indexs == null || titles == null)
            {
                throw new Exception("parameter cannot be null.");
            }

            if (indexs.Count != titles.Count)
            {
                throw new Exception("index count not equal the titles count.");
            }

            Dictionary<string, string> columnInfos = new Dictionary<string, string>();
            var columns = ReflectionUtil.GetPropertyNames(typeof(T));
            for (int i = 0; i < indexs.Count; i++)
            {
                columnInfos.Add(titles[i], columns[indexs[i]]);
            }

            return GenerateExportText(dataCollection, columnInfos, exportType);
        }

        /// <summary>
        /// Export by template with all property name as the titles
        /// </summary>
        /// <typeparam name="T">template</typeparam>
        /// <param name="dataCollection">template collection</param>
        /// <param name="separator">separator</param>
        /// <returns>content string</returns>
        public static string GenerateExportText<T>(List<T> dataCollection, ExportType exportType)
        {
            Dictionary<string, string> columnInfos = new Dictionary<string, string>();
            var columns = ReflectionUtil.GetPropertyNames(dataCollection[0]);
            foreach (var item in columns)
            {
                columnInfos.Add(item, item);
            }

            return GenerateExportText(dataCollection, columnInfos, exportType);
        }

        /// <summary>
        /// Export by template with (title,property)
        /// </summary>
        /// <typeparam name="T">template</typeparam>
        /// <param name="dataCollection">template collection</param>
        /// <param name="columnInfos">(title,property) collection</param>
        /// <param name="separator">separator</param>
        /// <returns>content string</returns>
        public static string GenerateExportText<T>(List<T> dataCollection, Dictionary<string, string> columnInfos, ExportType exportType)
        {
            StringBuilder fullText = new StringBuilder();
            var headers = columnInfos.Select(p => p.Key);

            string separator = string.Empty;
            switch (exportType)
            {
                case ExportType.TxtFile:
                    separator = "	";
                    break;
                case ExportType.CsvFile:
                    separator = ",";
                    break;
                case ExportType.NoSeparator:
                    separator = "";
                    break;
                case ExportType.Space:
                    separator = " ";
                    break;
            }

            //add title
            fullText.AppendLine(string.Join(separator, headers));

            if (dataCollection == null)
            {
                return fullText.ToString();
            }

            Dictionary<string, Func<object, object>> delegateMap = new Dictionary<string, Func<object, object>>();
            Type dataType = typeof(T);

            foreach (var pair in columnInfos)
            {
                string propertyName = pair.Value;
                delegateMap.Add(propertyName, ReflectionUtil.GetPropertySetFunc(dataType, propertyName));
            }

            foreach (var data in dataCollection)
            {
                List<string> values = new List<string>();

                foreach (var pair in columnInfos)
                {
                    string propertyName = pair.Value;
                    var getValueFunc = delegateMap[propertyName];
                    values.Add(getValueFunc.Invoke(data).ToString());
                }

                //add value
                fullText.AppendLine(string.Join(separator, values));
            }

            return fullText.ToString();
        }

        /// <summary>
        /// genetate file
        /// </summary>
        /// <param name="content"></param>
        /// <param name="path"></param>
        public static void GenerateExportFile(string content, string path)
        {
            File.WriteAllText(path, content, Encoding.Default);
        }

        /// <summary>
        /// generate file with encoding type
        /// </summary>
        /// <param name="content"></param>
        /// <param name="path"></param>
        /// <param name="encoding"></param>
        public static void GenerateExportFile(string content, string path, Encoding encoding)
        {
            if ((path + "").Trim().Length == 0)
            {
                throw new Exception("path of generated cannot be empty.");
            }

            if (!Directory.Exists(Path.GetDirectoryName(path)))
            {
                Directory.CreateDirectory(Path.GetDirectoryName(path));
            }

            File.WriteAllText(path, content, encoding);
        }
    }

5.使用举例：Demon

　　5.1 对于表：AutoDivInsertBulkLoaderInfo

    public class AutoDivInsertBulkLoaderInfo
    {
        public string RicEventType { get; set; }//key of the table}
        public string URL { get; set; }
        public string AnnualOrSemiAnnualReport { get; set; }
        public string RIC { get; set; }
        public string DVP_TYPE { get; set; }
        public string CLA_EVENT_STATUS { get; set; }
        public string FPE_PERIOD_END { get; set; }
        public string FPE_PERIOD_LENGTH { get; set; }
        public string DIVIDEND_AMOUNT { get; set; }
        public string ANNOUNCEMENT_DATE { get; set; }
        public string PAY_DATE { get; set; }
        public string RECORD_DATE { get; set; }
        public string EX_DATE { get; set; }
        public string PAYDATE_DAY_SET { get; set; }
        public string PAID_AS_PERCENT { get; set; }
        public string CLA_CUR_VAL { get; set; }
        public string QDI_PERCENT { get; set; }
        public string DESCRIPTION { get; set; }
        public string CLA_MEETING_TYPE_VAL { get; set; }
        public string MEETING_DATE { get; set; }
        public string CLA_TAX_STATUS_VAL { get; set; }
        public string TAX_RATE_PERCENT { get; set; }
        public string FOREIGN_INVESTOR_TAX_RATE { get; set; }
        public string SOURCE_TYPE { get; set; }
        public string RELEASE_DATE { get; set; }
        public string LOCAL_DATE { get; set; }
        public string TIMEZONE_NAME { get; set; }
        public string SOURCE_PROVIDER { get; set; }
        public string BRIDGE_SYMBOL { get; set; }
        public string SEQ_NUM { get; set; }
        public string CLA_RECORD_STATUS { get; set; }
        public string FPE_PERIOD_LENGTH_INDICATOR { get; set; }
        public string CLA_DIV_MARKER_VAL { get; set; }
        public string CLA_DIV_FREQ_VAL { get; set; }
        public string PID_QUARTER { get; set; }
        public string PID_YEAR { get; set; }
        public string PID { get; set; }
        public string CLA_TEXT_TYPE { get; set; }
        public string CLA_DIV_FEATURES_VAL { get; set; }
        public string TAX_CREDIT_PERCENT { get; set; }
        public string CLA_TAX_TRTMNT_MKR_VAL { get; set; }
        public string RESCINDED { get; set; }
        public string CAC_MA_COMMENTS { get; set; }
        public string FRANKED_PERCENT { get; set; }
        public string REINVESTMENT_PLAN_AVAILABLE { get; set; }
        public string REINVESTMENT_DEADLINE { get; set; }
        public string REINVESTMENT_PRICE { get; set; }
        public string CLA_SOURCE_OF_FUND { get; set; }
        public string CLA_DIV_RANKING { get; set; }
        public string DIVIDEND_RANKING_DATE { get; set; }
        public string BOOKCLOSURE_START_DATE { get; set; }
        public string BOOKCLOSURE_END_DATE { get; set; }
        public string MODIFIED { get; set; }
        public string SOURCE_ID { get; set; }
        public string SOURCE_LINK { get; set; }
        public string SOURCE_DESCRIPTION { get; set; }

        public AutoDivInsertBulkLoaderInfo()
        {
            //this.RicEventType = string.Empty;//key
            this.URL = string.Empty;
            this.AnnualOrSemiAnnualReport = string.Empty;
            //this.RIC = string.Empty;
            //this.DVP_TYPE = string.Empty;
            this.CLA_EVENT_STATUS = string.Empty;
            this.FPE_PERIOD_END = string.Empty;
            this.FPE_PERIOD_LENGTH = string.Empty;
            this.DIVIDEND_AMOUNT = string.Empty;
            this.ANNOUNCEMENT_DATE = string.Empty;
            this.PAY_DATE = string.Empty;
            this.RECORD_DATE = string.Empty;
            this.EX_DATE = string.Empty;
            this.PAYDATE_DAY_SET = string.Empty;
            this.PAID_AS_PERCENT = string.Empty;
            this.CLA_CUR_VAL = string.Empty;
            this.QDI_PERCENT = string.Empty;
            this.DESCRIPTION = string.Empty;
            this.CLA_MEETING_TYPE_VAL = string.Empty;
            this.MEETING_DATE = string.Empty;
            this.CLA_TAX_STATUS_VAL = string.Empty;
            this.TAX_RATE_PERCENT = string.Empty;
            this.FOREIGN_INVESTOR_TAX_RATE = string.Empty;
            this.SOURCE_TYPE = string.Empty;
            this.RELEASE_DATE = string.Empty;
            this.LOCAL_DATE = string.Empty;
            this.TIMEZONE_NAME = string.Empty;
            this.SOURCE_PROVIDER = string.Empty;
            this.BRIDGE_SYMBOL = string.Empty;
            this.SEQ_NUM = string.Empty;
            this.CLA_RECORD_STATUS = string.Empty;
            this.FPE_PERIOD_LENGTH_INDICATOR = string.Empty;
            this.CLA_DIV_MARKER_VAL = string.Empty;
            this.CLA_DIV_FREQ_VAL = string.Empty;
            this.PID_QUARTER = string.Empty;
            this.PID_YEAR = string.Empty;
            this.PID = string.Empty;
            this.CLA_TEXT_TYPE = string.Empty;
            this.CLA_DIV_FEATURES_VAL = string.Empty;
            this.TAX_CREDIT_PERCENT = string.Empty;
            this.CLA_TAX_TRTMNT_MKR_VAL = string.Empty;
            this.RESCINDED = string.Empty;
            this.CAC_MA_COMMENTS = string.Empty;
            this.FRANKED_PERCENT = string.Empty;
            this.REINVESTMENT_PLAN_AVAILABLE = string.Empty;
            this.REINVESTMENT_DEADLINE = string.Empty;
            this.REINVESTMENT_PRICE = string.Empty;
            this.CLA_SOURCE_OF_FUND = string.Empty;
            this.CLA_DIV_RANKING = string.Empty;
            this.DIVIDEND_RANKING_DATE = string.Empty;
            this.BOOKCLOSURE_START_DATE = string.Empty;
            this.BOOKCLOSURE_END_DATE = string.Empty;
            this.MODIFIED = string.Empty;
            this.SOURCE_ID = string.Empty;
            this.SOURCE_LINK = string.Empty;
            this.SOURCE_DESCRIPTION = string.Empty;
        }
    }

　　5.2 需求导出从URL开始(第2个属性)按升顺方式将AutoDivInsertBulkLoaderInfo所有属性的值导出，且属性AnnualOrSemiAnnualReport的Title改为

　　”Annual/Semi-annual Report“，其他Title 等于默认属性名。

        private void GenerateAutoDivInsertBulkLoaderBulkFile(List<AutoDivInsertBulkLoaderInfo> autoinsertBulkFile)
        {
            if (autoinsertBulkFile == null || autoinsertBulkFile.Count == 0)
            {
                Logger.Log("autoinsertBulkFile collection is empty, neednot to generate autoinsertBulkFile.csv file.", Logger.LogType.Warning);
                return;
            }

            Dictionary<string, string> titles = new Dictionary<string, string>();
            var property = Ric.Util.ReflectionUtil.GetPropertyNames(autoinsertBulkFile[0]);
            for (int i = 0; i < property.Count; i++)
            {
                if (i == 0)
                    continue;

                if (i == 2)
                    titles.Add("Annual/Semi-annual Report", property[i]);
                else
                    titles.Add(property[i], property[i]);
            }

            string path = Path.Combine(resultPath, DateTime.Now.ToString("dd-MM-yyyy"));
            string fileName = Path.Combine(path, string.Format("AUTO_DIV_Insert_Bulk_Loader_{0}.csv", DateTime.Now.ToString("dd-MM-yyyy")));
            CollectionExportUtil.GenerateExportFile(CollectionExportUtil.GenerateExportText(autoinsertBulkFile, titles, ExportType.CsvFile), fileName);
        }