private static bool ParseAttributeInfosForParameter(DbAutoFillAttribute attribute, string modelParameterPrefix, string modelParameterSuffix, string fieldName, ref string parameterName, ref DbType?sqlType)
{
if (attribute == null)
{
return(true);
}
if (attribute.FillBehavior == DbFillBehavior.None || attribute.FillBehavior == DbFillBehavior.FromDB)
{
return(false);
}
sqlType = attribute.DbType;
string propertyPrefix = string.IsNullOrWhiteSpace(modelParameterPrefix) ? string.Empty : modelParameterPrefix;
string propertySuffix = string.IsNullOrWhiteSpace(modelParameterSuffix) ? string.Empty : modelParameterSuffix;
if (!string.IsNullOrWhiteSpace(attribute.ParameterPrefix))
{
propertyPrefix = attribute.ParameterPrefix;
}
if (!string.IsNullOrWhiteSpace(attribute.ParameterSuffix))
{
propertySuffix = attribute.ParameterSuffix;
}
parameterName = string.Join(string.Empty,
propertyPrefix,
string.IsNullOrWhiteSpace(attribute.Alias) ? fieldName : attribute.Alias,
propertySuffix);
return(true);
}
/// <summary>
/// Create and assign the parameters to the given DbCommand object.
/// Parameters created from the names and values from the object.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="command"></param>
/// <param name="obj"></param>
/// <exception cref="ArgumentNullException"></exception>
public static void FillDbParametersFromObject <T>(IDbCommand command, T obj)
{
if (command == null)
{
throw new ArgumentNullException("command");
}
if (obj == null)
{
throw new ArgumentNullException("obj");
}
Type modelType = obj.GetType();
DbAutoFillAttribute modelAttribute = modelType
.GetCustomAttributes(typeof(DbAutoFillAttribute), true)
.FirstOrDefault() as DbAutoFillAttribute;
if (modelAttribute != null)
{
if (modelAttribute.FillBehavior == DbFillBehavior.None || modelAttribute.FillBehavior == DbFillBehavior.FromDB)
{
return;
}
}
PropertyInfo[] propertyInfos = modelType.GetProperties();
FieldInfo[] fieldInfos = modelType.GetFields();
string paramPrefix = string.IsNullOrWhiteSpace(modelAttribute.ParameterPrefix) ? string.Empty : modelAttribute.ParameterPrefix;
string paramSuffix = string.IsNullOrWhiteSpace(modelAttribute.ParameterSuffix) ? string.Empty : modelAttribute.ParameterSuffix;
AddParametersFromMemberInfos(command, obj, propertyInfos, modelAttribute, paramPrefix, paramSuffix);
AddParametersFromMemberInfos(command, obj, fieldInfos, modelAttribute, paramPrefix, paramSuffix);
}
private static void SetMembersValuesFromDataReader <T>(IDataReader reader, T obj, MemberInfo[] memberInfos, string[] lstDbFields, DbAutoFillAttribute modelAttribute)
{
foreach (MemberInfo mi in memberInfos)
{
DbAutoFillAttribute memberAttribute = mi.GetCustomAttributes(typeof(DbAutoFillAttribute), false)
.FirstOrDefault() as DbAutoFillAttribute;
if (memberAttribute == null && modelAttribute == null)
{
continue;
}
SetValueForObjectMember(reader, obj, mi, memberAttribute, mi.Name, lstDbFields);
}
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="command"></param>
/// <param name="obj"></param>
/// <param name="memberInfos"></param>
/// <param name="modelAttribute"></param>
/// <param name="modelParameterPrefix"></param>
/// <param name="modelParameterSuffix"></param>
private static void AddParametersFromMemberInfos <T>(IDbCommand command, T obj, MemberInfo[] memberInfos, DbAutoFillAttribute modelAttribute, string modelParameterPrefix, string modelParameterSuffix)
{
foreach (MemberInfo mi in memberInfos)
{
DbAutoFillAttribute memberAttribute = mi.GetCustomAttributes(typeof(DbAutoFillAttribute), false)
.FirstOrDefault() as DbAutoFillAttribute;
if (memberAttribute == null && modelAttribute == null)
{
continue;
}
AddParameterFromAttribute(command, obj, modelParameterPrefix, modelParameterSuffix, mi.Name, memberAttribute);
}
}
/// <summary>
/// Fills the model fromthe result set / data reader.
/// It uses the DbAutoFillAttribute to fill the object.
///
/// After a call to this method, the model should contain the data properly.
/// </summary>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="InvalidOperationException"></exception>
/// <exception cref="TypeLoadException"></exception>
/// <exception cref="MissingFieldException"></exception>
public static void FillObjectFromDataReader <T>(IDataReader dataReader, T obj)
where T : new()
{
if (obj == null)
{
throw new ArgumentNullException("obj");
}
if (dataReader == null)
{
throw new ArgumentNullException("dataReader");
}
Type modelType = obj.GetType();
if (modelType.IsSubclassOf(typeof(IDbAnonymousValue)))
{
SetDbAnonymousValueFromDataReader(obj as IDbAnonymousValue, dataReader);
return;
}
DbAutoFillAttribute modelAttribute = Attribute.GetCustomAttribute(modelType, typeof(DbAutoFillAttribute)) as DbAutoFillAttribute;
if (modelAttribute != null)
{
if (modelAttribute.FillBehavior == DbFillBehavior.None || modelAttribute.FillBehavior == DbFillBehavior.ToDB)
{
return;
}
}
PropertyInfo[] modelProperties = modelType.GetProperties();
FieldInfo[] modelFields = modelType.GetFields();
string[] lstDbFields = DataReaderUtils.GetFieldsFromDataReader(dataReader);
SetMembersValuesFromDataReader(dataReader, obj, modelProperties, lstDbFields, modelAttribute);
SetMembersValuesFromDataReader(dataReader, obj, modelFields, lstDbFields, modelAttribute);
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="cmd"></param>
/// <param name="model"></param>
/// <param name="modelParameterPrefix"></param>
/// <param name="modelParameterSuffix"></param>
/// <param name="memberName"></param>
/// <param name="propertyAttribute"></param>
private static void AddParameterFromAttribute <T>(IDbCommand cmd, T model, string modelParameterPrefix, string modelParameterSuffix, string memberName, DbAutoFillAttribute propertyAttribute)
{
string parameterName = modelParameterPrefix + memberName + modelParameterSuffix;
DbType?sqlType = null;
if (!ParseAttributeInfosForParameter(propertyAttribute, modelParameterPrefix, modelParameterSuffix, memberName, ref parameterName, ref sqlType))
{
return;
}
object parameterValue = null;
Type modelType = model.GetType();
{
PropertyInfo pi = modelType.GetProperty(memberName);
if (pi == null)
{
FieldInfo fi = modelType.GetField(memberName);
parameterValue = fi.GetValue(model);
}
else
{
parameterValue = pi.GetValue(model, null);
}
}
AddParameterWithValue(cmd, parameterName, parameterValue, sqlType);
}
/// <summary>
///
/// </summary>
/// <exception cref="MissingFieldException"></exception>
/// <exception cref="ArgumentException"></exception>
private static void SetValueForObjectMember <T>(IDataReader reader, T obj, MemberInfo memberInfo, DbAutoFillAttribute attribute, string fieldName, string[] lstDbFields)
{
string columnName = fieldName;
if (attribute != null)
{
if (attribute.FillBehavior == DbFillBehavior.None || attribute.FillBehavior == DbFillBehavior.ToDB)
{
return;
}
columnName = attribute.Alias ?? fieldName;
}
bool hasFieldInReader = lstDbFields.Contains(columnName);
if (!hasFieldInReader)
{
if (attribute != null && attribute.AllowMissing)
{
return;
}
throw new MissingFieldException(string.Format("No column named '{0}' in reader for object '{1}'.", columnName, obj.GetType().FullName));
}
object value;
if (reader.IsDBNull(reader.GetOrdinal(columnName)))
{
value = null;
}
if (memberInfo is PropertyInfo)
{
PropertyInfo pi = memberInfo as PropertyInfo;
value = GetValueFromColumn(pi.PropertyType, reader[columnName]);
pi.SetValue(obj, value, null);
}
else if (memberInfo is FieldInfo)
{
FieldInfo fi = memberInfo as FieldInfo;
value = GetValueFromColumn(fi.FieldType, reader[columnName]);
fi.SetValue(obj, value);
}
else
{
throw new ArgumentException("memberInfo", "Unsupported field type");
}
}
