Lazy compile expression in Lambda (#219)

Lazy compile expression in Lambda class to avoid compilation when is not needed.

src/DynamicExpresso.Core/Lambda.cs

@@ -14,28 +14,22 @@ public class Lambda
 	{
 		private readonly Expression _expression;
 		private readonly ParserArguments _parserArguments;
-
-		private readonly Delegate _delegate;
+		private readonly Lazy<Delegate> _delegate;
 
 		internal Lambda(Expression expression, ParserArguments parserArguments)
 		{
-			if (expression == null)
-				throw new ArgumentNullException("expression");
-			if (parserArguments == null)
-				throw new ArgumentNullException("parserArguments");
-
-			_expression = expression;
-			_parserArguments = parserArguments;
+			_expression = expression ?? throw new ArgumentNullException(nameof(expression));
+			_parserArguments = parserArguments ?? throw new ArgumentNullException(nameof(parserArguments));
 
-			// Note: I always compile the generic lambda. Maybe in the future this can be a setting because if I generate a typed delegate this compilation is not required.
-			var lambdaExpression = Expression.Lambda(_expression, _parserArguments.UsedParameters.Select(p => p.Expression).ToArray());
-			_delegate = lambdaExpression.Compile();
+			// Note: I always lazy compile the generic lambda. Maybe in the future this can be a setting because if I generate a typed delegate this compilation is not required.
+			_delegate = new Lazy<Delegate>(() =>
+				Expression.Lambda(_expression, _parserArguments.UsedParameters.Select(p => p.Expression).ToArray()).Compile());
 		}
 
 		public Expression Expression { get { return _expression; } }
 		public bool CaseInsensitive { get { return _parserArguments.Settings.CaseInsensitive; } }
 		public string ExpressionText { get { return _parserArguments.ExpressionText; } }
-		public Type ReturnType { get { return _delegate.Method.ReturnType; } }
+		public Type ReturnType { get { return Expression.Type; } }
 
 		/// <summary>
 		/// Gets the parameters actually used in the expression parsed.
@@ -112,7 +106,7 @@ private object InvokeWithUsedParameters(object[] orderedArgs)
 		{
 			try
 			{
-				return _delegate.DynamicInvoke(orderedArgs);
+				return _delegate.Value.DynamicInvoke(orderedArgs);
 			}
 			catch (TargetInvocationException exc)
 			{

src/DynamicExpresso.Core/Parameter.cs

@@ -38,6 +38,11 @@ public Parameter(string name, Type type, object value = null)
 			Expression = System.Linq.Expressions.Expression.Parameter(type, name);
 		}
 
+		public static Parameter Create<T>(string name, T value)
+		{
+			return new Parameter(name, typeof(T), value);
+		}
+
 		public string Name { get; private set; }
 		public Type Type { get; private set; }
 		public object Value { get; private set; }