private void BuildConverter()
{
Type itemType = isKeyConverter ? entityTypestoredInKey : typeof(TItem);
int index = 0;
ParameterExpression parameterExpression = Expression.Parameter(itemType, "item");
IEnumerable <Type> types = EnumerableUtils <Type> .Empty;
if (IsPersistableType(itemType))
{
Expression = (Expression)BuildField(itemType, ref index, ref types);
TupleDescriptor = TupleDescriptor.Create(types);
}
else
{
Xtensive.Collections.ISet <Type> processedTypes = new Set <Type>();
LocalCollectionExpression itemExpression = BuildLocalCollectionExpression(itemType, processedTypes, ref index, null, ref types);
TupleDescriptor = TupleDescriptor.Create(types);
Expression = itemExpression;
}
Func <TItem, Tuple> converter = delegate(TItem item) {
RegularTuple tuple = Tuple.Create(TupleDescriptor);
if (ReferenceEquals(item, null))
{
return(tuple);
}
int offset = 0;
FillLocalCollectionField(item, tuple, Expression);
return(tuple);
};
this.converter = converter;
}
protected override Expression VisitLocalCollectionExpression(LocalCollectionExpression expression)
{
foreach (var field in expression.Fields)
{
Visit((Expression)field.Value);
}
return(expression);
}
private LocalCollectionExpression BuildLocalCollectionExpression(Type type, Xtensive.Collections.ISet <Type> processedTypes, ref int columnIndex, MemberInfo parentMember, ref IEnumerable <Type> types)
{
if (type.IsAssignableFrom(typeof(Key)))
{
throw new InvalidOperationException(String.Format(Strings.ExUnableToStoreUntypedKeyToStorage, typeof(Ref <>).GetShortName()));
}
if (!processedTypes.Add(type))
{
throw new InvalidOperationException(String.Format(Strings.ExUnableToPersistTypeXBecauseOfLoopReference, type.FullName));
}
IEnumerable <MemberInfo> members = type
.GetProperties(BindingFlags.Instance | BindingFlags.Public)
.Where(propertyInfo => propertyInfo.CanRead)
.Cast <MemberInfo>()
.Concat(type.GetFields(BindingFlags.Instance | BindingFlags.Public));
var fields = new Dictionary <MemberInfo, IMappedExpression>();
foreach (MemberInfo memberInfo in members)
{
var propertyInfo = memberInfo as PropertyInfo;
Type memberType = propertyInfo == null
? ((FieldInfo)memberInfo).FieldType
: propertyInfo.PropertyType;
if (IsPersistableType(memberType))
{
IMappedExpression expression = BuildField(memberType, ref columnIndex, ref types);
fields.Add(memberInfo, expression);
}
else
{
LocalCollectionExpression collectionExpression = BuildLocalCollectionExpression(memberType, new Set <Type>(processedTypes), ref columnIndex, memberInfo, ref types);
fields.Add(memberInfo, collectionExpression);
}
}
if (fields.Count == 0)
{
throw new InvalidOperationException(String.Format(Strings.ExTypeXDoesNotHasAnyPublicReadablePropertiesOrFieldsSoItCanTBePersistedToStorage, type.FullName));
}
var result = new LocalCollectionExpression(type, parentMember, sourceExpression);
result.Fields = fields;
return(result);
}
protected override Expression VisitLocalCollectionExpression(LocalCollectionExpression expression)
{
throw new NotSupportedException(String.Format(Strings.ExUnableToMaterializeBackLocalCollectionItem, expression.SourceExpression));
}
protected virtual Expression VisitLocalCollectionExpression(LocalCollectionExpression expression)
{
return(expression);
}
