public override Expression Remap(int offset, Dictionary <Expression, Expression> processedExpressions)
{
if (!CanRemap)
{
return(this);
}
Expression result;
if (processedExpressions.TryGetValue(this, out result))
{
return(result);
}
var fields = Fields
.Select(f => f.Remap(offset, processedExpressions))
.Cast <PersistentFieldExpression>()
.ToList();
var keyExpression = (KeyExpression)Key.Remap(offset, processedExpressions);
var entity = Entity != null
? (EntityExpression)Entity.Remap(offset, processedExpressions)
: null;
result = new EntityFieldExpression(PersistentType, Field, fields, keyExpression.Mapping, keyExpression, entity, OuterParameter, DefaultIfEmpty);
if (Owner == null)
{
return(result);
}
processedExpressions.Add(this, result);
Owner.Remap(offset, processedExpressions);
return(result);
}
public override Expression BindParameter(ParameterExpression parameter, Dictionary <Expression, Expression> processedExpressions)
{
Expression result;
if (processedExpressions.TryGetValue(this, out result))
{
return(result);
}
var fields = Fields
.Select(f => f.BindParameter(parameter, processedExpressions))
.Cast <PersistentFieldExpression>()
.ToList();
var keyExpression = (KeyExpression)Key.BindParameter(parameter, processedExpressions);
var entity = Entity != null
? (EntityExpression)Entity.BindParameter(parameter, processedExpressions)
: null;
result = new EntityFieldExpression(PersistentType, Field, fields, Mapping, keyExpression, entity, parameter, DefaultIfEmpty);
if (Owner == null)
{
return(result);
}
processedExpressions.Add(this, result);
Owner.BindParameter(parameter, processedExpressions);
return(result);
}
public override Expression Remap(int offset, Dictionary <Expression, Expression> processedExpressions)
{
if (!CanRemap)
{
return(this);
}
if (processedExpressions.TryGetValue(this, out var result))
{
return(result);
}
var newFields = new List <PersistentFieldExpression>(fields.Count);
foreach (var field in fields)
{
// Do not convert to LINQ. We want to avoid a closure creation here.
newFields.Add((PersistentFieldExpression)field.Remap(offset, processedExpressions));
}
var keyExpression = (KeyExpression)Key.Remap(offset, processedExpressions);
var entity = (EntityExpression)Entity?.Remap(offset, processedExpressions);
result = new EntityFieldExpression(
PersistentType, Field, newFields, keyExpression.Mapping, keyExpression, entity, OuterParameter, DefaultIfEmpty);
if (Owner == null)
{
return(result);
}
processedExpressions.Add(this, result);
Owner.Remap(offset, processedExpressions);
return(result);
}
public override Expression Remap(int[] map, Dictionary <Expression, Expression> processedExpressions)
{
if (!CanRemap)
{
return(this);
}
if (processedExpressions.TryGetValue(this, out var result))
{
return(result);
}
var newFields = new List <PersistentFieldExpression>(fields.Count);
using (new SkipOwnerCheckScope()) {
foreach (var field in fields)
{
// Do not convert to LINQ. We want to avoid a closure creation here.
var mappedField = (PersistentFieldExpression)field.Remap(map, processedExpressions);
if (mappedField == null)
{
continue;
}
newFields.Add(mappedField);
}
}
if (newFields.Count != Fields.Count)
{
processedExpressions.Add(this, null);
return(null);
}
var keyExpression = (KeyExpression)Key.Remap(map, processedExpressions);
EntityExpression entity;
using (new SkipOwnerCheckScope()) {
entity = (EntityExpression)Entity?.Remap(map, processedExpressions);
}
result = new EntityFieldExpression(
PersistentType, Field, newFields, keyExpression.Mapping, keyExpression, entity, OuterParameter, DefaultIfEmpty);
if (Owner == null)
{
return(result);
}
processedExpressions.Add(this, result);
Owner.Remap(map, processedExpressions);
return(result);
}
// ReSharper disable RedundantNameQualifier
private static PersistentFieldExpression BuildNestedFieldExpression(FieldInfo nestedField, int offset)
{
if (nestedField.IsPrimitive)
{
return(FieldExpression.CreateField(nestedField, offset));
}
if (nestedField.IsStructure)
{
return(StructureFieldExpression.CreateStructure(nestedField, offset));
}
if (nestedField.IsEntity)
{
return(EntityFieldExpression.CreateEntityField(nestedField, offset));
}
throw new NotSupportedException(string.Format(Strings.ExNestedFieldXIsNotSupported, nestedField.Attributes));
}
public override Expression Remap(int[] map, Dictionary <Expression, Expression> processedExpressions)
{
if (!CanRemap)
{
return(this);
}
Expression result;
if (processedExpressions.TryGetValue(this, out result))
{
return(result);
}
List <PersistentFieldExpression> fields;
using (new SkipOwnerCheckScope()) {
fields = Fields
.Select(f => f.Remap(map, processedExpressions))
.Where(f => f != null)
.Cast <PersistentFieldExpression>()
.ToList();
}
if (fields.Count != Fields.Count)
{
processedExpressions.Add(this, null);
return(null);
}
var keyExpression = (KeyExpression)Key.Remap(map, processedExpressions);
EntityExpression entity;
using (new SkipOwnerCheckScope())
entity = Entity != null
? (EntityExpression)Entity.Remap(map, processedExpressions)
: null;
result = new EntityFieldExpression(PersistentType, Field, fields, keyExpression.Mapping, keyExpression, entity, OuterParameter, DefaultIfEmpty);
if (Owner == null)
{
return(result);
}
processedExpressions.Add(this, result);
Owner.Remap(map, processedExpressions);
return(result);
}
public static EntityExpression Create(EntityFieldExpression entityFieldExpression, int offset)
{
var typeInfo = entityFieldExpression.PersistentType;
var fields = new List <PersistentFieldExpression>();
var keyExpression = KeyExpression.Create(typeInfo, offset);
fields.Add(keyExpression);
foreach (var nestedField in typeInfo.Fields)
{
fields.Add(BuildNestedFieldExpression(nestedField, offset));
}
var result = new EntityExpression(typeInfo, keyExpression, null, entityFieldExpression.DefaultIfEmpty)
{
Fields = fields
};
if (entityFieldExpression.OuterParameter == null)
{
return(result);
}
return((EntityExpression)result.BindParameter(entityFieldExpression.OuterParameter, new Dictionary <Expression, Expression>()));
}
