diff --git a/Z.Dynamic.Core.Lab/Program.cs b/Z.Dynamic.Core.Lab/Program.cs index 6217707b..fc82dcb9 100644 --- a/Z.Dynamic.Core.Lab/Program.cs +++ b/Z.Dynamic.Core.Lab/Program.cs @@ -11,7 +11,7 @@ class Program static void Main(string[] args) { - Request_PropertyCaseSensitive.Execute(); + Request_LambdaAddFunc.Execute(); //var data = new List { // new { ItemCode = "AAAA", Flag = true, SoNo="aaa",JobNo="JNO01" } , diff --git a/Z.Dynamic.Core.Lab/Request_LambdaAddFunc.cs b/Z.Dynamic.Core.Lab/Request_LambdaAddFunc.cs new file mode 100644 index 00000000..3223e9ae --- /dev/null +++ b/Z.Dynamic.Core.Lab/Request_LambdaAddFunc.cs @@ -0,0 +1,19 @@ +using System; +using System.Collections.Generic; +using System.Linq.Dynamic.Core; +using System.Linq.Expressions; +using System.Text; + +namespace Z.Dynamic.Core.Lab +{ + class Request_LambdaAddFunc + { + public static void Execute() + { + var expression = (Action)DynamicExpressionParser.ParseLambda(typeof(Action), new[] { Expression.Parameter(typeof(int), "x") }, typeof(int), "x + 1").Compile(); + var expression2 = (Func)DynamicExpressionParser.ParseLambda(typeof(Func), new[] { Expression.Parameter(typeof(int), "x") }, typeof(int), "x + 1").Compile(); + + expression(3); + } + } +} diff --git a/src/System.Linq.Dynamic.Core/DynamicExpressionParser.cs b/src/System.Linq.Dynamic.Core/DynamicExpressionParser.cs index 6afb7e34..d313aa8f 100644 --- a/src/System.Linq.Dynamic.Core/DynamicExpressionParser.cs +++ b/src/System.Linq.Dynamic.Core/DynamicExpressionParser.cs @@ -30,6 +30,17 @@ public static LambdaExpression ParseLambda([CanBeNull] ParsingConfig parsingConf return Expression.Lambda(parser.Parse(resultType, createParameterCtor)); } + // NEED TEXT! + [PublicAPI] + public static LambdaExpression ParseLambda([CanBeNull] Type delegateType, [CanBeNull] ParsingConfig parsingConfig, bool createParameterCtor, [CanBeNull] Type resultType, [NotNull] string expression, params object[] values) + { + Check.NotEmpty(expression, nameof(expression)); + + var parser = new ExpressionParser(new ParameterExpression[0], expression, values, parsingConfig); + + return Expression.Lambda(delegateType, parser.Parse(resultType, createParameterCtor)); + } + /// /// Parses an expression into a Typed Expression. /// @@ -45,6 +56,12 @@ public static Expression> ParseLambda([CanBeNull] Parsing return (Expression>)ParseLambda(parsingConfig, createParameterCtor, typeof(TResult), expression, values); } + [PublicAPI] + public static Expression> ParseLambda([CanBeNull] Type delegateType, [CanBeNull] ParsingConfig parsingConfig, bool createParameterCtor, [NotNull] string expression, params object[] values) + { + return (Expression>)ParseLambda(delegateType, parsingConfig, createParameterCtor, typeof(TResult), expression, values); + } + /// /// Parses an expression into a LambdaExpression. /// @@ -57,7 +74,16 @@ public static Expression> ParseLambda([CanBeNull] Parsing /// The generated [PublicAPI] public static LambdaExpression ParseLambda([CanBeNull] ParsingConfig parsingConfig, bool createParameterCtor, [NotNull] ParameterExpression[] parameters, [CanBeNull] Type resultType, [NotNull] string expression, params object[] values) + { + return ParseLambda(parsingConfig, createParameterCtor, parameters, resultType, null, expression, values); + } + + // NEED TEXT! + [PublicAPI] + public static LambdaExpression ParseLambda([CanBeNull] Type delegateType, [CanBeNull] ParsingConfig parsingConfig, bool createParameterCtor, [NotNull] ParameterExpression[] parameters, [CanBeNull] Type resultType, [NotNull] string expression, params object[] values) { + LambdaExpression lambdaExpression = null; + Check.NotNull(parameters, nameof(parameters)); Check.HasNoNulls(parameters, nameof(parameters)); Check.NotEmpty(expression, nameof(expression)); @@ -71,12 +97,28 @@ public static LambdaExpression ParseLambda([CanBeNull] ParsingConfig parsingConf var renamer = new ParameterExpressionRenamer(parser.LastLambdaItName); parsedExpression = renamer.Rename(parsedExpression, out ParameterExpression newParameterExpression); - return Expression.Lambda(parsedExpression, new[] { newParameterExpression }); + if (delegateType == null) + { + lambdaExpression = Expression.Lambda(parsedExpression, new[] { newParameterExpression }); + } + else + { + lambdaExpression = Expression.Lambda(delegateType, parsedExpression, new[] { newParameterExpression }); + } } else { - return Expression.Lambda(parsedExpression, parameters); + if (delegateType == null) + { + lambdaExpression = Expression.Lambda(parsedExpression, parameters); + } + else + { + lambdaExpression = Expression.Lambda(delegateType, parsedExpression, parameters); + } } + + return lambdaExpression; } /// @@ -95,6 +137,13 @@ public static Expression> ParseLambda([CanBeNull] Parsing return (Expression>)ParseLambda(parsingConfig, createParameterCtor, parameters, typeof(TResult), expression, values); } + // NEED TEXT! + [PublicAPI] + public static Expression> ParseLambda([CanBeNull] Type delegateType, [CanBeNull] ParsingConfig parsingConfig, bool createParameterCtor, [NotNull] ParameterExpression[] parameters, [NotNull] string expression, params object[] values) + { + return (Expression>)ParseLambda(delegateType, parsingConfig, createParameterCtor, parameters, typeof(TResult), expression, values); + } + /// /// Parses an expression into a LambdaExpression. /// @@ -131,6 +180,25 @@ public static Expression> ParseLambda([CanBeNull] P return (Expression>)ParseLambda(parsingConfig, createParameterCtor, new[] { ParameterExpressionHelper.CreateParameterExpression(typeof(T), string.Empty, parsingConfig?.RenameEmptyParameterExpressionNames ?? false) }, typeof(TResult), expression, values); } + // NEED TEXT + + // COMMENT ---- BEGIN ---- + // COMMENT ---- BEGIN ---- + // COMMENT ---- BEGIN ---- + + // Not sur for this method. + + // COMMENT ---- END ---- + // COMMENT ---- END ---- + // COMMENT ---- END ---- + [PublicAPI] + public static Expression> ParseLambda([CanBeNull] Type delegateType, [CanBeNull] ParsingConfig parsingConfig, bool createParameterCtor, [NotNull] string expression, params object[] values) + { + Check.NotEmpty(expression, nameof(expression)); + + return (Expression>)ParseLambda(delegateType, parsingConfig, createParameterCtor, new[] { ParameterExpressionHelper.CreateParameterExpression(typeof(T), string.Empty, parsingConfig?.RenameEmptyParameterExpressionNames ?? false) }, typeof(TResult), expression, values); + } + /// /// Parses an expression into a LambdaExpression. (Also create a constructor for all the parameters. Note that this doesn't work for Linq-to-Database entities.) /// @@ -145,6 +213,13 @@ public static LambdaExpression ParseLambda([CanBeNull] ParsingConfig parsingConf return ParseLambda(parsingConfig, true, resultType, expression, values); } + // NEED TEXT + [PublicAPI] + public static LambdaExpression ParseLambda([CanBeNull] Type delegateType, [CanBeNull] ParsingConfig parsingConfig, [CanBeNull] Type resultType, [NotNull] string expression, params object[] values) + { + return ParseLambda(delegateType, parsingConfig, true, resultType, expression, values); + } + /// /// Parses an expression into a LambdaExpression. (Also create a constructor for all the parameters. Note that this doesn't work for Linq-to-Database entities.) /// @@ -160,6 +235,15 @@ public static LambdaExpression ParseLambda([CanBeNull] Type resultType, [NotNull return ParseLambda(null, true, resultType, expression, values); } + //// NEED TEXT + //[PublicAPI] + //public static LambdaExpression ParseLambda([CanBeNull] Type delegateType, [CanBeNull] Type resultType, [NotNull] string expression, params object[] values) + //{ + // Check.NotEmpty(expression, nameof(expression)); + + // return ParseLambda(delegateType, null, true, resultType, expression, values); + //} + /// /// Parses an expression into a LambdaExpression. (Also create a constructor for all the parameters. Note that this doesn't work for Linq-to-Database entities.) /// @@ -189,6 +273,13 @@ public static LambdaExpression ParseLambda([CanBeNull] ParsingConfig parsingConf return ParseLambda(parsingConfig, true, itType, resultType, expression, values); } + // NEED TEXT! + [PublicAPI] + public static LambdaExpression ParseLambda([CanBeNull] Type delegateType, [CanBeNull] ParsingConfig parsingConfig, [NotNull] Type itType, [CanBeNull] Type resultType, string expression, params object[] values) + { + return ParseLambda(delegateType, parsingConfig, true, itType, resultType, expression, values); + } + /// /// Parses an expression into a LambdaExpression. /// @@ -208,6 +299,16 @@ public static LambdaExpression ParseLambda([CanBeNull] ParsingConfig parsingConf return ParseLambda(parsingConfig, createParameterCtor, new[] { ParameterExpressionHelper.CreateParameterExpression(itType, string.Empty, parsingConfig?.RenameEmptyParameterExpressionNames ?? false) }, resultType, expression, values); } + // NEED TEXT! + [PublicAPI] + public static LambdaExpression ParseLambda([CanBeNull] Type delegateType, [CanBeNull] ParsingConfig parsingConfig, bool createParameterCtor, [NotNull] Type itType, [CanBeNull] Type resultType, string expression, params object[] values) + { + Check.NotNull(itType, nameof(itType)); + Check.NotEmpty(expression, nameof(expression)); + + return ParseLambda(parsingConfig, createParameterCtor, new[] { ParameterExpressionHelper.CreateParameterExpression(itType, string.Empty, parsingConfig?.RenameEmptyParameterExpressionNames ?? false) }, resultType, expression, values); + } + /// /// Parses an expression into a LambdaExpression. (Also create a constructor for all the parameters. Note that this doesn't work for Linq-to-Database entities.) /// @@ -222,6 +323,13 @@ public static LambdaExpression ParseLambda([NotNull] ParameterExpression[] param return ParseLambda(null, true, parameters, resultType, expression, values); } + // NEED TEXT! + [PublicAPI] + public static LambdaExpression ParseLambda([CanBeNull] Type delegateType, [NotNull] ParameterExpression[] parameters, [CanBeNull] Type resultType, string expression, params object[] values) + { + return ParseLambda(delegateType, null, true, parameters, resultType, expression, values); + } + /// /// Parses an expression into a LambdaExpression. (Also create a constructor for all the parameters. Note that this doesn't work for Linq-to-Database entities.) /// @@ -237,6 +345,13 @@ public static LambdaExpression ParseLambda([CanBeNull] ParsingConfig parsingConf return ParseLambda(parsingConfig, true, parameters, resultType, expression, values); } + // NEED TEXT! + [PublicAPI] + public static LambdaExpression ParseLambda([CanBeNull] Type delegateType, [CanBeNull] ParsingConfig parsingConfig, [NotNull] ParameterExpression[] parameters, [CanBeNull] Type resultType, string expression, params object[] values) + { + return ParseLambda(delegateType, parsingConfig, true, parameters, resultType, expression, values); + } + /// /// Parses an expression into a LambdaExpression. /// diff --git a/test/System.Linq.Dynamic.Core.Tests/MikArea/ParseLambda.cs b/test/System.Linq.Dynamic.Core.Tests/MikArea/ParseLambda.cs new file mode 100644 index 00000000..de05f24a --- /dev/null +++ b/test/System.Linq.Dynamic.Core.Tests/MikArea/ParseLambda.cs @@ -0,0 +1,26 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Linq.Expressions; +using System.Text; +using System.Threading.Tasks; +using Xunit; +using NFluent; + +namespace System.Linq.Dynamic.Core.Tests.MikArea +{ + public class ParseLambda + { + [Fact] + public void Test_ParseLambda_1() + { + + var expression = (Action)DynamicExpressionParser.ParseLambda(typeof(Action), new[] { Expression.Parameter(typeof(int), "x") }, typeof(int), "x + 1").Compile(); + var expression2 = (Func)DynamicExpressionParser.ParseLambda(typeof(Func), new[] { Expression.Parameter(typeof(int), "x") }, typeof(int), "x + 1").Compile(); + + expression(3); + var t = expression2(4); + Check.That(t).IsEqualTo(5); + } + } +}