///<summary> /// Sets value of the specified <see cref="ResultProperty"/> on the target object /// when a 'select' attribute exists and fills an <see cref="IList"/> property /// on the <see cref="ResultProperty"/> are empties. /// </summary> /// <param name="request">The request.</param> /// <param name="resultMap">The result map.</param> /// <param name="mapping">The ResultProperty.</param> /// <param name="target">The target.</param> /// <param name="reader">The current <see cref="IDataReader"/></param> /// <param name="keys">The keys</param> public void Set(RequestScope request, IResultMap resultMap, ResultProperty mapping, ref object target, IDataReader reader, object keys) { // Get the select statement IMappedStatement selectStatement = request.MappedStatement.ModelStore.GetMappedStatement(mapping.Select); PostBindind postSelect = new PostBindind(); postSelect.Statement = selectStatement; postSelect.Keys = keys; postSelect.Target = target; postSelect.ResultProperty = mapping; if (mapping.IsLazyLoad) { object values = mapping.LazyFactory.CreateProxy(request.MappedStatement.ModelStore.DataMapper, selectStatement, keys, target, mapping.SetAccessor); //为target类的mapping属性设置值为values mapping.Set(target, values); } else { if (mapping.SetAccessor.MemberType.GetGenericTypeDefinition() == typeof(IList<>)) { postSelect.Method = PostBindind.ExecuteMethod.ExecuteQueryForGenericIList; } //将postSelect类对象添加到队列中 request.DelayedLoad.Enqueue(postSelect); } }
/// <summary> /// Gets the value of an argument constructor. /// </summary> /// <param name="request">The current <see cref="RequestScope"/>.</param> /// <param name="mapping">The <see cref="ResultProperty"/> with the argument infos.</param> /// <param name="reader">The current <see cref="IDataReader"/>.</param> /// <param name="keys">The keys</param> /// <returns>The paremeter value.</returns> public object GetValue(RequestScope request, ResultProperty mapping, ref IDataReader reader, object keys) { if (mapping.TypeHandler == null || mapping.TypeHandler is UnknownTypeHandler) // Find the TypeHandler { lock(mapping) { if (mapping.TypeHandler == null || mapping.TypeHandler is UnknownTypeHandler) { int columnIndex = 0; if (mapping.ColumnIndex == ResultProperty.UNKNOWN_COLUMN_INDEX) { columnIndex = reader.GetOrdinal(mapping.ColumnName); } else { columnIndex = mapping.ColumnIndex; } Type systemType =reader.GetFieldType(columnIndex); mapping.TypeHandler = request.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(systemType); } } } object dataBaseValue = mapping.GetDataBaseValue( reader ); request.IsRowDataFound = request.IsRowDataFound || (dataBaseValue != null); return dataBaseValue; }
///<summary> /// Sets value of the specified <see cref="ResultProperty"/> on the target object /// when a 'select' attribute exists and fills an object property. /// on the <see cref="ResultProperty"/> are empties. /// </summary> /// <param name="request">The request.</param> /// <param name="resultMap">The result map.</param> /// <param name="mapping">The ResultProperty.</param> /// <param name="target">The target.</param> /// <param name="reader">The current <see cref="IDataReader"/></param> /// <param name="keys">The keys</param> public void Set(RequestScope request, IResultMap resultMap, ResultProperty mapping, ref object target, IDataReader reader, object keys) { // Get the select statement IMappedStatement selectStatement = request.MappedStatement.ModelStore.GetMappedStatement(mapping.Select); PostBindind postSelect = new PostBindind(); postSelect.Statement = selectStatement; postSelect.Keys = keys; postSelect.Target = target; postSelect.ResultProperty = mapping; if (mapping.IsLazyLoad) { object values = mapping.LazyFactory.CreateProxy( request.MappedStatement.ModelStore.DataMapper, selectStatement, keys, target, mapping.SetAccessor); mapping.Set(target, values); } else { postSelect.Method = PostBindind.ExecuteMethod.ExecuteQueryForObject; request.DelayedLoad.Enqueue(postSelect); } }
/// <summary> /// Initializes a new instance of the <see cref="SelectStrategy"/> class. /// </summary> /// <param name="mapping">The mapping.</param> /// <param name="selectArrayStrategy">The select array strategy.</param> /// <param name="selectGenericListStrategy">The select generic list strategy.</param> /// <param name="selectListStrategy">The select list strategy.</param> /// <param name="selectObjectStrategy">The select object strategy.</param> public SelectStrategy(ResultProperty mapping, IArgumentStrategy selectArrayStrategy, IArgumentStrategy selectGenericListStrategy, IArgumentStrategy selectListStrategy, IArgumentStrategy selectObjectStrategy) { // Collection object or .NET object if (mapping.MemberType.BaseType == typeof(Array)) { _selectStrategy = selectArrayStrategy; } else if (mapping.MemberType.IsGenericType && typeof(IList<>).IsAssignableFrom(mapping.MemberType.GetGenericTypeDefinition())) { _selectStrategy = selectGenericListStrategy; } // Check if the object to Map implement 'IList' or is IList type // If yes the ResultProperty is map to a IList object else if ( typeof(IList).IsAssignableFrom(mapping.MemberType) ) { _selectStrategy = selectListStrategy; } else // The ResultProperty is map to a .Net object { _selectStrategy = selectObjectStrategy; } }
/// <summary> /// Initializes a new instance of the <see cref="SelectStrategy"/> class. /// </summary> /// <param name="mapping">The mapping.</param> /// <param name="selectArrayStrategy">The select array strategy.</param> /// <param name="selectGenericListStrategy">The select generic list strategy.</param> /// <param name="selectListStrategy">The select list strategy.</param> /// <param name="selectObjectStrategy">The select object strategy.</param> public SelectStrategy(ResultProperty mapping, IPropertyStrategy selectArrayStrategy, IPropertyStrategy selectGenericListStrategy, IPropertyStrategy selectListStrategy, IPropertyStrategy selectObjectStrategy) { Contract.Require.That(selectArrayStrategy, Is.Not.Null).When("retrieving argument selectArrayStrategy in SelectStrategy constructor"); Contract.Require.That(selectGenericListStrategy, Is.Not.Null).When("retrieving argument selectGenericListStrategy in SelectStrategy constructor"); Contract.Require.That(selectListStrategy, Is.Not.Null).When("retrieving argument selectListStrategy in SelectStrategy constructor"); Contract.Require.That(selectObjectStrategy, Is.Not.Null).When("retrieving argument selectObjectStrategy in SelectStrategy constructor"); // Collection object or .NET object if (mapping.SetAccessor.MemberType.BaseType == typeof(Array)) { selectStrategy = selectArrayStrategy; } else if (mapping.SetAccessor.MemberType.IsGenericType && typeof(IList<>).IsAssignableFrom(mapping.SetAccessor.MemberType.GetGenericTypeDefinition()) ) { selectStrategy = selectGenericListStrategy; } // Check if the object to Map implement 'IList' or is IList type // If yes the ResultProperty is map to a IList object else if (typeof(IList).IsAssignableFrom(mapping.SetAccessor.MemberType)) { selectStrategy = selectListStrategy; } else // The ResultProperty is map to a .Net object { selectStrategy = selectObjectStrategy; } }
/// <summary> /// Gets the value of the specified <see cref="ResultProperty"/> that must be set on the target object. /// </summary> /// <param name="request">The request.</param> /// <param name="resultMap">The result map.</param> /// <param name="mapping">The mapping.</param> /// <param name="target">The target.</param> /// <param name="reader">The reader.</param> /// <returns></returns> public object Get(RequestScope request, IResultMap resultMap, ResultProperty mapping, ref object target, IDataReader reader) { object result = null; IResultMap propertyRresultMap = mapping.NestedResultMap.ResolveSubMap(reader); string circularKey = GetCircularKey(propertyRresultMap, reader); // Gets the [key, result object] already build IDictionary<string, object> buildObjects = request.GetCirularKeys(propertyRresultMap); if (buildObjects != null && buildObjects.ContainsKey(circularKey)) { // circular key is already known, so get the existing result object result = buildObjects[circularKey]; } else if (circularKey == null || buildObjects == null || !buildObjects.ContainsKey(circularKey)) { // circular key is NOT known, so create a new result object. result = resultMapStrategy.Get(request, resultMap, mapping, ref target, reader); if (buildObjects == null) { buildObjects = new Dictionary<string, object>(); request.SetCirularKeys(propertyRresultMap, buildObjects); } buildObjects[circularKey] = result; } return result; }
/// <summary> /// Sets value of the specified <see cref="ResultProperty"/> on the target object /// when a 'resultMapping' attribute exists /// on the <see cref="ResultProperty"/>. /// </summary> /// <param name="request">The request.</param> /// <param name="resultMap">The result map.</param> /// <param name="mapping">The ResultProperty.</param> /// <param name="target">The target.</param> /// <param name="reader">The reader.</param> /// <param name="keys">The keys</param> public void Set(RequestScope request, IResultMap resultMap, ResultProperty mapping, ref object target, IDataReader reader, object keys) { object obj = Get(request, resultMap, mapping, ref target, reader); // Sets created object on the property resultMap.SetValueOfProperty( ref target, mapping, obj ); }
/// <summary> /// Gets a column value by the index /// </summary> /// <param name="mapping"></param> /// <param name="dataReader"></param> /// <returns></returns> public override object GetValueByIndex(ResultProperty mapping, IDataReader dataReader) { if (dataReader.IsDBNull(mapping.ColumnIndex)) { return DBNull.Value; } return Enum.Parse(mapping.MemberType, dataReader.GetValue(mapping.ColumnIndex).ToString()); }
/// <summary> /// Gets a column value by the index /// </summary> /// <param name="mapping"></param> /// <param name="dataReader"></param> /// <returns></returns> public override object GetValueByIndex(ResultProperty mapping, IDataReader dataReader) { if (dataReader.IsDBNull(mapping.ColumnIndex)) { return DBNull.Value; } return dataReader.GetFloat(mapping.ColumnIndex); }
/// <summary> /// Gets a column value by the index /// </summary> /// <param name="mapping"></param> /// <param name="dataReader"></param> /// <returns></returns> public override object GetValueByIndex(ResultProperty mapping, IDataReader dataReader) { if (dataReader.IsDBNull(mapping.ColumnIndex) || dataReader.GetBytes(mapping.ColumnIndex, 0, null, 0, 0) == 0) { return DBNull.Value; } return GetValueByIndex(mapping.ColumnIndex, dataReader); }
/// <summary> /// Gets a column value by the index /// </summary> /// <param name="mapping"></param> /// <param name="dataReader"></param> /// <returns></returns> public override object GetValueByIndex(ResultProperty mapping, IDataReader dataReader) { if (dataReader.IsDBNull(mapping.ColumnIndex)) { return DBNull.Value; } return new byte?( Convert.ToByte(dataReader.GetValue(mapping.ColumnIndex)) ); }
/// <summary> /// Gets a column value by the index /// </summary> /// <param name="mapping"></param> /// <param name="dataReader"></param> /// <returns></returns> public override object GetValueByIndex(ResultProperty mapping, IDataReader dataReader) { if (dataReader.IsDBNull(mapping.ColumnIndex)) { return DBNull.Value; } return new char?( dataReader.GetString(mapping.ColumnIndex)[0] ); }
///<summary> /// Sets value of the specified <see cref="ResultProperty"/> on the target object /// when the 'select' and 'resultMap' attributes /// on the <see cref="ResultProperty"/> are empties. /// </summary> /// <param name="request">The request.</param> /// <param name="resultMap">The result map.</param> /// <param name="mapping">The ResultProperty.</param> /// <param name="target">The target.</param> /// <param name="reader">The reader.</param> /// <param name="keys">The keys</param> public void Set(RequestScope request, IResultMap resultMap, ResultProperty mapping, ref object target, IDataReader reader, object keys) { //获取属性mapping的值 object obj = Get(request, resultMap, mapping, ref target, reader); //将mapping的值放到类中对应的属性里 resultMap.SetValueOfProperty(ref target, mapping, obj); }
/// <summary> /// Gets a column value by the index /// </summary> /// <param name="mapping"></param> /// <param name="dataReader"></param> /// <returns></returns> public override object GetValueByIndex(ResultProperty mapping, IDataReader dataReader) { if (dataReader.IsDBNull(mapping.ColumnIndex)) { return DBNull.Value; } // Don't used dataReader.GetInt32 to fix oracle who alwray return decimal type return Convert.ToInt32(dataReader.GetValue(mapping.ColumnIndex)); }
/// <summary> /// Gets the value of an argument constructor. /// </summary> /// <param name="request">The current <see cref="RequestScope"/>.</param> /// <param name="mapping">The <see cref="ResultProperty"/> with the argument infos.</param> /// <param name="reader">The current <see cref="IDataReader"/>.</param> /// <param name="keys">The keys</param> /// <returns>The paremeter value.</returns> public object GetValue(RequestScope request, ResultProperty mapping, ref IDataReader reader, object keys) { // Get the select statement IMappedStatement selectStatement = request.MappedStatement.ModelStore.GetMappedStatement(mapping.Select); reader = DataReaderTransformer.Transform(reader, request.Session.SessionFactory.DataSource.DbProvider); return selectStatement.ExecuteQueryForObject(request.Session, keys, null); }
/// <summary> /// Gets a column value by the name /// </summary> /// <param name="mapping"></param> /// <param name="dataReader"></param> /// <returns></returns> public override object GetValueByName(ResultProperty mapping, IDataReader dataReader) { int index = dataReader.GetOrdinal(mapping.ColumnName); if (dataReader.IsDBNull(index) || dataReader.GetBytes(index, 0, null, 0, 0) == 0) { return DBNull.Value; } return GetValueByIndex(index, dataReader); }
/// <summary> /// /// </summary> /// <param name="mapping"></param> /// <param name="dataReader"></param> /// <returns></returns> public override object GetValueByName(ResultProperty mapping, IDataReader dataReader) { int index = dataReader.GetOrdinal(mapping.ColumnName); if (dataReader.IsDBNull(index)) { return DBNull.Value; } return Enum.Parse(mapping.MemberType, dataReader.GetValue(index).ToString()); }
/// <summary> /// Gets a column value by the name /// </summary> /// <param name="mapping"></param> /// <param name="dataReader"></param> /// <returns></returns> public override object GetValueByName(ResultProperty mapping, IDataReader dataReader) { int index = dataReader.GetOrdinal(mapping.ColumnName); if (dataReader.IsDBNull(index)) { return DBNull.Value; } return dataReader.GetFloat(index); }
/// <summary> /// Gets a column value by the name /// </summary> /// <param name="mapping"></param> /// <param name="dataReader"></param> /// <returns></returns> public override object GetValueByName(ResultProperty mapping, IDataReader dataReader) { int index = dataReader.GetOrdinal(mapping.ColumnName); if (dataReader.IsDBNull(index)) { return DBNull.Value; } return new byte?( Convert.ToByte(dataReader.GetValue(index)) ); }
/// <summary> /// Gets a column value by the name /// </summary> /// <param name="mapping"></param> /// <param name="dataReader"></param> /// <returns></returns> public override object GetValueByName(ResultProperty mapping, IDataReader dataReader) { int index = dataReader.GetOrdinal(mapping.ColumnName); if (dataReader.IsDBNull(index)) { return DBNull.Value; } // Don't used dataReader.GetInt32 to fix oracle who alwray return decimal type return new Int16?(Convert.ToInt16(dataReader.GetValue(index))); }
/// <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 = (AutoResultMap)request.CurrentResultMap; if (outObject == null) { outObject = resultMap.CreateInstanceOfResult(null); } if (!resultMap.IsInitalized) { lock(resultMap) { if (!resultMap.IsInitalized) { // Create a ResultProperty const string propertyName = "value"; const int columnIndex = 0; ITypeHandler typeHandler = request.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(outObject.GetType()); ResultProperty property = new ResultProperty( propertyName, string.Empty, columnIndex, string.Empty, string.Empty, string.Empty, false, string.Empty, null, string.Empty, null, null, typeHandler); //property.PropertyStrategy = PropertyStrategyFactory.Get(property); resultMap.Properties.Add(property); resultMap.DataExchange = request.DataExchangeFactory.GetDataExchangeForClass(typeof(int));// set the PrimitiveDataExchange resultMap.IsInitalized = true; } } } //为outObject类的属性property赋值 resultMap.Properties[0].PropertyStrategy.Set(request, resultMap, resultMap.Properties[0], ref outObject, reader, null); return outObject; }
/// <summary> /// Gets the value of an argument constructor. /// </summary> /// <param name="request">The current <see cref="RequestScope"/>.</param> /// <param name="mapping">The <see cref="ResultProperty"/> with the argument infos.</param> /// <param name="reader">The current <see cref="IDataReader"/>.</param> /// <param name="keys">The keys</param> /// <returns>The paremeter value.</returns> public object GetValue(RequestScope request, ResultProperty mapping, ref IDataReader reader, object keys) { // Get the select statement IMappedStatement selectStatement = request.MappedStatement.ModelStore.GetMappedStatement(mapping.Select); if (mapping.MemberType == typeof(IList)) { reader = DataReaderTransformer.Transform(reader, request.Session.SessionFactory.DataSource.DbProvider); return selectStatement.ExecuteQueryForList(request.Session, keys); } reader = DataReaderTransformer.Transform(reader, request.Session.SessionFactory.DataSource.DbProvider); IFactory factory = request.DataExchangeFactory.ObjectFactory.CreateFactory(mapping.MemberType, Type.EmptyTypes); object values = factory.CreateInstance(null); selectStatement.ExecuteQueryForList(request.Session, keys, (IList)values); return values; }
/// <summary> /// Gets the value of an argument constructor. /// </summary> /// <param name="request">The current <see cref="RequestScope"/>.</param> /// <param name="mapping">The <see cref="ResultProperty"/> with the argument infos.</param> /// <param name="reader">The current <see cref="IDataReader"/>.</param> /// <param name="keys">The keys</param> /// <returns>The paremeter value.</returns> public object GetValue(RequestScope request, ResultProperty mapping, ref IDataReader reader, object keys) { // Get the select statement IMappedStatement selectStatement = request.MappedStatement.ModelStore.GetMappedStatement(mapping.Select); reader = DataReaderTransformer.Transform(reader, request.Session.SessionFactory.DataSource.DbProvider); IList values = selectStatement.ExecuteQueryForList(request.Session, keys); Type elementType = mapping.MemberType.GetElementType(); Array array = Array.CreateInstance(elementType, values.Count); int count = values.Count; for(int i=0;i<count;i++) { array.SetValue(values[i],i); } return array; }
/// <summary> /// Gets a column value by the index /// </summary> /// <param name="mapping"></param> /// <param name="dataReader"></param> /// <returns></returns> public override object GetValueByIndex(ResultProperty mapping, IDataReader dataReader) { if (dataReader.IsDBNull(mapping.ColumnIndex)) { return DBNull.Value; } // Don't used dataReader.GetInt32 to fix oracle who alwray return decimal type object obj=0; try { obj = dataReader.GetValue(mapping.ColumnIndex); } catch(Exception e) { string m =mapping.ColumnName+ e.Message; } return Convert.ToInt32(obj); }
///<summary> /// Sets value of the specified <see cref="ResultProperty"/> on the target object /// when a 'select' attribute exists and fills an Array property /// on the <see cref="ResultProperty"/> are empties. /// </summary> /// <param name="request">The request.</param> /// <param name="resultMap">The result map.</param> /// <param name="mapping">The ResultProperty.</param> /// <param name="target">The target.</param> /// <param name="reader">The <see cref="IDataReader"/></param> /// <param name="keys">The keys</param> public void Set(RequestScope request, IResultMap resultMap, ResultProperty mapping, ref object target, IDataReader reader, object keys) { // Get the select statement IMappedStatement selectStatement = request.MappedStatement.ModelStore.GetMappedStatement(mapping.Select); PostBindind postSelect = new PostBindind(); postSelect.Statement = selectStatement; postSelect.Keys = keys; postSelect.Target = target; postSelect.ResultProperty = mapping; if (mapping.IsLazyLoad) { throw new NotImplementedException("Lazy load no supported for System.Array property:" + mapping.SetAccessor.Name); } postSelect.Method = PostBindind.ExecuteMethod.ExecuteQueryForArrayList; request.DelayedLoad.Enqueue(postSelect); }
/// <summary> /// Sets the value to the result property. /// </summary> /// <param name="mapping"></param> /// <param name="target"></param> /// <param name="dataBaseValue"></param> public override void SetData(ref object target, ResultProperty mapping, object dataBaseValue) { Type targetType = target.GetType(); if ((targetType != parameterClass) && !targetType.IsSubclassOf(parameterClass) && !parameterClass.IsAssignableFrom(targetType)) { throw new ArgumentException("Could not set value in class '" + target.GetType() + "' for property '" + mapping.PropertyName + "' of type '" + mapping.MemberType + "'"); } if ( mapping.IsComplexMemberName) { ObjectProbe.SetMemberValue(target, mapping.PropertyName, dataBaseValue, DataExchangeFactory.ObjectFactory, DataExchangeFactory.AccessorFactory); } else { mapping.Set(target, dataBaseValue); } }
/// <summary> /// Gets the value of the specified <see cref="ResultProperty"/> that must be set on the target object. /// </summary> /// <param name="request">The request.</param> /// <param name="resultMap">The result map.</param> /// <param name="mapping">The mapping.</param> /// <param name="reader">The reader.</param> /// <param name="target">The target object</param> public object Get(RequestScope request, IResultMap resultMap, ResultProperty mapping, ref object target, IDataReader reader) { object[] parameters = null; bool isParameterFound = false; IResultMap resultMapping = mapping.NestedResultMap.ResolveSubMap(reader); if (resultMapping.Parameters.Count > 0) { parameters = new object[resultMapping.Parameters.Count]; // Fill parameters array for (int index = 0; index < resultMapping.Parameters.Count; index++) { ResultProperty resultProperty = resultMapping.Parameters[index]; parameters[index] = resultProperty.GetValue(request, ref reader, null); request.IsRowDataFound = request.IsRowDataFound || (parameters[index] != null); isParameterFound = isParameterFound || (parameters[index] != null); } } object obj = null; // If I have a constructor tag and all argumments values are null, the obj is null if (resultMapping.Parameters.Count > 0 && isParameterFound == false) { obj = null; } else { obj = resultMapping.CreateInstanceOfResult(parameters); // Fills properties on the new object if (FillObjectWithReaderAndResultMap(request, reader, resultMapping, ref obj) == false) { obj = null; } } return obj; }
/// <summary> /// Gets the value of an argument constructor. /// </summary> /// <param name="request">The current <see cref="RequestScope"/>.</param> /// <param name="mapping">The <see cref="ResultProperty"/> with the argument infos.</param> /// <param name="reader">The current <see cref="IDataReader"/>.</param> /// <param name="keys">The keys</param> /// <returns>The paremeter value.</returns> public object GetValue(RequestScope request, ResultProperty mapping, ref IDataReader reader, object keys) { // Get the select statement IMappedStatement selectStatement = request.MappedStatement.ModelStore.GetMappedStatement(mapping.Select); reader = DataReaderTransformer.Transform(reader, request.Session.SessionFactory.DataSource.DbProvider); //Type[] typeArgs = mapping.MemberType.GetGenericArguments(); //Type genericList = typeof(IList<>); //Type constructedType = genericList.MakeGenericType(typeArgs); Type elementType = mapping.MemberType.GetGenericArguments()[0]; Type mappedStatementType = selectStatement.GetType(); //Type[] typeArguments = { typeof(ISession), typeof(object) }; MethodInfo[] mis = mappedStatementType.GetMethods(BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Instance); MethodInfo mi = null; for (int i = 0; i < mis.Length; i++) { if (mis[i].IsGenericMethod && mis[i].Name == "ExecuteQueryForList" && mis[i].GetParameters().Length == 2) { mi = mis[i]; break; } } MethodInfo miConstructed = mi.MakeGenericMethod(elementType); // Invoke the method. object[] args = { request.Session, keys }; object values = miConstructed.Invoke(selectStatement, args); return values; }
/// <summary> /// Finds the <see cref="IPropertyStrategy"/>. /// </summary> /// <param name="mapping">The <see cref="ResultProperty"/>.</param> /// <returns>The <see cref="IPropertyStrategy"/></returns> public static IPropertyStrategy Get(ResultProperty mapping) { // no 'select' or 'resultMap' attributes if (mapping.Select.Length == 0 && mapping.NestedResultMap == null) { // We have a 'normal' ResultMap return defaultStrategy; } if (mapping.NestedResultMap != null) // 'resultMap' attribute { if (mapping.NestedResultMap.GroupByPropertyNames.Count>0) { return groupByStrategy; } if (mapping.MemberType.IsGenericType && typeof(IList<>).IsAssignableFrom(mapping.MemberType.GetGenericTypeDefinition())) { return groupByStrategy; } if (typeof(IList).IsAssignableFrom(mapping.MemberType)) { return groupByStrategy; } if (mapping.NestedResultMap.KeyPropertyNames.Count > 0) { return circularStrategy; } return resultMapStrategy; } //'select' ResultProperty return new SelectStrategy(mapping, selectArrayStrategy, selectGenericListStrategy, selectListStrategy, selectObjectStrategy); }
/// <summary> /// Processes the specified <see cref="IDataReader"/> /// when a ResultClass is specified on the statement and /// the ResultClass is <see cref="IList"/>. /// </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 = request.CurrentResultMap.CreateInstanceOfResult(null); } //将reader当前行中的所有字段加入到IList对象中 int count = reader.FieldCount; for (int i = 0; i < count; i++) { const string propertyName = "value"; int columnIndex = i; ITypeHandler typeHandler = request.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(reader.GetFieldType(i)); ResultProperty property = new ResultProperty( propertyName, string.Empty, columnIndex, string.Empty, string.Empty, string.Empty, false, string.Empty, null, string.Empty, null, null, typeHandler); ((IList) outObject).Add(property.GetDataBaseValue(reader)); } return outObject; }
/// <summary> /// Set the value of an object property. /// </summary> /// <param name="target">The object to set the property.</param> /// <param name="property">The result property to use.</param> /// <param name="dataBaseValue">The database value to set.</param> public void SetValueOfProperty(ref object target, ResultProperty property, object dataBaseValue) { throw new NotImplementedException("The method or operation is not implemented."); }
/// <summary> /// Set the value of an object property. /// </summary> /// <param name="target">The object to set the property.</param> /// <param name="property">The result property to use.</param> /// <param name="dataBaseValue">The database value to set.</param> public void SetValueOfProperty(ref object target, ResultProperty property, object dataBaseValue) { dataExchange.SetData(ref target, property, dataBaseValue); }