public static ChainMemberNode CloneChainMemberNode(this ChainMemberNode node, ChainNode parent) { var child = new ChainMemberNode(node.Type, node.Expression, /* node.MemberInfo,*/ node.MemberName, /*node.ChainMemberNodeExpressionType,*/ node.IsEnumerable, parent); parent.Children.Add(node.MemberName, child); return(child); }
private static int AddLevelRecursive(ChainNode root, ChainMemberNode[] parents, int number, Expression inExpression, out Expression outExpression) { var @value = number; var node = parents.Length == 0 ? root : parents[parents.Length - 1]; outExpression = null; foreach (var childPair in node.Children) { var memberNode = childPair.Value; var modifiedParents = new ChainMemberNode[parents.Length + 1]; parents.CopyTo(modifiedParents, 0); modifiedParents[parents.Length] = memberNode; if (memberNode.Children.Count != 0) { @value = AddLevelRecursive(root, modifiedParents, @value, inExpression, out outExpression); inExpression = outExpression; } else { @value = AddMember(root, modifiedParents, @value, inExpression, out outExpression); inExpression = outExpression; } } return(@value); }
public static ChainMemberNode AddChild(this ChainNode node, FieldInfo fieldInfo) { var expression = node.Type.CreateFieldLambda(fieldInfo); var child = new ChainMemberNode(fieldInfo.FieldType, expression, fieldInfo.Name, isEnumerable: false, node); node.Children.Add(fieldInfo.Name, child); return(child); }
public static ChainMemberNode AddChild(this ChainNode node, PropertyInfo propertyInfo) { var expression = node.Type.CreatePropertyLambda(propertyInfo); var child = new ChainMemberNode(propertyInfo.PropertyType, expression, propertyInfo.Name, isEnumerable: false, node); node.Children.Add(propertyInfo.Name, child); return(child); }
public void Parse <TThenEntity, TEntity>(Expression <Func <TThenEntity, TEntity> > navigationExpression, bool changeCurrenNode, string memberName) { var node = AddIfAbsent(CurrentNode, navigationExpression, memberName, typeof(TEntity), null, false); if (changeCurrenNode) { CurrentNode = node; } }
private static ChainMemberNode AddIfAbsent( ChainNode parent, LambdaExpression lambdaExpression, string memberName, Type navigationType, Type navigationEnumerableType, bool isEnumerable ) { var dictionary = parent.Children; if (memberName != null) { if (!dictionary.TryGetValue(memberName, out ChainMemberNode node)) { node = new ChainMemberNode(navigationType, lambdaExpression, memberName, isEnumerable, parent); dictionary.Add(memberName, node); } return(node); } else { if (lambdaExpression.Body is MemberExpression) { var memberInfo = ((MemberExpression)lambdaExpression.Body).Member; var name = memberInfo.Name; if (!dictionary.TryGetValue(name, out ChainMemberNode node)) { node = new ChainMemberNode(navigationType, lambdaExpression, name, isEnumerable, parent); dictionary.Add(name, node); } return(node); } else if (lambdaExpression.Body is MethodCallExpression) { var methodInfo = ((MethodCallExpression)lambdaExpression.Body).Method; var name = methodInfo.Name; if (!dictionary.TryGetValue(name, out ChainMemberNode node)) { node = new ChainMemberNode(navigationType, lambdaExpression, name, isEnumerable, parent); dictionary.Add(name, node); } return(node); } else { throw new NotSupportedException("Not supported type of expression: neither member, neither method call"); } } }
public static Include <T> ComposeInclude <T>(this ChainNode root) { var parents = new ChainMemberNode[0]; var entityType = root.Type; Type rootChainType = typeof(Chain <>).MakeGenericType(entityType); ParameterExpression tParameterExpression = Expression.Parameter(rootChainType, "t"); int number = AddLevelRecursive(root, parents, 0, tParameterExpression, out Expression outExpression); Include <T> @destination = null; if (outExpression != null) { var lambdaExpression = Expression.Lambda <Include <T> >(outExpression, new[] { tParameterExpression }); @destination = lambdaExpression.Compile(); } return(@destination); }
public static ChainNode FindLinkedRootPath(ChainMemberNode node) => TreeExtensions.FindLinkedRootPath(meta, node);
public static bool FindNode(ChainNode root, string[] path, out ChainMemberNode node) => TreeExtensions.FindNode(meta, root, path, out node);
public void ParseRootEnumerable <TEntity>(Expression <Func <TRootEntity, IEnumerable <TEntity> > > navigationExpression, string memberName) { var node = AddIfAbsent(Root, navigationExpression, memberName, typeof(TEntity), typeof(IEnumerable <TEntity>), true); CurrentNode = node; }
public void ParseRoot <TEntity>(Expression <Func <TRootEntity, TEntity> > navigationExpression, string memberName) { var node = AddIfAbsent(Root, navigationExpression, memberName, typeof(TEntity), null, false); CurrentNode = node; }