//Returns a list of materialized entities for a given resultSet representing TableEntities.
protected List <object> Materialize(IEnumerable <AnonymousType> resultSet, ProjectedType projectedType)
{
var getProjection = Get_GetProjection_Computation(projectedType, resultSet.Cast <object>());
var objects = new List <object>();
foreach (var result in resultSet)
{
var tableSource = new TableEntityRow(result);
objects.Add(getProjection(tableSource.Values[0], tableSource));
}
return(objects);
}
private Func <object, TableEntityRow, object> Get_GetProjection_Computation(ProjectedType projectedType, IEnumerable <object> resultSet)
{
//Field0 holds the originally requested object. The rest are IncludeBindings, InheritanceBindings etc.
var field0 = projectedType.Fields.First(kvp => kvp.Key.Name == FIRST_FIELD_IN_PROJECTION).Value;
return(Get_GetOrCreateEntityOrCollection_Computation(field0,
new MaterializationData
{
ProjectedType = projectedType,
ResultSet = resultSet,
InheritanceChains = new InheritanceChainLoader <T>(projectedType, entityContext).LoadUnprojectedBindings(resultSet.Cast <object>().ToList()),
ManyToManyMaps = new ManyToManyMapLoader <T>(projectedType, entityContext).LoadUnprojectedBindings(resultSet.ToList()),
}));
}
private ProjectionModification CreateMethodCallExpression(ParameterExpression parameter, List <IRelatedBinding> relatedBindings, List <IUnprojectedBinding> unprojectedBindings)
{
//We will create an AnonymousType(this type is part of AgileFx), to hold the new projection.
var typeArgs = new List <Type>();
typeArgs.Add(queryableType.NonPrimitiveEnumerableItemType.TranslatedType);
relatedBindings.ForEach(binding => typeArgs.Add(binding.TranslatedType));
var anonType = typeTranslationUtil.GetAnonymousType(typeArgs.ToArray());
var ctor = anonType.GetConstructor(Type.EmptyTypes);
var newExpression = Expression.New(ctor);
//Fields in the Projected Type
var fieldsInProjectedType = new Dictionary <MemberInfo, SimpleType>();
//The first field is the original type. This goes in as Field0.
fieldsInProjectedType.Add(anonType.GetProperties()[0], queryableType.NonPrimitiveEnumerableItemType);
var memberBindings = new List <MemberBinding>();
//The first field is the original type. This goes in as Field0.
memberBindings.Add(Expression.Bind(anonType.GetProperties()[0], parameter));
int propCounter = 1;
var anonTypeProperties = anonType.GetProperties();
foreach (var binding in relatedBindings)
{
var propInfo = anonTypeProperties[propCounter];
memberBindings.Add(Expression.Bind(propInfo, binding.TranslatedExpression));
fieldsInProjectedType.Add(propInfo, null);
propCounter++;
}
var memberInit = Expression.MemberInit(newExpression, memberBindings);
var lambda = Expression.Lambda(memberInit, parameter);
var projectedType = new ProjectedType(queryableType.NonPrimitiveEnumerableItemType.Type, anonType, ctor, null, fieldsInProjectedType,
relatedBindings, unprojectedBindings);
Func <IQueryable <object>, Expression <Func <object, object> >, IQueryable <object> > f = Queryable.Select;
var selectMethod = f.Method.GetGenericMethodDefinition().MakeGenericMethod(queryableType.NonPrimitiveEnumerableItemType.TranslatedType, anonType);
var mce = Expression.Call(null, selectMethod, currentExpression, lambda);
return(new ProjectionModification {
ModifiedExpression = mce, QueryableType = RuntimeTypes.CreateEnumerable(projectedType)
});
}
public CollectionIncludesLoader(ProjectedType projectedType, EntityContext entityContext)
{
this.projectedType = projectedType;
this.entityContext = entityContext;
//In the case of many-to-many and derived collections, includes can be handled when they are reloaded
foreach (var inc in projectedType.UnprojectedBindings
.Where(ub => ub is UnprojectedIncludeInCollectionBinding &&
!(ub.TargetBinding is UnprojectedCollectionBinding || ub.TargetBinding is UnprojectedManyToManyBinding)))
{
var includeDirective = (inc as UnprojectedIncludeInCollectionBinding).IncludeDirective;
var collSelector = includeDirective.GetSelector();
if (!includeGroups.ContainsKey(collSelector))
{
includeGroups.Add(collSelector, new List <LambdaExpression>());
}
includeGroups[collSelector].Add(((IIncludeInCollectionDirective)includeDirective).GetFieldSelector());
}
}
private bool Equals(ProjectedType other) => Equals(Order, other.Order);
public override IEnumerable <IUnprojectedBinding> GetBindingsToAnalyze(ProjectedType projectedType)
{
return(projectedType.UnprojectedBindings.Where(ub => ub is UnprojectedManyToManyBinding));
}
public ManyToManyMapLoader(ProjectedType projectedType, EntityContext entityContext)
: base(projectedType, entityContext)
{
}
protected bool Equals(ProjectedType other) => Equals(Order, other.Order);
public InheritanceChainLoader(ProjectedType projectedType, EntityContext entityContext)
: base(projectedType, entityContext)
{
}
public PostProjectionLoader(ProjectedType projectedType, EntityContext entityContext)
{
this.entityContext = entityContext;
this.projectedType = projectedType;
}
public abstract IEnumerable <IUnprojectedBinding> GetBindingsToAnalyze(ProjectedType projectionType);
