public static EntityFieldExpression CreateEntityField(FieldInfo entityField, int offset)
{
if (!entityField.IsEntity)
{
throw new ArgumentException(string.Format(Strings.ExFieldXIsNotEntity, entityField.Name), nameof(entityField));
}
var entityType = entityField.ValueType;
var persistentType = entityField.ReflectedType.Model.Types[entityType];
var mappingInfo = entityField.MappingInfo;
var mapping = new Segment <int>(mappingInfo.Offset + offset, mappingInfo.Length);
var keyFields = persistentType.Key.Fields;
var keyExpression = KeyExpression.Create(persistentType, offset + mappingInfo.Offset);
var fields = new List <PersistentFieldExpression>(keyFields.Count + 1)
{
keyExpression
};
foreach (var field in keyFields)
{
// Do not convert to LINQ. We want to avoid a closure creation here.
fields.Add(BuildNestedFieldExpression(field, offset + mappingInfo.Offset));
}
return(new EntityFieldExpression(persistentType, entityField, fields, mapping, keyExpression, null, null, false));
}
public static EntityExpression Create(TypeInfo typeInfo, int offset, bool keyFieldsOnly)
{
if (!typeInfo.IsEntity && !typeInfo.IsInterface)
{
throw new ArgumentException(string.Format(Strings.ExPersistentTypeXIsNotEntityOrPersistentInterface, typeInfo.Name), "typeInfo");
}
var fields = new List <PersistentFieldExpression>();
var keyExpression = KeyExpression.Create(typeInfo, offset);
fields.Add(keyExpression);
var result = new EntityExpression(typeInfo, keyExpression, null, false);
if (keyFieldsOnly)
{
// Add key fields to field collection
var keyFieldClones = keyExpression
.KeyFields
.Select(kf => FieldExpression.CreateField(kf.Field, offset))
.Cast <PersistentFieldExpression>();
fields.AddRange(keyFieldClones);
}
else
{
foreach (var nestedField in typeInfo.Fields)
{
fields.Add(BuildNestedFieldExpression(nestedField, offset));
}
}
result.Fields = fields;
return(result);
}
public static EntityFieldExpression CreateEntityField(FieldInfo entityField, int offset)
{
if (!entityField.IsEntity)
{
throw new ArgumentException(string.Format(Strings.ExFieldXIsNotEntity, entityField.Name), "entityField");
}
var entityType = entityField.ValueType;
var persistentType = entityField.ReflectedType.Model.Types[entityType];
var mapping = new Segment <int>(entityField.MappingInfo.Offset + offset, entityField.MappingInfo.Length);
var fields = new List <PersistentFieldExpression>();
var keyExpression = KeyExpression.Create(persistentType, offset + entityField.MappingInfo.Offset);
fields.Add(keyExpression);
foreach (var keyField in persistentType.Fields.Where(f => f.IsPrimaryKey))
{
fields.Add(BuildNestedFieldExpression(keyField, offset + entityField.MappingInfo.Offset));
}
return(new EntityFieldExpression(persistentType, entityField, fields, mapping, keyExpression, null, null, false));
}
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>()));
}
