private static List <PocoMember> CreateDynamicDictionaryPocoMembers(IEnumerable <GroupResult <PosName> > subItems, PocoData pocoData, Type type)
{
var isDict = type != typeof(object);
var dataType = isDict ? type.GetGenericArguments().Last() : type;
return(subItems.Select(x =>
{
var member = new DynamicPocoMember
{
MemberInfoData = new MemberInfoData(x.Item, dataType, type),
PocoColumn = new ExpandoColumn
{
ColumnName = x.Item
}
};
if (isDict)
{
var pocoDataBuilder = new PocoDataBuilder(dataType, pocoData.Mapper);
member.PocoMemberChildren = pocoDataBuilder.GetPocoMembers(pocoDataBuilder.GetColumnInfos(dataType), new List <MemberInfo>()).Select(plan => plan(pocoData.TableInfo)).ToList();
member.SetDynamicMemberAccessor(new FastCreate(dataType, pocoData.Mapper));
}
return (PocoMember)member;
}).ToList());
}
public static IEnumerable <PosName> ConvertFromNewConvention(this IEnumerable <PosName> posNames, PocoData pocoData)
{
IEnumerable <PocoMember> allMembers = pocoData.GetAllMembers();
List <PocoMember> scopedPocoMembers = pocoData.Members;
string prefix = null;
foreach (PosName posName in posNames)
{
if (posName.Name.StartsWith(SplitPrefix, StringComparison.OrdinalIgnoreCase))
{
prefix = posName.Name.Substring(SplitPrefix.Length);
PocoMember relevantMembers = allMembers.SingleOrDefault(x => string.Equals(PocoColumn.GenerateKey(x.MemberInfoChain), prefix, StringComparison.OrdinalIgnoreCase));
if (relevantMembers != null)
{
scopedPocoMembers = relevantMembers.PocoMemberChildren;
}
continue;
}
PocoMember member = FindMember(scopedPocoMembers, posName.Name);
if (member != null && member.PocoColumn != null)
{
posName.Name = member.PocoColumn.MemberInfoKey;
}
else
{
posName.Name = PocoDataBuilder.JoinStrings(prefix, posName.Name);
}
yield return(posName);
}
}
private IEnumerable <MapPlan> BuildMapPlans(GroupResult <PosName> groupedName, DbDataReader dataReader, PocoData pocoData, List <PocoMember> pocoMembers)
{
// find pocomember by property name
var pocoMember = pocoMembers.FirstOrDefault(x => IsEqual(groupedName.Item, x.Name, x.PocoColumn?.ExactColumnNameMatch ?? false) ||
string.Equals(groupedName.Item, x.PocoColumn?.ColumnAlias, StringComparison.OrdinalIgnoreCase));
if (pocoMember == null)
{
yield break;
}
if (groupedName.SubItems.Any())
{
var memberInfoType = pocoMember.MemberInfoData.MemberType;
if (memberInfoType.IsAClass() || pocoMember.IsDynamic)
{
var children = PocoDataBuilder.IsDictionaryType(memberInfoType)
? CreateDynamicDictionaryPocoMembers(groupedName.SubItems, pocoData, memberInfoType)
: pocoMember.PocoMemberChildren;
var subPlans = groupedName.SubItems.SelectMany(x => BuildMapPlans(x, dataReader, pocoData, children)).ToArray();
yield return((reader, values, instance) =>
{
var newObject = pocoMember.IsList ? pocoMember.Create(dataReader) : (pocoMember.GetValue(instance) ?? pocoMember.Create(dataReader));
var shouldSetNestedObject = false;
foreach (var subPlan in subPlans)
{
shouldSetNestedObject |= subPlan(reader, values, newObject);
}
if (shouldSetNestedObject)
{
if (pocoMember.IsList)
{
var list = pocoMember.CreateList();
list.Add(newObject);
newObject = list;
}
pocoMember.SetValue(instance, newObject);
return true;
}
return false;
});
}
}
else
{
var destType = pocoMember.MemberInfoData.MemberType;
var defaultValue = MappingHelper.GetDefault(destType);
var converter = GetConverter(pocoData, pocoMember.PocoColumn, dataReader.GetFieldType(groupedName.Key.Pos), destType);
yield return((reader, values, instance) => MapValue(groupedName, values, converter, instance, pocoMember.PocoColumn, defaultValue));
}
}
private IEnumerable <MapPlan> BuildMapPlans(GroupResult <PosName> groupedName, DbDataReader dataReader, PocoData pocoData, List <PocoMember> pocoMembers)
{
// find pocomember by property name
PocoMember pocoMember = pocoMembers.FirstOrDefault(x => IsEqual(groupedName.Item, x.Name));
if (pocoMember == null)
{
yield break;
}
if (groupedName.SubItems.Any())
{
Type memberInfoType = pocoMember.MemberInfoData.MemberType;
if (memberInfoType.IsAClass() || pocoMember.IsDynamic)
{
List <PocoMember> children = PocoDataBuilder.IsDictionaryType(memberInfoType)
? CreateDynamicDictionaryPocoMembers(groupedName.SubItems, pocoData)
: pocoMember.PocoMemberChildren;
MapPlan[] subPlans = groupedName.SubItems.SelectMany(x => this.BuildMapPlans(x, dataReader, pocoData, children)).ToArray();
yield return((reader, instance) =>
{
object newObject = pocoMember.IsList ? pocoMember.Create(dataReader) : (pocoMember.GetValue(instance) ?? pocoMember.Create(dataReader));
bool shouldSetNestedObject = false;
foreach (MapPlan subPlan in subPlans)
{
shouldSetNestedObject |= subPlan(reader, newObject);
}
if (shouldSetNestedObject)
{
if (pocoMember.IsList)
{
IList list = pocoMember.CreateList();
list.Add(newObject);
newObject = list;
}
pocoMember.SetValue(instance, newObject);
return true;
}
return false;
});
}
}
else
{
Type destType = pocoMember.MemberInfoData.MemberType;
object defaultValue = MappingHelper.GetDefault(destType);
Func <object, object> converter = GetConverter(pocoData, pocoMember.PocoColumn, dataReader.GetFieldType(groupedName.Key.Pos), destType);
yield return((reader, instance) => this.MapValue(groupedName, reader, converter, instance, pocoMember.PocoColumn, defaultValue));
}
}
private static bool IsPocoMemberEqual(PocoMember pocoMember, string prefix, string name)
{
if (pocoMember.PocoColumn == null)
{
return(PropertyMapper.IsEqual(name, pocoMember.Name, false));
}
if (pocoMember.PocoColumn.MemberInfoKey == name)
{
return(true);
}
if (string.Equals(pocoMember.PocoColumn.ColumnName, PocoDataBuilder.JoinStrings(prefix, name), StringComparison.OrdinalIgnoreCase))
{
return(true);
}
if (PropertyMapper.IsEqual(name, pocoMember.PocoColumn.ColumnAlias ?? pocoMember.PocoColumn.ColumnName, pocoMember.PocoColumn.ExactColumnNameMatch))
{
return(true);
}
return(PropertyMapper.IsEqual(name, pocoMember.Name, pocoMember.PocoColumn.ExactColumnNameMatch));
}
private static IEnumerable <ColumnDefinition> GetColumnDefinitions(ConventionScannerSettings scannerSettings, Type type, List <MemberInfo> memberInfos, bool isReferenceProperty = false)
{
MemberInfo[] capturedMembers = memberInfos.ToArray();
foreach (MemberInfo member in ReflectionUtils.GetFieldsAndPropertiesForClasses(type))
{
bool complexProperty = scannerSettings.ComplexPropertiesWhere(member);
bool referenceProperty = scannerSettings.ReferencePropertiesWhere(member);
bool dbColumn = scannerSettings.DbColumnWhere(member);
if ((complexProperty || referenceProperty) && !dbColumn)
{
if (capturedMembers.GroupBy(x => x.GetMemberInfoType()).Any(x => x.Count() >= 2))
{
continue;
}
List <MemberInfo> members = new List <MemberInfo>();
members.AddRange(capturedMembers);
members.Add(member);
Type memberInfoType = member.GetMemberInfoType();
if (PocoDataBuilder.IsList(member))
{
memberInfoType = memberInfoType.GetGenericArguments().First();
}
List <ColumnDefinition> columnDefinitions = GetColumnDefinitions(scannerSettings, memberInfoType, members, referenceProperty).ToList();
foreach (ColumnDefinition columnDefinition in columnDefinitions)
{
yield return(columnDefinition);
}
string referenceDbColumnsNamed = scannerSettings.ReferenceDbColumnsNamed(member);
yield return(new ColumnDefinition()
{
MemberInfoChain = capturedMembers.Concat(new[] { member }).ToArray(),
MemberInfo = member,
IsComplexMapping = complexProperty,
IsReferenceMember = referenceProperty,
ReferenceType = ReferenceType.None,
ReferenceMember = null,
DbColumnName = referenceProperty ? referenceDbColumnsNamed : null,
});
}
else
{
ColumnDefinition columnDefinition = new ColumnDefinition();
columnDefinition.MemberInfoChain = capturedMembers.Concat(new[] { member }).ToArray();
columnDefinition.MemberInfo = member;
IEnumerable <string> prefixProperty = isReferenceProperty ? Enumerable.Empty <string>() : capturedMembers.Select(x => scannerSettings.DbColumnsNamed(x));
columnDefinition.DbColumnName = string.Join(PocoData.Separator, prefixProperty.Concat(new[] { scannerSettings.DbColumnsNamed(member) }).ToArray());
columnDefinition.DbColumnAlias = scannerSettings.AliasNamed(member);
columnDefinition.IgnoreColumn = scannerSettings.IgnorePropertiesWhere.Any(x => x.Invoke(member));
columnDefinition.DbColumnType = scannerSettings.DbColumnTypesAs(member);
columnDefinition.ResultColumn = scannerSettings.ResultPropertiesWhere(member);
columnDefinition.ComputedColumn = scannerSettings.ComputedPropertiesWhere(member);
columnDefinition.ComputedColumnType = scannerSettings.ComputedPropertyTypeAs(member);
columnDefinition.VersionColumn = scannerSettings.VersionPropertiesWhere(member);
columnDefinition.VersionColumnType = scannerSettings.VersionPropertyTypeAs(member);
columnDefinition.ForceUtc = scannerSettings.ForceDateTimesToUtcWhere(member);
columnDefinition.Serialized = scannerSettings.SerializedWhere(member);
yield return(columnDefinition);
}
}
}
