omg finally.
This commit is contained in:
David Lebée
@@ -1,231 +0,0 @@
|
||||
using PoweredSoft.DynamicLinq.Dal.Pocos;
|
||||
using PoweredSoft.DynamicLinq.Helpers;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Linq.Expressions;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
#if false
|
||||
|
||||
namespace PoweredSoft.DynamicLinq.ConsoleApp
|
||||
{
|
||||
public class StaticProto1
|
||||
{
|
||||
public static void Run()
|
||||
{
|
||||
var q = new List<Author>().AsQueryable();
|
||||
q.Select(t => new
|
||||
{
|
||||
Ids = t.Posts.SelectMany(t2 => t2.Comments.Select(t3 => t3.CommentLikes))
|
||||
});
|
||||
|
||||
var expressionParser = new ExpressionParser(typeof(Author), "Posts.Comments.CommentLikes");
|
||||
expressionParser.Parse();
|
||||
|
||||
var finalExpression = CreateSelectExpressionFromParsed(expressionParser, SelectCollectionHandling.Flatten, SelectNullHandling.New);
|
||||
}
|
||||
|
||||
public static Expression CreateSelectExpressionFromParsed(ExpressionParser expressionParser,
|
||||
SelectCollectionHandling selectCollectionHandling = SelectCollectionHandling.LeaveAsIs,
|
||||
SelectNullHandling nullChecking = SelectNullHandling.LeaveAsIs)
|
||||
{
|
||||
Type nullHandlingRightType = null;
|
||||
Expression nullHandlingNullValue = null;
|
||||
|
||||
if (nullChecking != SelectNullHandling.LeaveAsIs)
|
||||
{
|
||||
var withoutNullCheckResult = CreateSelectExpressionFromParsed(expressionParser, SelectCollectionHandling.Flatten, SelectNullHandling.LeaveAsIs);
|
||||
if (QueryableHelpers.IsGenericEnumerable(withoutNullCheckResult.Type))
|
||||
nullHandlingRightType = typeof(List<>).MakeGenericType(withoutNullCheckResult.Type.GenericTypeArguments.First());
|
||||
else
|
||||
nullHandlingRightType = withoutNullCheckResult.Type;
|
||||
|
||||
nullHandlingNullValue = nullChecking == SelectNullHandling.Default
|
||||
? Expression.Default(nullHandlingRightType) as Expression
|
||||
: Expression.New(nullHandlingRightType) as Expression;
|
||||
}
|
||||
|
||||
// reversed :)
|
||||
var reversedCopy = expressionParser.Groups.Select(t => t).ToList();
|
||||
reversedCopy.Reverse();
|
||||
|
||||
MethodCallExpression lastSelectExpression = null;
|
||||
Expression ret = null;
|
||||
|
||||
foreach (var t in reversedCopy)
|
||||
{
|
||||
if (true == t.Parent?.LastPiece().IsGenericEnumerable())
|
||||
{
|
||||
if (lastSelectExpression == null)
|
||||
lastSelectExpression = RegroupSelectExpressions(t, selectCollectionHandling);
|
||||
else
|
||||
lastSelectExpression = RegroupSelectExpressions(t, lastSelectExpression, selectCollectionHandling);
|
||||
}
|
||||
}
|
||||
|
||||
ret = lastSelectExpression;
|
||||
return ret;
|
||||
}
|
||||
|
||||
public static MethodCallExpression RegroupSelectExpressions(ExpressionParameterGroup group, SelectCollectionHandling selectCollectionHandling)
|
||||
{
|
||||
MethodCallExpression ret = null;
|
||||
var lambda = group.CreateLambda();
|
||||
var parentExpression = group.Parent.LastExpression();
|
||||
var isParentExpressionGenericEnumerable = QueryableHelpers.IsGenericEnumerable(parentExpression);
|
||||
var parentExpressionGenericEnumerableType = isParentExpressionGenericEnumerable ? parentExpression.Type.GenericTypeArguments.First() : null;
|
||||
var lastPiece = group.LastPiece();
|
||||
|
||||
if (selectCollectionHandling == SelectCollectionHandling.LeaveAsIs || !lastPiece.IsGenericEnumerable())
|
||||
ret = Expression.Call(typeof(Enumerable), "Select", new Type[] { parentExpressionGenericEnumerableType, lastPiece.Expression.Type }, parentExpression, lambda);
|
||||
else
|
||||
ret = Expression.Call(typeof(Enumerable), "SelectMany", new Type[] { parentExpressionGenericEnumerableType, lastPiece.GetGenericEnumerableType() }, parentExpression, lambda);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
public static MethodCallExpression RegroupSelectExpressions(ExpressionParameterGroup group, MethodCallExpression innerSelect, SelectCollectionHandling selectCollectionHandling)
|
||||
{
|
||||
var parent = group.Parent;
|
||||
var parentLastPiece = parent.LastPiece();
|
||||
|
||||
MethodCallExpression ret = null;
|
||||
var lambda = Expression.Lambda(innerSelect, group.Parameter);
|
||||
if (selectCollectionHandling == SelectCollectionHandling.LeaveAsIs)
|
||||
ret = Expression.Call(typeof(Enumerable), "Select", new Type[] { parentLastPiece.GetGenericEnumerableType(), innerSelect.Type }, parentLastPiece.Expression, lambda);
|
||||
else
|
||||
ret = Expression.Call(typeof(Enumerable), "SelectMany", new Type[] { parentLastPiece.GetGenericEnumerableType(), innerSelect.Type.GenericTypeArguments.First() }, parentLastPiece.Expression, lambda);
|
||||
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public class ExpressionParameterGroup
|
||||
{
|
||||
public ExpressionParameterGroup Parent { get; set; }
|
||||
public ParameterExpression Parameter { get; set; }
|
||||
public List<ExpressionPiece> Pieces { get; set; } = new List<ExpressionPiece>();
|
||||
|
||||
public ExpressionParameterGroup(ParameterExpression parameter)
|
||||
{
|
||||
Parameter = parameter;
|
||||
}
|
||||
|
||||
public void AddSubPart(ExpressionPiece expressionPart)
|
||||
{
|
||||
Pieces.Add(expressionPart);
|
||||
}
|
||||
|
||||
public Expression LastExpression() => LastPiece().Expression;
|
||||
|
||||
public ExpressionPiece LastPiece() => Pieces.Last();
|
||||
|
||||
public LambdaExpression CreateLambda()
|
||||
{
|
||||
var lastExpression = LastPiece().Expression;
|
||||
var lambda = Expression.Lambda(lastExpression, Parameter);
|
||||
return lambda;
|
||||
}
|
||||
}
|
||||
|
||||
public class ExpressionPiece
|
||||
{
|
||||
public ExpressionParameterGroup Parameter { get; set; }
|
||||
public ExpressionPiece Parent { get; set; }
|
||||
public Expression Expression { get; set; }
|
||||
|
||||
public ExpressionPiece(ExpressionParameterGroup parameter, ExpressionPiece parent = null)
|
||||
{
|
||||
Parameter = parameter;
|
||||
Parent = parent;
|
||||
}
|
||||
|
||||
public void Resolve(string piece)
|
||||
{
|
||||
Expression = Expression.PropertyOrField(Parent?.Expression ?? Parameter.Parameter, piece);
|
||||
}
|
||||
|
||||
public bool IsGenericEnumerable() => QueryableHelpers.IsGenericEnumerable(Expression);
|
||||
public Type GetGenericEnumerableType() => Expression.Type.GenericTypeArguments.First();
|
||||
}
|
||||
|
||||
public class ExpressionParser
|
||||
{
|
||||
public ParameterExpression Parameter { get; protected set; }
|
||||
public string Path { get; protected set; }
|
||||
public List<ExpressionParameterGroup> Groups { get; set; } = new List<ExpressionParameterGroup>();
|
||||
|
||||
public ExpressionParser(Type type, string path) : this(Expression.Parameter(type), path)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
public ExpressionParser(ParameterExpression parameter, string path)
|
||||
{
|
||||
if (parameter == null)
|
||||
throw new ArgumentNullException("parameter");
|
||||
|
||||
if (string.IsNullOrEmpty(path))
|
||||
throw new ArgumentNullException("path");
|
||||
|
||||
Parameter = parameter;
|
||||
Path = path;
|
||||
}
|
||||
|
||||
public void Parse()
|
||||
{
|
||||
Groups = new List<ExpressionParameterGroup>();
|
||||
var pieces = Path.Split('.').ToList();
|
||||
|
||||
// create the current parameter.
|
||||
var currentGroup = CreateAndAddParameterGroup(Parameter);
|
||||
ExpressionPiece parentPiece = null;
|
||||
|
||||
int indexOfPiece = -1;
|
||||
pieces.ForEach(piece =>
|
||||
{
|
||||
++indexOfPiece;
|
||||
bool isLast = indexOfPiece == pieces.Count - 1;
|
||||
|
||||
var expressionPiece = new ExpressionPiece(currentGroup, parentPiece);
|
||||
expressionPiece.Resolve(piece);
|
||||
currentGroup.AddSubPart(expressionPiece);
|
||||
|
||||
// rest is only if its not the last piece.
|
||||
if (isLast) return;
|
||||
|
||||
if (expressionPiece.IsGenericEnumerable())
|
||||
{
|
||||
var param = Expression.Parameter(expressionPiece.GetGenericEnumerableType());
|
||||
currentGroup = CreateAndAddParameterGroup(param, currentGroup);
|
||||
parentPiece = null;
|
||||
}
|
||||
else
|
||||
{
|
||||
parentPiece = expressionPiece;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
public ExpressionParameterGroup CreateAndAddParameterGroup(ParameterExpression parameter, ExpressionParameterGroup parent = null)
|
||||
{
|
||||
var group = new ExpressionParameterGroup(parameter);
|
||||
|
||||
if (parent != null)
|
||||
group.Parent = parent;
|
||||
|
||||
Groups.Add(group);
|
||||
return group;
|
||||
}
|
||||
|
||||
public ExpressionParameterGroup LastGroup()
|
||||
{
|
||||
return this.Groups.Last();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@@ -1,217 +0,0 @@
|
||||
using PoweredSoft.DynamicLinq.Dal.Pocos;
|
||||
using PoweredSoft.DynamicLinq.Helpers;
|
||||
using PoweredSoft.DynamicLinq.Parser;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Linq.Expressions;
|
||||
|
||||
namespace PoweredSoft.DynamicLinq.ConsoleApp
|
||||
{
|
||||
public class BetterProto2
|
||||
{
|
||||
/*
|
||||
* (parent, innerExpression, innerExpressionLambda) =>
|
||||
{
|
||||
var listGenericArgumentType = parent.Type.GetGenericArguments().First();
|
||||
Expression ret = null;
|
||||
if (selectCollectionHandling == SelectCollectionHandling.LeaveAsIs || !QueryableHelpers.IsGenericEnumerable(innerExpression))
|
||||
ret = Expression.Call(typeof(Enumerable), "Select", new Type[] { listGenericArgumentType, innerExpression.Type }, parent, innerExpressionLambda);
|
||||
else
|
||||
ret = Expression.Call(typeof(Enumerable), "SelectMany", new Type[] { listGenericArgumentType, innerExpression.Type.GenericTypeArguments.First() }, parent, innerExpressionLambda);
|
||||
|
||||
return ret;
|
||||
}
|
||||
*/
|
||||
public static void Run()
|
||||
{
|
||||
//Case1();
|
||||
Case2();
|
||||
}
|
||||
|
||||
public static void Case1()
|
||||
{
|
||||
// the expression parser.
|
||||
var ep = new ExpressionParser(typeof(Author), "Posts.Comments.Id");
|
||||
|
||||
// the builder.
|
||||
var per = new PathExpressionResolver(ep);
|
||||
per.Resolve();
|
||||
|
||||
// the result expression.
|
||||
var result = per.Result;
|
||||
}
|
||||
|
||||
public static void Case2()
|
||||
{
|
||||
// the expression parser.
|
||||
var ep = new ExpressionParser(typeof(Author), "Posts.Author.Website.Url");
|
||||
|
||||
new List<Author>().AsQueryable().Select(t => new
|
||||
{
|
||||
A = t.Posts.Select(t2 => t2.Author.Posts.Select(t3 => t3.Author.Website.Url)) ,
|
||||
B = t.Posts.Where(t2 => t2.Author != null).Select(t2 => t2.Author.Posts.Where(t3 => t3.Author != null && t3.Author.Website != null).Select(t3 => t3.Author.Website.Url))
|
||||
});
|
||||
|
||||
new List<Post>().AsQueryable().Select(t => new
|
||||
{
|
||||
FirstNames = t.Author == null ? new List<string>() : (t.Author.Posts == null ? new List<string>() : t.Author.Posts.Where(t2 => t2.Author != null).Select(t2 => t2.Author.FirstName)),
|
||||
PostsAuthors = t.Author == null ? new List<Author>() : (t.Author.Posts == null ? new List<Author>() : t.Author.Posts.Where(t2 => t2.Author != null).Select(t2 => t2.Author)),
|
||||
Comments = t.Comments == null ? new List<Comment>() : t.Comments,
|
||||
CommentLikes = (t.Comments == null ? new List<CommentLike>() : t.Comments.Where(t2 => t2.CommentLikes != null).SelectMany(t2 => t2.CommentLikes)),
|
||||
CommentLikeIds = (t.Comments == null ? new List<long>() : t.Comments.Where(t2 => t2.CommentLikes != null).SelectMany(t2 => t2.CommentLikes.Select(t3 => t3.Id))),
|
||||
CommentsLikes = (t.Comments == null ? new List<List<CommentLike>>() : t.Comments.Where(t2 => t2.CommentLikes != null).Select(t2 => t2.CommentLikes))
|
||||
});
|
||||
|
||||
// the builder.
|
||||
var per = new PathExpressionResolver(ep);
|
||||
per.NullHandling = SelectNullHandling.Handle;
|
||||
per.Resolve();
|
||||
|
||||
// the result expression.
|
||||
var result = per.Result;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
public class PathExpressionResolver
|
||||
{
|
||||
public SelectNullHandling NullHandling { get; set; } = SelectNullHandling.LeaveAsIs;
|
||||
public SelectCollectionHandling CollectionHandling { get; set; } = SelectCollectionHandling.LeaveAsIs;
|
||||
public ExpressionParser Parser { get; protected set; }
|
||||
|
||||
public Expression Result { get; protected set; }
|
||||
public Type NullType { get; set; }
|
||||
|
||||
public PathExpressionResolver(ExpressionParser parser)
|
||||
{
|
||||
Parser = parser;
|
||||
}
|
||||
|
||||
protected Expression CompileGroup(ExpressionParserPieceGroup group, SelectNullHandling NullHandling)
|
||||
{
|
||||
var expr = group.Parameter as Expression;
|
||||
group.Pieces.ForEach(piece =>
|
||||
{
|
||||
expr = Expression.PropertyOrField(expr, piece.Name);
|
||||
});
|
||||
return expr;
|
||||
}
|
||||
|
||||
public void Resolve()
|
||||
{
|
||||
Result = null;
|
||||
|
||||
// parse the expression.
|
||||
Parser.Parse();
|
||||
|
||||
// group the piece by common parameters
|
||||
var groups = Parser.GroupBySharedParameters();
|
||||
|
||||
NullType = groups.ResolveNullHandlingType();
|
||||
|
||||
Expression currentExpression = null;
|
||||
foreach(var group in groups.Reversed())
|
||||
{
|
||||
if (currentExpression == null)
|
||||
{
|
||||
var groupExpression = CompileGroup(group, NullHandling);
|
||||
var groupExpressionLambda = Expression.Lambda(groupExpression, group.Parameter);
|
||||
|
||||
if (group.Parent == null)
|
||||
{
|
||||
currentExpression = groupExpressionLambda;
|
||||
continue;
|
||||
}
|
||||
|
||||
var parent = group.Parent;
|
||||
var parentExpression = CompileGroup(parent, NullHandling);
|
||||
|
||||
// check null with where.
|
||||
if (NullHandling != SelectNullHandling.LeaveAsIs)
|
||||
parentExpression = CheckNullOnEnumerableParent(group, parent, parentExpression);
|
||||
|
||||
// the select expression.
|
||||
var selectType = parent.GroupEnumerableType();
|
||||
var selectExpression = Expression.Call(typeof(Enumerable), "Select",
|
||||
new Type[] { selectType, groupExpression.Type },
|
||||
parentExpression, groupExpressionLambda);
|
||||
currentExpression = selectExpression;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (group.Parent == null)
|
||||
{
|
||||
if (NullHandling != SelectNullHandling.LeaveAsIs)
|
||||
currentExpression = CheckNullOnFirstGroup(group, currentExpression);
|
||||
|
||||
currentExpression = Expression.Lambda(currentExpression, group.Parameter);
|
||||
continue;
|
||||
}
|
||||
|
||||
var parent = group.Parent;
|
||||
var parentExpression = CompileGroup(parent, NullHandling);
|
||||
var selectType = parent.GroupEnumerableType();
|
||||
|
||||
|
||||
if (NullHandling != SelectNullHandling.LeaveAsIs)
|
||||
parentExpression = CheckNullOnEnumerableParent(group, parent, parentExpression);
|
||||
|
||||
var currentExpressionLambda = Expression.Lambda(currentExpression, group.Parameter);
|
||||
currentExpression = Expression.Call(typeof(Enumerable), "Select",
|
||||
new Type[] { selectType, currentExpression.Type },
|
||||
parentExpression, currentExpressionLambda);
|
||||
}
|
||||
}
|
||||
|
||||
Result = currentExpression;
|
||||
}
|
||||
|
||||
private Expression CheckNullOnFirstGroup(ExpressionParserPieceGroup group, Expression currentExpression)
|
||||
{
|
||||
var path = string.Join(".", group.Pieces.Select(t => t.Name));
|
||||
var whereExpression = QueryableHelpers.CreateConditionExpression(group.Parameter.Type, path,
|
||||
ConditionOperators.NotEqual, null, QueryConvertStrategy.ConvertConstantToComparedPropertyOrField,
|
||||
parameter: group.Parameter, nullChecking: true);
|
||||
|
||||
var whereBodyExpression = (whereExpression as LambdaExpression).Body;
|
||||
|
||||
Expression ifTrueExpression = null;
|
||||
if (QueryableHelpers.IsGenericEnumerable(NullType))
|
||||
{
|
||||
var listType = typeof(List<>).MakeGenericType(NullType.GenericTypeArguments.First());
|
||||
ifTrueExpression = Expression.New(listType);
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
ifTrueExpression = Expression.Default(NullType);
|
||||
}
|
||||
|
||||
return Expression.Condition(whereBodyExpression, ifTrueExpression, currentExpression, currentExpression.Type);
|
||||
}
|
||||
|
||||
private static Expression CheckNullOnEnumerableParent(ExpressionParserPieceGroup group, ExpressionParserPieceGroup parent, Expression parentExpression)
|
||||
{
|
||||
if (group.Pieces.Count > 1)
|
||||
{
|
||||
var path = string.Join(".", group.Pieces.Take(group.Pieces.Count - 1).Select(T => T.Name));
|
||||
var whereExpression = QueryableHelpers.CreateConditionExpression(group.Parameter.Type, path,
|
||||
ConditionOperators.NotEqual, null, QueryConvertStrategy.ConvertConstantToComparedPropertyOrField,
|
||||
parameter: group.Parameter, nullChecking: true);
|
||||
|
||||
//public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate);
|
||||
parentExpression = Expression.Call(typeof(Enumerable), "Where",
|
||||
new Type[] { parent.GroupEnumerableType() },
|
||||
parentExpression, whereExpression);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
return parentExpression;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -42,8 +42,6 @@
|
||||
<Reference Include="System.Xml" />
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<Compile Include="BetterParserProto1.cs" />
|
||||
<Compile Include="BetterProto2.cs" />
|
||||
<Compile Include="Program.cs" />
|
||||
<Compile Include="Properties\AssemblyInfo.cs" />
|
||||
</ItemGroup>
|
||||
|
||||
@@ -14,7 +14,8 @@ namespace PoweredSoft.DynamicLinq.ConsoleApp
|
||||
{
|
||||
static void Main(string[] args)
|
||||
{
|
||||
BetterProto2.Run();
|
||||
var selectTests = new SelectTests();
|
||||
selectTests.SelectNullChecking();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user