/// <summary> /// Processes the specified <see cref="IDataReader"/> /// when a ResultClass is specified on the statement and /// the ResultClass is a SimpleType. /// </summary> /// <param name="request">The request.</param> /// <param name="reader">The reader.</param> /// <param name="resultObject">The result object.</param> public object Process(RequestScope request, ref IDataReader reader, object resultObject) { object outObject = resultObject; AutoResultMap resultMap = request.CurrentResultMap as AutoResultMap; if (outObject == null) { outObject = resultMap.CreateInstanceOfResultClass(); } if (!resultMap.IsInitalized) { lock (resultMap) { if (!resultMap.IsInitalized) { // Create a ResultProperty ResultProperty property = new ResultProperty(); property.PropertyName = "value"; property.ColumnIndex = 0; property.TypeHandler = request.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(outObject.GetType()); property.PropertyStrategy = PropertyStrategyFactory.Get(property); resultMap.Properties.Add(property); resultMap.DataExchange = request.DataExchangeFactory.GetDataExchangeForClass(typeof(int));// set the PrimitiveDataExchange resultMap.IsInitalized = true; } } } resultMap.Properties[0].PropertyStrategy.Set(request, resultMap, resultMap.Properties[0], ref outObject, reader, null); return(outObject); }
public object Process(RequestScope request, ref IDataReader reader, object resultObject) { object target = resultObject; AutoResultMap currentResultMap = request.CurrentResultMap as AutoResultMap; if (target == null) { target = currentResultMap.CreateInstanceOfResultClass(); } if (!currentResultMap.IsInitalized) { lock (currentResultMap) { if (!currentResultMap.IsInitalized) { ResultProperty property; property = new ResultProperty { PropertyName = "value", ColumnIndex = 0, TypeHandler = request.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(target.GetType()), PropertyStrategy = PropertyStrategyFactory.Get(property) }; currentResultMap.Properties.Add(property); currentResultMap.DataExchange = request.DataExchangeFactory.GetDataExchangeForClass(typeof(int)); currentResultMap.IsInitalized = true; } } } currentResultMap.Properties[0].PropertyStrategy.Set(request, currentResultMap, currentResultMap.Properties[0], ref target, reader, null); return(target); }
/// <summary> /// Builds a <see cref="ResultPropertyCollection"/> for an <see cref="AutoResultMap"/>. /// </summary> /// <param name="dataExchangeFactory">The data exchange factory.</param> /// <param name="reader">The reader.</param> /// <param name="resultObject">The result object.</param> public static ResultPropertyCollection Build <T>(DataExchangeFactory dataExchangeFactory, IDataReader reader, ref T resultObject) { Type targetType = resultObject.GetType(); ResultPropertyCollection properties = new ResultPropertyCollection(); try { // Get all PropertyInfo from the resultObject properties var reflectionInfo = ReflectionInfo.GetInstance(targetType); var membersName = reflectionInfo.GetWriteableMemberNames(); var propertyMap = new Hashtable(); int length = membersName.Length; for (int i = 0; i < length; i++) { ISetAccessorFactory setAccessorFactory = dataExchangeFactory.AccessorFactory.SetAccessorFactory; ISetAccessor setAccessor = setAccessorFactory.CreateSetAccessor(targetType, membersName[i]); propertyMap.Add(membersName[i], setAccessor); } // Get all column Name from the reader // and build a resultMap from with the help of the PropertyInfo[]. var dataColumn = reader.GetSchemaTable(); if (dataColumn == null) { return(new ResultPropertyCollection()); } int count = dataColumn.Rows.Count; for (int i = 0; i < count; i++) { var columnName = dataColumn.Rows[i][0].ToString(); var matchedSetAccessor = propertyMap[columnName] as ISetAccessor; var property = new ResultProperty { ColumnName = columnName, ColumnIndex = i }; if (resultObject is Hashtable) { property.PropertyName = columnName; properties.Add(property); } Type propertyType = null; if (matchedSetAccessor == null) { try { propertyType = ObjectProbe.GetMemberTypeForSetter(resultObject, columnName); } catch { // ignored } } else { propertyType = matchedSetAccessor.MemberType; } if (propertyType != null || matchedSetAccessor != null) { property.PropertyName = (matchedSetAccessor != null ? matchedSetAccessor.Name : columnName); if (matchedSetAccessor != null) { property.Initialize(dataExchangeFactory.TypeHandlerFactory, matchedSetAccessor); } else { property.TypeHandler = dataExchangeFactory.TypeHandlerFactory.GetTypeHandler(propertyType); } property.PropertyStrategy = PropertyStrategyFactory.Get(property); properties.Add(property); } } } catch (Exception e) { throw new DataMapperException("Error automapping columns. Cause: " + e.Message, e); } return(properties); }
public static ResultPropertyCollection Build(DataExchangeFactory dataExchangeFactory, IDataReader reader, ref object resultObject) { Type type = resultObject.GetType(); ResultPropertyCollection propertys = new ResultPropertyCollection(); try { string[] writeableMemberNames = ReflectionInfo.GetInstance(type).GetWriteableMemberNames(); Hashtable hashtable = new Hashtable(); int length = writeableMemberNames.Length; for (int i = 0; i < length; i++) { ISetAccessor accessor = dataExchangeFactory.AccessorFactory.SetAccessorFactory.CreateSetAccessor(type, writeableMemberNames[i]); hashtable.Add(writeableMemberNames[i], accessor); } DataTable schemaTable = reader.GetSchemaTable(); int count = schemaTable.Rows.Count; for (int j = 0; j < count; j++) { string memberName = schemaTable.Rows[j][0].ToString(); ISetAccessor setAccessor = hashtable[memberName] as ISetAccessor; ResultProperty property = new ResultProperty { ColumnName = memberName, ColumnIndex = j }; if (resultObject is Hashtable) { property.PropertyName = memberName; propertys.Add(property); } Type memberTypeForSetter = null; if (setAccessor == null) { try { memberTypeForSetter = ObjectProbe.GetMemberTypeForSetter(resultObject, memberName); } catch { _logger.Error("The column [" + memberName + "] could not be auto mapped to a property on [" + resultObject.ToString() + "]"); } } else { memberTypeForSetter = setAccessor.MemberType; } if ((memberTypeForSetter != null) || (setAccessor != null)) { property.PropertyName = (setAccessor != null) ? setAccessor.Name : memberName; if (setAccessor != null) { property.Initialize(dataExchangeFactory.TypeHandlerFactory, setAccessor); } else { property.TypeHandler = dataExchangeFactory.TypeHandlerFactory.GetTypeHandler(memberTypeForSetter); } property.PropertyStrategy = PropertyStrategyFactory.Get(property); propertys.Add(property); } } } catch (Exception exception) { throw new DataMapperException("Error automapping columns. Cause: " + exception.Message, exception); } return(propertys); }
/// <summary> /// Initializes a new instance of the <see cref="ResultProperty"/> class. /// </summary> /// <param name="propertyName">Name of the property.</param> /// <param name="columnName">Name of the column.</param> /// <param name="columnIndex">Index of the column.</param> /// <param name="clrType">Type of the CLR.</param> /// <param name="callBackName">Name of the call back.</param> /// <param name="dbType">Type of the db.</param> /// <param name="isLazyLoad">if set to <c>true</c> [is lazy load].</param> /// <param name="nestedResultMapName">Name of the nested result map.</param> /// <param name="nullValue">The null value.</param> /// <param name="select">The select.</param> /// <param name="resultClass">The result class.</param> /// <param name="dataExchangeFactory">The data exchange factory.</param> /// <param name="typeHandler">The type handler.</param> public ResultProperty( string propertyName, string columnName, int columnIndex, string clrType, string callBackName, string dbType, bool isLazyLoad, string nestedResultMapName, string nullValue, string select, Type resultClass, DataExchangeFactory dataExchangeFactory, ITypeHandler typeHandler ) { Contract.Require.That(propertyName, Is.Not.Null & Is.Not.Empty).When("retrieving argument propertyName in ResultProperty constructor"); this.propertyName = propertyName; this.columnName = columnName; this.callBackName = callBackName; this.dbType = dbType; this.clrType = clrType; this.select = select; this.nestedResultMapName = nestedResultMapName; this.isLazyLoad = isLazyLoad; this.nullValue = nullValue; this.columnIndex = columnIndex; this.typeHandler = typeHandler; #region isComplexMemberName if (propertyName.IndexOf('.') < 0) { isComplexMemberName = false; } else // complex member name FavouriteLineItem.Id { isComplexMemberName = true; } #endregion if (propertyName.Length > 0 && propertyName != "value" && !typeof(IDictionary).IsAssignableFrom(resultClass) && !typeof(DataRow).IsAssignableFrom(resultClass)) { #region SetAccessor if (!isComplexMemberName) { setAccessor = dataExchangeFactory.AccessorFactory.SetAccessorFactory.CreateSetAccessor(resultClass, propertyName); } else // complex member name FavouriteLineItem.Id { MemberInfo propertyInfo = ObjectProbe.GetMemberInfoForSetter(resultClass, propertyName); string memberName = propertyName.Substring(propertyName.LastIndexOf('.') + 1); setAccessor = dataExchangeFactory.AccessorFactory.SetAccessorFactory.CreateSetAccessor(propertyInfo.ReflectedType, memberName); } #endregion isGenericIList = TypeUtils.IsImplementGenericIListInterface(MemberType); isIList = typeof(IList).IsAssignableFrom(MemberType); #region Set the list factory if (isGenericIList) { if (MemberType.IsArray) { listFactory = arrayListFactory; } else { Type[] typeArgs = MemberType.GetGenericArguments(); if (typeArgs.Length == 0)// Custom collection which derive from List<T> { listFactory = dataExchangeFactory.ObjectFactory.CreateFactory(MemberType, Type.EmptyTypes); } else { Type genericIList = typeof(IList <>); Type interfaceListType = genericIList.MakeGenericType(typeArgs); Type genericList = typeof(List <>); Type listType = genericList.MakeGenericType(typeArgs); if ((interfaceListType == MemberType) || (listType == MemberType)) { Type constructedType = genericList.MakeGenericType(typeArgs); listFactory = dataExchangeFactory.ObjectFactory.CreateFactory( constructedType, Type.EmptyTypes); } else // Custom collection which derive from List<T> { listFactory = dataExchangeFactory.ObjectFactory.CreateFactory(MemberType, Type.EmptyTypes); } } } } else if (isIList) { if (MemberType.IsArray) { listFactory = arrayListFactory; } else { if (MemberType == typeof(IList)) { listFactory = arrayListFactory; } else // custom collection { listFactory = dataExchangeFactory.ObjectFactory.CreateFactory(MemberType, Type.EmptyTypes); } } } #endregion } #region TypeHandler if (!string.IsNullOrEmpty(CallBackName)) { try { Type type = dataExchangeFactory.TypeHandlerFactory.GetType(CallBackName); ITypeHandlerCallback typeHandlerCallback = (ITypeHandlerCallback)Activator.CreateInstance(type); this.typeHandler = new CustomTypeHandler(typeHandlerCallback); } catch (Exception e) { throw new ConfigurationException("Error occurred during custom type handler configuration. Cause: " + e.Message, e); } } else { if (typeHandler == null) { //configScope.ErrorContext.MoreInfo = "Result property '" + propertyName + "' set the typeHandler attribute."; this.typeHandler = dataExchangeFactory.TypeHandlerFactory.ResolveTypeHandler(resultClass, propertyName, clrType, dbType, true); } } #endregion #region LazyLoad if (IsLazyLoad) { lazyFactory = new LazyFactoryBuilder().GetLazyFactory(setAccessor.MemberType); } #endregion if (!GetType().IsSubclassOf(typeof(ResultProperty))) { propertyStrategy = PropertyStrategyFactory.Get(this); } }
/// <summary> /// Builds a <see cref="ResultPropertyCollection"/> for an <see cref="AutoResultMap"/>. /// </summary> /// <param name="dataExchangeFactory">The data exchange factory.</param> /// <param name="reader">The reader.</param> /// <param name="resultObject">The result object.</param> /// <param name="isUseAutoMapCompatibilityMode">The result object.</param> public static ResultPropertyCollection Build(DataExchangeFactory dataExchangeFactory, IDataReader reader, ref object resultObject, bool isUseAutoMapCompatibilityMode) { Type targetType = resultObject.GetType(); ResultPropertyCollection properties = new ResultPropertyCollection(); try { // Get all PropertyInfo from the resultObject properties ReflectionInfo reflectionInfo = ReflectionInfo.GetInstance(targetType); string[] membersName = reflectionInfo.GetPublicWriteableMemberNames(); Hashtable propertyMap = new Hashtable(); int length = membersName.Length; for (int i = 0; i < length; i++) { var memberName = membersName[i]; ISetAccessorFactory setAccessorFactory = dataExchangeFactory.AccessorFactory.SetAccessorFactory; ISetAccessor setAccessor = setAccessorFactory.CreateSetAccessor(targetType, memberName); var menberInfo = reflectionInfo.GetSetter(memberName); //ʹ�ñ�ע������Ϊ�к����ԵĹ�ϵ var attrs = menberInfo.GetCustomAttribute <AliasAttribute>(); if (attrs != null) { memberName = attrs.Name; } else if (isUseAutoMapCompatibilityMode)//���ü���ģʽ { memberName = memberName.Replace("_", "").ToLower(); } propertyMap.Add(memberName, setAccessor); } // Get all column Name from the reader // and build a resultMap from with the help of the PropertyInfo[]. DataTable dataColumn = reader.GetSchemaTable(); int count = dataColumn.Rows.Count; for (int i = 0; i < count; i++) { string columnName = dataColumn.Rows[i][0].ToString(); ISetAccessor matchedSetAccessor = propertyMap[columnName] as ISetAccessor; if (matchedSetAccessor == null && isUseAutoMapCompatibilityMode) { columnName = columnName.Replace("_", "").ToLower(); matchedSetAccessor = propertyMap[columnName] as ISetAccessor; } ResultProperty property = new ResultProperty(); property.ColumnName = columnName; property.ColumnIndex = i; if (resultObject is Hashtable) { property.PropertyName = columnName; properties.Add(property); } Type propertyType = null; if (matchedSetAccessor == null) { try { propertyType = ObjectProbe.GetMemberTypeForSetter(resultObject, columnName); } catch { _logger.Error("The column [" + columnName + "] could not be auto mapped to a property on [" + resultObject.ToString() + "]"); } } else { propertyType = matchedSetAccessor.MemberType; } if (propertyType != null || matchedSetAccessor != null) { property.PropertyName = (matchedSetAccessor != null ? matchedSetAccessor.Name : columnName); if (matchedSetAccessor != null) { property.Initialize(dataExchangeFactory.TypeHandlerFactory, matchedSetAccessor); } else { property.TypeHandler = dataExchangeFactory.TypeHandlerFactory.GetTypeHandler(propertyType); } property.PropertyStrategy = PropertyStrategyFactory.Get(property); properties.Add(property); } } } catch (Exception e) { throw new DataMapperException("Error automapping columns. Cause: " + e.Message, e); } return(properties); }