///<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.SqlMap.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(selectStatement, keys, target, mapping.SetAccessor);
mapping.SetAccessor.Set(target, values);
}
else
{
if (mapping.SetAccessor.MemberType == typeof(IList))
{
postSelect.Method = PostBindind.ExecuteMethod.ExecuteQueryForIList;
}
else
{
postSelect.Method = PostBindind.ExecuteMethod.ExecuteQueryForStrongTypedIList;
}
request.QueueSelect.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>
/// 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 =((IDataRecord)reader).GetFieldType(columnIndex);
mapping.TypeHandler = request.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(systemType);
}
}
}
object dataBaseValue = mapping.GetDataBaseValue( reader );
request.IsRowDataFound = request.IsRowDataFound || (dataBaseValue != null);
return dataBaseValue;
}
/// <summary>
/// Processes the specified <see cref="IDataReader"/>
/// when no resultClass or resultMap attribute are specified.
/// </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;
if (reader.FieldCount == 1)
{
ResultProperty property = new ResultProperty();
property.PropertyName = "value";
property.ColumnIndex = 0;
property.TypeHandler = request.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(reader.GetFieldType(0));
outObject = property.GetDataBaseValue(reader);
}
else if (reader.FieldCount > 1)
{
object[] newOutObject = new object[reader.FieldCount];
int count = reader.FieldCount;
for (int i = 0; i < count; i++)
{
ResultProperty property = new ResultProperty();
property.PropertyName = "value";
property.ColumnIndex = i;
property.TypeHandler = request.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(reader.GetFieldType(i));
newOutObject[i] = property.GetDataBaseValue(reader);
}
outObject = newOutObject;
}
else
{
// do nothing if 0 fields
}
return outObject;
}
/// <summary>
/// Processes the specified <see cref="IDataReader"/>
/// when a 'resultClass' attribute is specified on the statement and
/// the 'resultClass' attribute is a <see cref="IDictionary"/>.
/// </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();
}
int count = reader.FieldCount;
IDictionary dictionary = (IDictionary) outObject;
for (int i = 0; i < count; i++)
{
ResultProperty property = new ResultProperty();
property.PropertyName = "value";
property.ColumnIndex = i;
property.TypeHandler = request.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(reader.GetFieldType(i));
dictionary.Add(
reader.GetName(i),
property.GetDataBaseValue(reader));
}
return outObject;
}
/// <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;
}
/// <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.SqlMap.GetMappedStatement(mapping.Select);
reader = DataReaderTransformer.Transform(reader, request.Session.DataSource.DbProvider);
return selectStatement.ExecuteQueryForObject(request.Session, keys);
}
/// <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) == true)
{
return DBNull.Value;
}
else
{
return new UInt64?(Convert.ToUInt64(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) == true)
{
return DBNull.Value;
}
else
{
return new DateTime?(dataReader.GetDateTime(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) == true)
{
return System.DBNull.Value;
}
else
{
return 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) == true)
{
return DBNull.Value;
}
else
{
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) || dataReader.GetBytes(mapping.ColumnIndex, 0, null, 0, 0) == 0)
{
return DBNull.Value;
}
else
{
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) == true)
{
return DBNull.Value;
}
else
{
// Don't used dataReader.GetInt32 to fix oracle who alwray return decimal type
return Convert.ToUInt16(dataReader.GetValue(mapping.ColumnIndex));
}
}
/// <summary>
/// Deserialize a ResultProperty object
/// </summary>
/// <param name="node"></param>
/// <param name="configScope"></param>
/// <returns></returns>
public static ResultProperty Deserialize(XmlNode node, ConfigurationScope configScope)
{
ResultProperty resultProperty = new ResultProperty();
NameValueCollection prop = NodeUtils.ParseAttributes(node, configScope.Properties);
resultProperty.CLRType = NodeUtils.GetStringAttribute(prop, "type");
resultProperty.CallBackName = NodeUtils.GetStringAttribute(prop, "typeHandler");
resultProperty.ColumnIndex = NodeUtils.GetIntAttribute( prop, "columnIndex", ResultProperty.UNKNOWN_COLUMN_INDEX );
resultProperty.ColumnName = NodeUtils.GetStringAttribute(prop, "column");
resultProperty.DbType = NodeUtils.GetStringAttribute(prop, "dbType");
resultProperty.IsLazyLoad = NodeUtils.GetBooleanAttribute( prop, "lazyLoad", false);
resultProperty.NestedResultMapName = NodeUtils.GetStringAttribute(prop, "resultMapping");
resultProperty.NullValue = prop["nullValue"];
resultProperty.PropertyName = NodeUtils.GetStringAttribute(prop, "property");
resultProperty.Select = NodeUtils.GetStringAttribute(prop, "select");
return resultProperty;
}
/// <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.SqlMap.GetMappedStatement(mapping.Select);
reader = DataReaderTransformer.Transform(reader, request.Session.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>
/// 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.SqlMap.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.QueueSelect.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)
{
// Get the select statement
IMappedStatement selectStatement = request.MappedStatement.SqlMap.GetMappedStatement(mapping.Select);
if (mapping.MemberType == typeof(IList))
{
reader = DataReaderTransformer.Transform(reader, request.Session.DataSource.DbProvider);
return selectStatement.ExecuteQueryForList(request.Session, keys);
}
else // Strongly typed List
{
reader = DataReaderTransformer.Transform(reader, request.Session.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>
/// 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;
}
else if (mapping.NestedResultMap != null) // 'resultMap' attribute
{
if (mapping.NestedResultMap.GroupByPropertyNames.Count>0)
{
return _groupByStrategy;
}
else
{
if (mapping.MemberType.IsGenericType &&
typeof(IList<>).IsAssignableFrom(mapping.MemberType.GetGenericTypeDefinition()))
{
return _groupByStrategy;
}
else
if (typeof(IList).IsAssignableFrom(mapping.MemberType))
{
return _groupByStrategy;
}
else
{
return _resultMapStrategy;
}
}
}
else //'select' ResultProperty
{
return new SelectStrategy(mapping,
_selectArrayStrategy,
_selectGenericListStrategy,
_selectListStrategy,
_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="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.ArgumentStrategy.GetValue(request, resultProperty, 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 (this.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.SqlMap.GetMappedStatement(mapping.Select);
reader = DataReaderTransformer.Transform(reader, request.Session.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(SqlMapSession), typeof(object) };
MethodInfo[] mis = mappedStatementType.GetMethods(BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Instance);
MethodInfo mi = null;
foreach (MethodInfo m in mis)
{
if (m.IsGenericMethod &&
m.Name == "ExecuteQueryForList" &&
m.GetParameters().Length == 2)
{
mi = m;
break;
}
}
MethodInfo miConstructed = mi.MakeGenericMethod(elementType);
// Invoke the method.
object[] args = { request.Session, keys };
object values = miConstructed.Invoke(selectStatement, args);
return values;
}
/// <summary>
/// Indicate if a ResultProperty is in the collection
/// </summary>
/// <param name="value">A ResultProperty</param>
/// <returns>True fi is in</returns>
public bool Contains(ResultProperty value)
{
return Contains(value.PropertyName);
}
/// <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) == true)
{
return DBNull.Value;
}
else
{
// Don't used dataReader.GetInt32 to fix oracle who alwray return decimal type
return new Int16?(Convert.ToInt16(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) || dataReader.GetBytes(index, 0, null, 0, 0) == 0)
{
return DBNull.Value;
}
else
{
return GetValueByIndex(index, dataReader);
}
}
/// <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 Exception("The method or operation is not implemented.");
}
/// <summary> /// Sets the value to the result property. /// </summary> /// <param name="mapping"></param> /// <param name="target"></param> /// <param name="dataBaseValue"></param> public abstract void SetData(ref object target, ResultProperty mapping, object dataBaseValue);
/// <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) == true)
{
return DBNull.Value;
}
else
{
return new UInt16?(Convert.ToUInt16(dataReader.GetValue(index)));
}
}
/// <summary>
/// Remove a ResultProperty of the collection.
/// </summary>
public void Remove(ResultProperty value)
{
for(int i = 0; i < _count; i++)
{
if(_innerList[i].PropertyName==value.PropertyName)
{
RemoveAt(i);
return;
}
}
}
/// <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);
}
/// <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)
{
ObjectProbe.SetMemberValue(target, mapping.PropertyName, dataBaseValue,
this.DataExchangeFactory.ObjectFactory,
this.DataExchangeFactory.AccessorFactory);
}
/// <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) == true)
{
return System.DBNull.Value;
}
else
{
return dataReader.GetValue(index);
}
}
/// <summary>
/// Insert a ResultProperty in the collection.
/// </summary>
/// <param name="index">Index where to insert.</param>
/// <param name="value">A ResultProperty</param>
public void Insert(int index, ResultProperty value)
{
if (index < 0 || index > _count)
{
throw new ArgumentOutOfRangeException("index");
}
Resize(_count + 1);
Array.Copy(_innerList, index, _innerList, index + 1, _count - index);
_innerList[index] = value;
_count++;
}
/// <summary>
/// Get the result properties and the subMap properties.
/// </summary>
/// <param name="configScope"></param>
private void GetChildNode(ConfigurationScope configScope)
{
ResultProperty mapping = null;
SubMap subMap = null;
#region Load the parameters constructor
XmlNodeList nodeList = configScope.NodeContext.SelectNodes(DomSqlMapBuilder.ApplyMappingNamespacePrefix(XML_CONSTRUCTOR_ARGUMENT), configScope.XmlNamespaceManager);
if (nodeList.Count > 0)
{
Type[] parametersType = new Type[nodeList.Count];
string[] parametersName = new string[nodeList.Count];
for (int i = 0; i < nodeList.Count; i++)
{
ArgumentProperty argumentMapping = ArgumentPropertyDeSerializer.Deserialize(nodeList[i], configScope);
_parameters.Add(argumentMapping);
parametersName[i] = argumentMapping.ArgumentName;
}
ConstructorInfo constructorInfo = this.GetConstructor(_class, parametersName);
for (int i = 0; i < _parameters.Count; i++)
{
ArgumentProperty argumentMapping = (ArgumentProperty)_parameters[i];
configScope.ErrorContext.MoreInfo = "initialize argument property : " + argumentMapping.ArgumentName;
argumentMapping.Initialize(configScope, constructorInfo);
parametersType[i] = argumentMapping.MemberType;
}
// Init the object factory
_objectFactory = configScope.SqlMapper.ObjectFactory.CreateFactory(_class, parametersType);
}
else
{
if (Type.GetTypeCode(_class) == TypeCode.Object)
{
_objectFactory = configScope.SqlMapper.ObjectFactory.CreateFactory(_class, Type.EmptyTypes);
}
}
#endregion
#region Load the Result Properties
foreach (XmlNode resultNode in configScope.NodeContext.SelectNodes(DomSqlMapBuilder.ApplyMappingNamespacePrefix(XML_RESULT), configScope.XmlNamespaceManager))
{
mapping = ResultPropertyDeSerializer.Deserialize(resultNode, configScope);
configScope.ErrorContext.MoreInfo = "initialize result property: " + mapping.PropertyName;
mapping.Initialize(configScope, _class);
_properties.Add(mapping);
}
#endregion
#region Load the Discriminator Property
XmlNode discriminatorNode = configScope.NodeContext.SelectSingleNode(DomSqlMapBuilder.ApplyMappingNamespacePrefix(XML_DISCRIMNATOR), configScope.XmlNamespaceManager);
if (discriminatorNode != null)
{
configScope.ErrorContext.MoreInfo = "initialize discriminator";
this.Discriminator = DiscriminatorDeSerializer.Deserialize(discriminatorNode, configScope);
this.Discriminator.SetMapping(configScope, _class);
}
#endregion
#region Load the SubMap Properties
if (configScope.NodeContext.SelectNodes(DomSqlMapBuilder.ApplyMappingNamespacePrefix(XML_SUBMAP), configScope.XmlNamespaceManager).Count > 0 && this.Discriminator == null)
{
throw new ConfigurationException("The discriminator is null, but somehow a subMap was reached. This is a bug.");
}
foreach (XmlNode resultNode in configScope.NodeContext.SelectNodes(DomSqlMapBuilder.ApplyMappingNamespacePrefix(XML_SUBMAP), configScope.XmlNamespaceManager))
{
configScope.ErrorContext.MoreInfo = "initialize subMap";
subMap = SubMapDeSerializer.Deserialize(resultNode, configScope);
this.Discriminator.Add(subMap);
}
#endregion
}
/// <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);
}
/// <summary>
/// Indicate if a ResultProperty is in the collection
/// </summary>
/// <param name="value">A ResultProperty</param>
/// <returns>True fi is in</returns>
public bool Contains(ResultProperty value)
{
return(Contains(value.PropertyName));
}