private static Dictionary <PropertyInfo, int> InitTxtToEntityMapper <T>(Dictionary <string, object> propertyMatch = null, TxtTypeEnum typeEnum = TxtTypeEnum.Normal) where T : class { int propertyIndex = 0; Dictionary <PropertyInfo, int> propertyDict = new Dictionary <PropertyInfo, int>(); ReflectionGenericHelper.Foreach <T>((PropertyInfo propertyInfo) => { if (propertyMatch != null && propertyMatch.ContainsKey(propertyInfo.Name)) { propertyDict.Add(propertyInfo, int.Parse(propertyMatch[propertyInfo.Name].ToString())); } else { if (typeEnum == TxtTypeEnum.Attribute) { TxtTAttribute attribute = propertyInfo.GetCustomAttribute <TxtTAttribute>(); if (attribute != null && (attribute.Type == AttributeReadAndWriteTypeEnum.ReadAndWrite || attribute.Type == AttributeReadAndWriteTypeEnum.Read)) { propertyDict.Add(propertyInfo, attribute.Index); } } else { propertyDict.Add(propertyInfo, propertyIndex); propertyIndex++; } } }); return(propertyDict); }
private static T HtmlNodeToEntity <T>(HtmlNode htmlNode, int index, Dictionary <string, List <HtmlNode> > nodeDict, dynamic propertySetDict, Dictionary <PropertyInfo, HtmlAttributeMapperItem> attributeMapperDict) where T : class, new() { T t = ReflectionGenericHelper.New <T>(); HtmlNode dataNode = htmlNode; foreach (var keyValueItem in attributeMapperDict) { if (nodeDict != null && nodeDict.ContainsKey(keyValueItem.Key.Name)) { dataNode = nodeDict[keyValueItem.Key.Name][index]; } string attributeValue = GetNodeText(dataNode, keyValueItem.Value.AttributeName, keyValueItem.Value.AttributeEnum); if (!string.IsNullOrEmpty(attributeValue)) { if (propertySetDict != null && propertySetDict.ContainsKey(keyValueItem.Key.Name)) { ReflectionGenericHelper.SetPropertyValue(propertySetDict[keyValueItem.Key.Name], t, attributeValue, keyValueItem.Key); } else { ReflectionHelper.SetPropertyValue(t, attributeValue, keyValueItem.Key); } } } return(t); }
internal static T ExecuteGetCookie <T>(HttpRequestBase httpRequest, string cookieName, Dictionary <string, object> propertyDict, ReflectionTypeEnum reflectionType = ReflectionTypeEnum.Expression) where T : class, new() { HttpCookie httpCookie = GetHttpCookie(httpRequest, cookieName); if (httpCookie == null) { return(null); } Dictionary <PropertyInfo, string> mapperDict = CommonHelper.InitPropertyReadMapper <T, CookieTAttribute>(propertyDict, (name) => httpCookie.Values[name] != null); dynamic propertySetDict = null; if (reflectionType != ReflectionTypeEnum.Original) { propertySetDict = ReflectionExtendHelper.PropertySetCallDict <T>(reflectionType); } T t = ReflectionGenericHelper.New <T>(); foreach (var keyValueItem in mapperDict) { if (propertySetDict != null && propertySetDict.ContainsKey(keyValueItem.Key.Name)) { ReflectionGenericHelper.SetPropertyValue(propertySetDict[keyValueItem.Key.Name], t, HttpUtility.UrlDecode(httpCookie[keyValueItem.Value]), keyValueItem.Key); } else { ReflectionHelper.SetPropertyValue(t, HttpUtility.UrlDecode(httpCookie[keyValueItem.Value]), keyValueItem.Key); } } return(t); }
/// <summary> /// 获取类属性的设置值委托列表 /// </summary> /// <param name="type">Type</param> /// <param name="reflectionType">反射类型</param> /// <returns></returns> public static dynamic PropertySetCallDict(Type type, ReflectionTypeEnum reflectionType = ReflectionTypeEnum.Expression) { return(ExecutePropertySetCall(type, () => { return ReflectionGenericHelper.PropertySetCallDict(type, reflectionType); }, reflectionType)); }
/// <summary> /// 获取类属性的设置值委托 /// </summary> /// <param name="type">Type</param> /// <param name="propertyName">属性名称</param> /// <param name="reflectionType">反射类型</param> /// <returns></returns> public static dynamic PropertySetCall(Type type, string propertyName, ReflectionTypeEnum reflectionType = ReflectionTypeEnum.Expression) { return(ExecutePropertySetCall(type, propertyName, () => { return ReflectionGenericHelper.PropertySetCall(type, type.GetProperty(propertyName), reflectionType); }, reflectionType)); }
/// <summary> /// 获取类属性的获取值委托 /// </summary> /// <param name="type">Type</param> /// <param name="propertyInfo">PropertyInfo</param> /// <param name="reflectionType">反射类型</param> /// <returns></returns> public static dynamic PropertyGetCall(Type type, PropertyInfo propertyInfo, ReflectionTypeEnum reflectionType = ReflectionTypeEnum.Expression) { return(ExecutePropertyGetCall(type, propertyInfo.Name, () => { return ReflectionGenericHelper.PropertyGetCall(type, propertyInfo, reflectionType); }, reflectionType)); }
private static Dictionary <PropertyInfo, HtmlAttributeMapperItem> GetAttributeMapperDict <T>(object propertyMatchList) where T : class { Dictionary <string, object> propertyMatchDict = CommonHelper.GetParameterDict(propertyMatchList); Dictionary <PropertyInfo, HtmlAttributeMapperItem> propertyDict = new Dictionary <PropertyInfo, HtmlAttributeMapperItem>(); ReflectionGenericHelper.Foreach <T>((PropertyInfo propertyInfo) => { HtmlAttributeMapperItem mapperItem = new HtmlAttributeMapperItem(); if (propertyMatchDict != null && propertyMatchDict.ContainsKey(propertyInfo.Name)) { mapperItem.AttributeName = propertyMatchDict[propertyInfo.Name].ToString(); mapperItem.AttributeEnum = HtmlAnalysisAttributeEnum.Attribute; } else { HtmlAnalysisTAttribute attribute = propertyInfo.GetCustomAttribute <HtmlAnalysisTAttribute>(); if (attribute != null) { mapperItem.AttributeName = attribute.Name; mapperItem.AttributeEnum = attribute.NameType; } else { mapperItem.AttributeName = propertyInfo.Name; mapperItem.AttributeEnum = HtmlAnalysisAttributeEnum.Attribute; } } propertyDict.Add(propertyInfo, mapperItem); }); return(propertyDict); }
private static T IRowToEntity <T>(int rowIndex, IRow row, dynamic propertySetDict, Dictionary <PropertyInfo, ExcelToEntityColumnMapper> excelToEntityMapperList, List <ExcelMergeCell> mergeCellList) where T : class, new() { T t = ReflectionGenericHelper.New <T>(); ICell iCell = null; string cellText = null; foreach (var keyValueItem in excelToEntityMapperList) { cellText = GetSheetMergeCellText(mergeCellList, rowIndex, keyValueItem.Value.ColumnIndex); if (cellText == null) { iCell = row.GetCell(keyValueItem.Value.ColumnIndex); if (iCell != null) { cellText = GetCellText(iCell, keyValueItem.Key.PropertyType); } } if (!string.IsNullOrEmpty(cellText)) { if (propertySetDict != null && propertySetDict.ContainsKey(keyValueItem.Key.Name)) { ReflectionGenericHelper.SetPropertyValue(propertySetDict[keyValueItem.Key.Name], t, cellText, keyValueItem.Key); } else { ReflectionHelper.SetPropertyValue(t, cellText, keyValueItem.Key); } } } return(t); }
private static T DocumentToEntity <T>(Document document, dynamic propertySetDict) where T : class, new() { T t = ReflectionGenericHelper.New <T>(); ReflectionGenericHelper.Foreach <T>((PropertyInfo propertyInfo) => { LuceneIndexTAttribute attribute = propertyInfo.GetCustomAttribute <LuceneIndexTAttribute>(); if (attribute != null) { string field = document.Get(propertyInfo.Name); if (!string.IsNullOrEmpty(field)) { if (propertySetDict != null && propertySetDict.ContainsKey(propertyInfo.Name)) { ReflectionGenericHelper.SetPropertyValue(propertySetDict[propertyInfo.Name], t, field, propertyInfo); } else { ReflectionHelper.SetPropertyValue(t, field, propertyInfo); } } } }); return(t); }
private static List <LuceneIndexModel> EntityToLuceneIndexModel <T>(T t, dynamic propertyGetDict, List <string> propertyList) where T : class { List <LuceneIndexModel> modelList = new List <LuceneIndexModel>(); ReflectionGenericHelper.Foreach <T>((PropertyInfo propertyInfo) => { if (propertyList == null || propertyList.IndexOf(propertyInfo.Name) < 0) { object value = null; if (propertyGetDict != null && propertyGetDict.ContainsKey(propertyInfo.Name)) { value = propertyGetDict[propertyInfo.Name](t); } else { value = ReflectionHelper.GetPropertyValue(t, propertyInfo); } LuceneIndexTAttribute attribute = propertyInfo.GetCustomAttribute <LuceneIndexTAttribute>(); if (attribute != null) { LuceneIndexModel model = new LuceneIndexModel() { Name = propertyInfo.Name, Value = value != null ? value.ToString() : "", StoreEnum = GetIndexStoreEnum(attribute.StoreEnum), IndexEnum = GetIndexIndexEnum(attribute.IndexEnum) }; modelList.Add(model); } } }); return(modelList); }
private static List <T> ToEntityListNormal <T>(HtmlDocument htmlDocument, string xPath, List <XPathMatch> xPathMatchList = null, object propertyMatchList = null, ReflectionTypeEnum reflectionType = ReflectionTypeEnum.Expression) where T : class, new() { HtmlNode documentNode = htmlDocument.DocumentNode; if (documentNode == null) { return(null); } List <T> dataList = new List <T>(); dynamic propertySetDict = null; if (reflectionType != ReflectionTypeEnum.Original) { propertySetDict = ReflectionExtendHelper.PropertySetCallDict <T>(reflectionType); } Dictionary <PropertyInfo, HtmlAttributeMapperItem> attributeMapperDict = GetAttributeMapperDict <T>(propertyMatchList); HtmlNodeCollection htmlNodeCollection = documentNode.SelectNodes(xPath); if (htmlNodeCollection == null || htmlNodeCollection.Count == 0) { return(null); } Dictionary <PropertyInfo, XPathMatch> propertyInfoXPathDict = new Dictionary <PropertyInfo, XPathMatch>(); XPathMatch matchItem = null; foreach (HtmlNode htmlNode in htmlNodeCollection) { T t = new T(); ReflectionGenericHelper.Foreach <T>((PropertyInfo propertyInfo) => { matchItem = null; if (propertyInfoXPathDict.ContainsKey(propertyInfo)) { matchItem = propertyInfoXPathDict[propertyInfo]; } else { matchItem = xPathMatchList.Where(p => p.PropertyName == propertyInfo.Name).FirstOrDefault(); if (matchItem != null) { propertyInfoXPathDict.Add(propertyInfo, matchItem); } } if (matchItem != null) { HtmlNode childHtmlNode = htmlNode.SelectSingleNode(matchItem.XPath); SetEntityValue <T>(t, childHtmlNode, propertyInfo, attributeMapperDict[propertyInfo], propertySetDict); } }); dataList.Add(t); } return(dataList); }
/// <summary> /// 获取类属性的设置值委托列表 /// </summary> /// <typeparam name="T">实体类型</typeparam> /// <param name="reflectionType">反射类型</param> /// <returns></returns> public static dynamic PropertySetCallDict <T>(ReflectionTypeEnum reflectionType = ReflectionTypeEnum.Expression) where T : class { Type type = typeof(T); return(ExecutePropertySetCall(type, () => { return ReflectionGenericHelper.PropertySetCallDict <T>(reflectionType); }, reflectionType)); }
/// <summary> /// 获取类属性的设置值委托 /// </summary> /// <typeparam name="T">实体类型</typeparam> /// <param name="propertyName">属性名称</param> /// <param name="reflectionType">反射类型</param> /// <returns></returns> public static dynamic PropertySetCall <T>(string propertyName, ReflectionTypeEnum reflectionType = ReflectionTypeEnum.Expression) where T : class { Type type = typeof(T); return(ExecutePropertySetCall(type, propertyName, () => { return ReflectionGenericHelper.PropertySetCall <T>(type.GetProperty(propertyName), reflectionType); }, reflectionType)); }
/// <summary> /// 获取类属性的获取值委托 /// </summary> /// <typeparam name="T">实体类型</typeparam> /// <param name="propertyInfo">PropertyInfo</param> /// <param name="reflectionType">反射类型</param> /// <returns></returns> public static dynamic PropertyGetCall <T>(PropertyInfo propertyInfo, ReflectionTypeEnum reflectionType = ReflectionTypeEnum.Expression) where T : class { Type type = typeof(T); return(ExecutePropertyGetCall(type, propertyInfo.Name, () => { return ReflectionGenericHelper.PropertyGetCall <T>(propertyInfo, reflectionType); }, reflectionType)); }
public static List <string> GetFilterNameList <T>(List <string> filterNameList, bool filterPropertyContain) where T : class { if (filterNameList == null) { filterNameList = ReflectionGenericHelper.GetPropertyNameList <T>(); } else { if (!filterPropertyContain) { filterNameList = ReflectionGenericHelper.GetPropertyNameList <T>().Except <string>(filterNameList).ToList(); } } return(filterNameList); }
private static void SetEntityValue <T>(T t, HtmlNode htmlNode, PropertyInfo propertyInfo, HtmlAttributeMapperItem mapperItem, dynamic propertySetDict) where T : class { string attributeValue = GetNodeText(htmlNode, mapperItem.AttributeName, mapperItem.AttributeEnum); if (!string.IsNullOrEmpty(attributeValue)) { if (propertySetDict != null && propertySetDict.ContainsKey(propertyInfo.Name)) { ReflectionGenericHelper.SetPropertyValue(propertySetDict[propertyInfo.Name], t, attributeValue, propertyInfo); } else { ReflectionHelper.SetPropertyValue(t, attributeValue, propertyInfo); } } }
/// <summary> /// 复制数据 /// </summary> /// <typeparam name="T">实体类型</typeparam> /// <typeparam name="K">拥有索引器的实体类型</typeparam> /// <typeparam name="P">索引器参数类型,例:int</typeparam> /// <typeparam name="R">索引器返回类型,例:string</typeparam> /// <param name="originalData">原实体数据</param> /// <param name="propertyMatchList">属性匹配,例:new { ID = "UserID" }</param> /// <param name="reflectionType">反射类型</param> /// <returns></returns> public static T Copy <T, K, P, R>(K originalData, object propertyMatchList = null, ReflectionTypeEnum reflectionType = ReflectionTypeEnum.Expression) where T : class, new() where K : class { T t = ReflectionGenericHelper.New <T>(); Func <K, P, object> indexCall = ReflectionGenericHelper.PropertyIndexGetCall <K, P, R>(reflectionType); Dictionary <PropertyInfo, string> propertyMatchDict = InitPropertyMatchMapper(originalData.GetType(), typeof(T), propertyMatchList, null); foreach (var keyValueItem in propertyMatchDict) { P indexName = (P)Convert.ChangeType(keyValueItem.Value, typeof(P), CultureInfo.InvariantCulture); ReflectionHelper.SetPropertyValue(t, indexCall(originalData, indexName).ToString(), keyValueItem.Key); } return(t); }
private static Dictionary <string, EntityToXmlMapper> InitEntityToXmlMapper <T>(T t, dynamic propertyGetDict, List <string> propertyList) where T : class { Dictionary <string, EntityToXmlMapper> mapperDict = new Dictionary <string, EntityToXmlMapper>(); string propertyValue = null; XmlTAttribute attribute = null; ReflectionGenericHelper.Foreach <T>((PropertyInfo propertyInfo) => { if (propertyList == null || propertyList.IndexOf(propertyInfo.Name) >= 0) { if (propertyGetDict != null && propertyGetDict.ContainsKey(propertyInfo.Name)) { propertyValue = propertyGetDict[propertyInfo.Name](t).ToString(); } else { propertyValue = ReflectionHelper.GetPropertyValue(t, propertyInfo).ToString(); } attribute = propertyInfo.GetCustomAttribute <XmlTAttribute>(); if (attribute != null) { if (!string.IsNullOrEmpty(attribute.Name)) { mapperDict.Add(attribute.Name, new EntityToXmlMapper() { Value = propertyValue, ValueEnum = attribute.NameType }); } else { mapperDict.Add(propertyInfo.Name, new EntityToXmlMapper() { Value = propertyValue, ValueEnum = attribute.NameType }); } } else { mapperDict.Add(propertyInfo.Name, new EntityToXmlMapper() { Value = propertyValue, ValueEnum = XmlTEnum.Attribute }); } } }); return(mapperDict); }
internal static List <T> SheetEntityList <T>(Workbook workbook, string sheetName, Dictionary <string, string> propertyDict = null, int headerIndex = 0, int dataIndex = 1, ReflectionTypeEnum reflectionType = ReflectionTypeEnum.Expression) where T : class, new() { List <T> dataList = new List <T>(); Worksheet sheet = workbook.Worksheets[sheetName]; Cells cellList = sheet.Cells; Dictionary <int, TExcelToEntityColumnMapper> excelToEntityMapperList = InitExcelToEntityMapper <T>(headerIndex, cellList, propertyDict); dynamic propertySetDict = null; if (reflectionType != ReflectionTypeEnum.Original) { propertySetDict = ReflectionExtendHelper.PropertySetCallDict <T>(reflectionType); } int rowCount = cellList.MaxDataRow + 1; int cellCount = cellList.MaxColumn + 1; for (int index = dataIndex; index < rowCount; index++) { T t = new T(); for (int cellIndex = 0; cellIndex < cellCount; cellIndex++) { if (excelToEntityMapperList.ContainsKey(cellIndex)) { TExcelToEntityColumnMapper columnMapper = excelToEntityMapperList[cellIndex]; Cell cell = cellList[index, cellIndex]; if (cell != null && cell.Value != null) { if (propertySetDict != null && propertySetDict.ContainsKey(columnMapper.ColumnPropertyName)) { ReflectionGenericHelper.SetPropertyValue(propertySetDict[columnMapper.ColumnPropertyName], t, cell.StringValue, columnMapper.ColumnPropertyInfo); } else { ReflectionHelper.SetPropertyValue(t, cell.StringValue, columnMapper.ColumnPropertyInfo); } } } } dataList.Add(t); } return(dataList); }
private static Dictionary <int, PropertyInfo> InitEntityToTxtMapper <T>(object propertyMatchList = null, TxtTypeEnum typeEnum = TxtTypeEnum.Normal, string[] propertyList = null, bool propertyContain = true) where T : class { List <string> filterNameList = null; if (propertyList != null) { filterNameList = propertyList.ToList <string>(); } int propertyIndex = 0; Dictionary <string, object> propertyMatchDict = CommonHelper.GetParameterDict(propertyMatchList); Dictionary <int, PropertyInfo> propertyNameDict = new Dictionary <int, PropertyInfo>(); ReflectionGenericHelper.Foreach <T>((PropertyInfo propertyInfo) => { if (filterNameList == null || (propertyContain && filterNameList.IndexOf(propertyInfo.Name) >= 0) || (!propertyContain && filterNameList.IndexOf(propertyInfo.Name) < 0)) { if (propertyMatchDict != null && propertyMatchDict.ContainsKey(propertyInfo.Name)) { propertyNameDict.Add(int.Parse(propertyMatchDict[propertyInfo.Name].ToString()), propertyInfo); } else { if (typeEnum == TxtTypeEnum.Attribute) { TxtTAttribute attribute = propertyInfo.GetCustomAttribute <TxtTAttribute>(); if (attribute != null && (attribute.Type == AttributeReadAndWriteTypeEnum.ReadAndWrite || attribute.Type == AttributeReadAndWriteTypeEnum.Write)) { object attributeIndex = ReflectionExtendHelper.GetAttributeValue <TxtTAttribute>(typeof(T), propertyInfo, p => p.Index); if (attributeIndex != null) { propertyNameDict.Add(int.Parse(attributeIndex.ToString()), propertyInfo); } } } else { propertyNameDict.Add(propertyIndex, propertyInfo); propertyIndex++; } } } }); return(propertyNameDict); }
private static Dictionary <PropertyInfo, string> InitDbToEntityMapper <T>(DbDataReader reader, object propertyMatchList = null) where T : class { Dictionary <PropertyInfo, string> resultDict = new Dictionary <PropertyInfo, string>(); if (propertyMatchList != null) { Dictionary <string, object> propertyMatchDict = CommonHelper.GetParameterDict(propertyMatchList); ReflectionGenericHelper.Foreach <T>((PropertyInfo propertyInfo) => { string columnName = propertyInfo.Name; object propertyValue = propertyMatchDict[propertyInfo.Name]; if (propertyValue != null) { columnName = propertyValue.ToString(); } resultDict.Add(propertyInfo, columnName); }); return(resultDict); } string key = typeof(T).FullName; if (PropertyAttributeDict.ContainsKey(key)) { return(PropertyAttributeDict[key]); } lock (lockItem) { ReflectionGenericHelper.Foreach <T>((PropertyInfo propertyInfo) => { string columnName = ReflectionExtendHelper.GetAttributeValue <DataBaseTAttribute>(typeof(T), propertyInfo, p => p.Name); if (string.IsNullOrEmpty(columnName)) { columnName = propertyInfo.Name; } resultDict.Add(propertyInfo, columnName); }); if (!PropertyAttributeDict.ContainsKey(key)) { PropertyAttributeDict.Add(key, resultDict); } return(resultDict); } }
internal static Dictionary <string, PropertyInfo> InitPropertyWriteMapperFormat <T, K>(Dictionary <string, object> propertyDict = null, List <string> filterNameList = null, bool filterPropertyContain = true) where T : class where K : BaseReadAndWriteTAttribute { Dictionary <string, PropertyInfo> resultDict = new Dictionary <string, PropertyInfo>(); ReflectionGenericHelper.Foreach <T>((PropertyInfo propertyInfo) => { if (filterNameList == null || (filterPropertyContain && filterNameList.IndexOf(propertyInfo.Name) >= 0) || (!filterPropertyContain && filterNameList.IndexOf(propertyInfo.Name) < 0)) { string attributeName = null; if (propertyDict != null && propertyDict.ContainsKey(propertyInfo.Name)) { attributeName = propertyDict[propertyInfo.Name].ToString(); } else { K k = propertyInfo.GetCustomAttribute <K>(); if (k != null) { if (k.Type == AttributeReadAndWriteTypeEnum.ReadAndWrite || k.Type == AttributeReadAndWriteTypeEnum.Write) { if (!string.IsNullOrEmpty(k.Name)) { attributeName = k.Name; } else { attributeName = propertyInfo.Name; } } } else { attributeName = propertyInfo.Name; } } if (!string.IsNullOrEmpty(attributeName)) { resultDict.Add(attributeName, propertyInfo); } } }); return(resultDict); }
public static Dictionary <PropertyInfo, string> InitPropertyReadMapper <T, K>(Dictionary <string, object> propertyDict, Func <string, bool> callback) where T : class where K : BaseReadAndWriteTAttribute { Dictionary <PropertyInfo, string> resultDict = new Dictionary <PropertyInfo, string>(); ReflectionGenericHelper.Foreach <T>((PropertyInfo propertyInfo) => { string mapperName = null; if (propertyDict != null && propertyDict.ContainsKey(propertyInfo.Name)) { mapperName = propertyDict[propertyInfo.Name].ToString(); } else { K attribute = propertyInfo.GetCustomAttribute <K>(); if (attribute != null) { if (attribute.Type == AttributeReadAndWriteTypeEnum.ReadAndWrite || attribute.Type == AttributeReadAndWriteTypeEnum.Read) { if (!string.IsNullOrEmpty(attribute.Name)) { mapperName = attribute.Name; } else { mapperName = propertyInfo.Name; } } } else { mapperName = propertyInfo.Name; } } if (mapperName != null && callback(mapperName)) { resultDict.Add(propertyInfo, mapperName); } }); return(resultDict); }
private static T DataReaderToEntity <T>(DbDataReader reader, dynamic propertySetDict, List <string> columnNameList, Dictionary <PropertyInfo, string> columnNameDict) where T : class, new() { T t = ReflectionGenericHelper.New <T>(); foreach (var keyValueItem in columnNameDict) { if (columnNameList.IndexOf(keyValueItem.Value) >= 0) { if (propertySetDict != null && propertySetDict.ContainsKey(keyValueItem.Key.Name)) { ReflectionGenericHelper.SetPropertyValue(propertySetDict[keyValueItem.Key.Name], t, reader[keyValueItem.Value].ToString(), keyValueItem.Key); } else { ReflectionHelper.SetPropertyValue(t, reader[keyValueItem.Value].ToString(), keyValueItem.Key); } } } return(t); }
private static T DataRowToEntity <T>(DataRow dataRow, dynamic propertySetDict, Dictionary <PropertyInfo, string> columnNameDict) where T : class, new() { T t = ReflectionGenericHelper.New <T>(); foreach (var keyValueItem in columnNameDict) { if (dataRow[keyValueItem.Value] != null) { if (propertySetDict != null && propertySetDict.ContainsKey(keyValueItem.Key.Name)) { ReflectionGenericHelper.SetPropertyValue(propertySetDict[keyValueItem.Key.Name], t, dataRow[keyValueItem.Value].ToString(), keyValueItem.Key); } else { ReflectionHelper.SetPropertyValue(t, dataRow[keyValueItem.Value].ToString(), keyValueItem.Key); } } } return(t); }
private static T TextToEntity <T>(string text, string splitChar, dynamic propertySetDict, Dictionary <PropertyInfo, int> propertyNameDict) where T : class, new() { // 按分隔符拆分文本内容 string[] dataList = text.Split(new string[] { splitChar }, StringSplitOptions.None); T t = ReflectionGenericHelper.New <T>(); foreach (var keyValueItem in propertyNameDict) { if (keyValueItem.Value >= 0 && keyValueItem.Value < dataList.Length) { // 设置实体对象属性数据 if (propertySetDict != null && propertySetDict.ContainsKey(keyValueItem.Key.Name)) { ReflectionGenericHelper.SetPropertyValue(propertySetDict[keyValueItem.Key.Name], t, dataList[keyValueItem.Value], keyValueItem.Key); } else { ReflectionHelper.SetPropertyValue(t, dataList[keyValueItem.Value], keyValueItem.Key); } } } return(t); }
private static object CopyData(object targetData, dynamic propertySetDict, dynamic propertyGetDict, Dictionary <PropertyInfo, string> propertyMatchDict, dynamic originalData, object propertyMatch = null, object propertyIgnore = null, ReflectionTypeEnum reflectionType = ReflectionTypeEnum.Expression) { if (originalData == null) { return(targetData); } PropertyInfo propertyInfo = null; dynamic propertyValue = null; foreach (var keyValueItem in propertyMatchDict) { propertyInfo = keyValueItem.Key; if (propertyGetDict != null && propertyGetDict.ContainsKey(keyValueItem.Value)) { propertyValue = propertyGetDict[keyValueItem.Value](originalData); } else { propertyValue = ReflectionHelper.GetPropertyValue(originalData, keyValueItem.Value); } if (propertyValue != null) { if (ReflectionHelper.IsListType(propertyInfo.PropertyType)) { Type originalTType = ReflectionHelper.GetListGenericType(originalData.GetType().GetProperty(keyValueItem.Value)); var originalPropertyMatchValue = ReflectionHelper.GetPropertyValue(propertyMatch, propertyInfo.Name); var originalPropertyIgnoreValue = ReflectionHelper.GetPropertyValue(propertyIgnore, propertyInfo.Name); var originalPropertyValue = ReflectionHelper.GetPropertyValue(targetData, propertyInfo) as IList; Type listTType = ReflectionHelper.GetListGenericType(propertyInfo); var objectDataList = ReflectionHelper.NewList(listTType) as IList; dynamic listPropertySetDict = null; if (reflectionType != ReflectionTypeEnum.Original) { listPropertySetDict = ReflectionExtendHelper.PropertySetCallDict(listTType, reflectionType); } dynamic listPropertyGetDict = null; if (reflectionType != ReflectionTypeEnum.Original) { listPropertyGetDict = ReflectionExtendHelper.PropertyGetCallDict(originalTType, reflectionType); } for (int index = 0; index < propertyValue.Count; index++) { if (originalPropertyValue != null && index < originalPropertyValue.Count) { objectDataList.Add(CopyData(originalPropertyValue[index], listPropertySetDict, listPropertyGetDict, InitPropertyMatchMapper(originalTType, listTType, originalPropertyMatchValue, originalPropertyIgnoreValue), propertyValue[index], originalPropertyMatchValue, originalPropertyIgnoreValue, reflectionType)); } else { objectDataList.Add(CopyData(listTType, listPropertySetDict, listPropertyGetDict, InitPropertyMatchMapper(originalTType, listTType, originalPropertyMatchValue, originalPropertyIgnoreValue), propertyValue[index], originalPropertyMatchValue, originalPropertyIgnoreValue, reflectionType)); } } targetData.GetType().GetProperty(propertyInfo.Name).SetValue(targetData, objectDataList, null); } else if (ReflectionHelper.IsCustomType(propertyInfo.PropertyType)) { var originalPropertyMatchValue = ReflectionHelper.GetPropertyValue(propertyMatch, propertyInfo.Name); var originalPropertyIgnoreValue = ReflectionHelper.GetPropertyValue(propertyIgnore, propertyInfo.Name); var originalPropertyValue = ReflectionHelper.GetPropertyValue(targetData, propertyInfo); if (originalPropertyValue == null) { targetData.GetType().GetProperty(propertyInfo.Name).SetValue(targetData, CopyData(propertyInfo.PropertyType, null, null, InitPropertyMatchMapper(propertyValue.GetType(), propertyInfo.PropertyType, originalPropertyMatchValue, originalPropertyIgnoreValue), propertyValue, originalPropertyMatchValue, originalPropertyIgnoreValue, reflectionType), null); } else { targetData.GetType().GetProperty(propertyInfo.Name).SetValue(targetData, CopyData(originalPropertyValue, null, null, InitPropertyMatchMapper(propertyValue.GetType(), propertyInfo.PropertyType, originalPropertyMatchValue, originalPropertyIgnoreValue), propertyValue, originalPropertyMatchValue, originalPropertyIgnoreValue, reflectionType), null); } } else { if (propertySetDict != null && propertySetDict.ContainsKey(propertyInfo.Name)) { ReflectionGenericHelper.SetPropertyValue(propertySetDict[propertyInfo.Name], targetData, propertyValue.ToString(), propertyInfo); } else { ReflectionHelper.SetPropertyValue(targetData, propertyValue.ToString(), propertyInfo); } } } } return(targetData); }
private static Dictionary <PropertyInfo, ExcelToEntityColumnMapper> InitExcelToEntityMapper <T>(IRow row, bool isHeader, string primaryKey, ref int primaryIndex, Dictionary <string, object> propertyDict = null) where T : class { Dictionary <string, int> columnNameDict = null; Dictionary <int, int> columnIndexDict = null; if (isHeader) { columnNameDict = InitExcelPrimaryMapperByName(row, primaryKey, ref primaryIndex); } else { columnIndexDict = InitExcelPrimaryMapperByIndex(row, primaryKey, ref primaryIndex); } Dictionary <PropertyInfo, ExcelToEntityColumnMapper> resultList = new Dictionary <PropertyInfo, ExcelToEntityColumnMapper>(); ReflectionGenericHelper.Foreach <T>((PropertyInfo propertyInfo) => { if (isHeader) { string columnName = null; if (propertyDict != null && propertyDict.ContainsKey(propertyInfo.Name)) { columnName = propertyDict[propertyInfo.Name].ToString(); } else { ExcelTAttribute attribute = propertyInfo.GetCustomAttribute <ExcelTAttribute>(); if (attribute != null) { if (attribute.Type == AttributeReadAndWriteTypeEnum.ReadAndWrite || attribute.Type == AttributeReadAndWriteTypeEnum.Read) { if (!string.IsNullOrEmpty(attribute.Name)) { columnName = attribute.Name; } else { columnName = propertyInfo.Name; } } } else { columnName = propertyInfo.Name; } } if (columnName != null && columnNameDict.ContainsKey(columnName)) { resultList.Add(propertyInfo, new ExcelToEntityColumnMapper() { ColumnName = columnName, ColumnIndex = columnNameDict[columnName] }); } } else { int columnIndex = -1; if (propertyDict != null && propertyDict.ContainsKey(propertyInfo.Name)) { columnIndex = int.Parse(propertyDict[propertyInfo.Name].ToString()); } else { ExcelTAttribute attribute = propertyInfo.GetCustomAttribute <ExcelTAttribute>(); if (attribute != null) { columnIndex = attribute.Index; } } if (columnIndexDict.ContainsKey(columnIndex)) { resultList.Add(propertyInfo, new ExcelToEntityColumnMapper() { ColumnName = null, ColumnIndex = columnIndex }); } } }); return(resultList); }
private static object XmlNodeToObject(Type type, XmlNode xmlNode, dynamic propertySetDict, Dictionary <PropertyInfo, XmlTAttribute> propertyNameDict, ReflectionTypeEnum reflectionType = ReflectionTypeEnum.Expression) { object t = ReflectionHelper.New(type); if (propertyNameDict == null) { propertyNameDict = InitXmlToEntityMapper(type); } if (propertySetDict == null) { if (reflectionType != ReflectionTypeEnum.Original) { propertySetDict = ReflectionExtendHelper.PropertySetCallDict(type, reflectionType); } } foreach (var keyValueItem in propertyNameDict) { XmlNodeList childXmlNodeList = null; string propertyValue = null; switch (keyValueItem.Value.NameType) { case XmlTEnum.Attribute: // 如果是获得 XmlNode 属性值 if (xmlNode.Attributes[keyValueItem.Value.Name] != null) { propertyValue = xmlNode.Attributes[keyValueItem.Value.Name].Value; } ; break; case XmlTEnum.Text: // 如果是获得 XmlNode 的 Text 数据 propertyValue = xmlNode.InnerText; break; case XmlTEnum.Xml: // 如果是获得 XmlNode 的子元素数据 propertyValue = xmlNode.InnerXml; break; case XmlTEnum.Element: case XmlTEnum.ElementList: // 如果是元素或者元素列表 childXmlNodeList = xmlNode.SelectNodes("descendant::" + keyValueItem.Value.Name); break; } if (keyValueItem.Value.NameType == XmlTEnum.Element) { SetPropertyValueByElement(t, keyValueItem.Key, childXmlNodeList, propertySetDict, reflectionType); } else if (keyValueItem.Value.NameType == XmlTEnum.ElementList) { SetPropertyValueByElementList(t, keyValueItem.Key, childXmlNodeList, reflectionType); } else { if (propertySetDict != null && propertySetDict.ContainsKey(keyValueItem.Key.Name)) { ReflectionGenericHelper.SetPropertyValue(propertySetDict[keyValueItem.Key.Name], t, propertyValue, keyValueItem.Key); } else { ReflectionHelper.SetPropertyValue(t, propertyValue, keyValueItem.Key); } } } return(t); }
/// <summary> /// 返回实体数据列表 /// </summary> /// <typeparam name="T">实体类型</typeparam> /// <param name="excelPath">Excel 路径</param> /// <param name="sheetName">Sheet 表单名称</param> /// <param name="propertyMatchList">属性匹配,Dictionary<string, object> 或 new {}</param> /// <param name="headerIndex">表头起始索引,默认值:0,表示第一行是表头数据,与 dataIndex 相同时,表示 Excel 无表头</param> /// <param name="dataIndex">数据行起始索引,默认值:1,表示数据从第二行开始</param> /// <param name="reflectionType">反射类型</param> /// <returns></returns> public static List <T> ToEntityList <T>(string excelPath, string sheetName, object propertyMatchList = null, int headerIndex = 0, int dataIndex = 1, ReflectionTypeEnum reflectionType = ReflectionTypeEnum.Expression) where T : class, new() { List <T> dataList = new List <T>(); ExecuteIWorkbookRead(excelPath, (Workbook workbook) => { Dictionary <string, string> propertyDict = CommonHelper.MergeDict(false, CommonHelper.KeyValueTransform(propertyMatchList), CommonHelper.KeyValueTransform(ReflectionGenericHelper.GetPropertyDict <T>())); dataList = SheetEntityList <T>(workbook, sheetName, propertyDict, headerIndex, dataIndex, reflectionType); }); return(dataList); }