Add eval docs

Add eval docs

Author: JonathanMagnan

docs2/pages/documentations/eval-expressions/eval-compile.md

@@ -0,0 +1,65 @@
+# Eval.Compile
+
+## Description
+You can compile C# expression at runtime using the [Eval-Expression.NET](http://eval-expression.net/) library.
+
+You can download it here: [Download](http://eval-expression.net/download)
+
+> The Eval-Expression.NET library can be activated with the Eval-SQL.NET license. 
+
+## Compile and return a strongly typed delegate
+You can return the delegate as a strongly typed function or action:
+
+- Eval.Compile<TDelegate>(string code)
+- Eval.Compile<TDelegate>(string code, IEnumerable<string> parameterNames)
+- Eval.Compile<TDelegate>(string code, params string[] parameterNames)
+
+### Example
+```csharp
+// Delegate Func
+var compiled = Eval.Compile<Func<int, int, int>>("{0} + {1}");
+int result = compiled(1, 2);
+
+// Delegate Action
+var compiled = Eval.Compile<Action<int, int>>("{0} + {1}");
+compiled(1, 2);
+
+// Named Parameter
+var compiled = Eval.Compile<Func<int, int, int>>("X + Y", "X", "Y");
+int result = compiled(1, 2);
+```
+{% include component-try-it.html href='https://dotnetfiddle.net/MBHlX8' %}
+
+## Compile and return a delegate
+You can return the delegate as a generic delegate:
+
+- Eval.Compile(string code): Func&lt;object&gt;
+- Eval.Compile(string code, Type type1): Func&lt;object, object&gt;
+- Eval.Compile(string code, Type type1, ... , Type type9): Func&lt;object, ... , object, object&gt;
+- Eval.Compile(string code, IEnumerable&lt;Type&gt; types): Func&lt;IEnumerable, object&gt;
+- Eval.Compile(string code, params Type[] types): Func&lt;IEnumerable, object&gt;
+- Eval.Compile(string code, IDictionary&lt;string, Type&gt; nameTypes): Func&lt;IDictionary, object&gt;
+
+### Example
+```csharp
+// Overload: Up to 9 parameters can be used
+var compiled = Eval.Compile("{0} + {1}", typeof(int), typeof(int));
+object result = compiled(1, 2);
+
+// Overload: params Type[]
+var values = new List<int>() {1, 2};
+var types = values.Select(x => x.GetType()).ToArray();
+
+var compiled = Eval.Compile("{0} + {1}", types);
+var result = compiled(values);
+
+// Overload: IDictionary<string, Type>
+var values = new Dictionary<string, object> { {"X", 1}, {"Y", 2} };
+var types = values.ToDictionary(x => x.Key, x => x.Value.GetType());
+
+var compiled = Eval.Compile("X + Y", types);
+var result = compiled(values);
+```
+{% include component-try-it.html href='https://dotnetfiddle.net/870F71' %}
+
+

docs2/pages/documentations/eval-expressions/eval-execute.md

@@ -0,0 +1,73 @@
+# Eval.Execute
+
+## Description
+You can execute C# expression at runtime using the [Eval-Expression.NET](http://eval-expression.net/) library.
+
+You can download it here: [Download](http://eval-expression.net/download)
+
+> The Eval-Expression.NET library can be activated with the Eval-SQL.NET license. 
+
+You can specify parameter value to use in the expression from various way:
+
+- Anonymous Type
+- Argument Position
+- Class Member
+- Dictionary
+
+Under the hood, the fist time an expression is executed, it's getting compiled and the delegate is stored in the memory before being returned and executed. All future call from the same expression will retrieve the delegate from the memory to optimize the performance.
+
+Even with this optimization, if you have to evaluate multiple times the same expression, by example in a for loop, we highly recommend you to use directly the delegate returning from the Compile method instead.
+
+## Execute and return a strongly typed result
+You can return the result as a strongly typed type:
+
+- Eval.Execute<TResult>(string code)
+- Eval.Execute<TResult>(string code, object parameters)
+- Eval.Execute<TResult>(string code, params object[] parameters)
+
+### Example
+
+```csharp
+// Parameter: Anonymous Type
+int result = Eval.Execute<int>("X + Y", new { X = 1, Y = 2} );
+
+// Parameter: Argument Position
+int result = Eval.Execute<int>("{0} + {1}", 1, 2);
+
+// Parameter: Class Member
+dynamic expandoObject = new ExpandoObject();
+expandoObject.X = 1;
+expandoObject.Y = 2;
+int result = Eval.Execute<int>("X + Y", expandoObject);
+
+// Parameter: Dictionary Key
+var values = new Dictionary<string, object>() { {"X", 1}, {"Y", 2} };
+int result = Eval.Execute<int>("X + Y", values);
+```
+{% include component-try-it.html href='https://dotnetfiddle.net/W9TwcP' %}  
+
+## Execute and return an object result
+You can return the result as an object:
+
+- Eval.Execute(string code)
+- Eval.Execute(string code, object parameters)
+- Eval.Execute(string code, params object[] parameters)
+
+```csharp
+// Parameter: Anonymous Type
+object result = Eval.Execute("X + Y", new { X = 1, Y = 2} );
+
+// Parameter: Argument Position
+object result = Eval.Execute("{0} + {1}", 1, 2);
+
+// Parameter: Class Member
+dynamic expandoObject = new ExpandoObject();
+expandoObject.X = 1;
+expandoObject.Y = 2;
+object result = Eval.Execute("X + Y", expandoObject);
+
+// Parameter: Dictionary Key
+var values = new Dictionary<string, object>() { {"X", 1}, {"Y", 2} };
+object result = Eval.Execute("X + Y", values);
+```
+{% include component-try-it.html href='https://dotnetfiddle.net/8mtLH8' %}  

docs2/pages/documentations/eval-expressions/linq-dynamic.md

@@ -0,0 +1,75 @@
+# LINQ Dynamic
+
+## Description
+You can execute query dynamically through the [Eval-Expression.NET](http://eval-expression.net/) library.
+
+You can download it here: [Download](http://eval-expression.net/download)
+
+> The Eval-Expression.NET library can be activated with the Eval-SQL.NET license. 
+
+## LINQ Dynamic - Predicate
+You can use any LINQ method that support predicate with a dynamic C# expression :
+
+- Deferred
+   - SkipWhile
+   - TakeWhile
+   - Where
+- Immediate
+   - All
+   - Any
+   - Count
+   - First
+   - FirstOrDefault
+   - Last
+   - LastOrDefault
+   - LongCount
+   - Single
+   - SingleOrDefault
+
+### Example
+```csharp
+var list = new List<int>() { 1, 2, 3, 4, 5 };
+
+var list2 = list.Where(x => "x > 2");
+var list3 = list.Where(x => "x > X", new { X = 2 }); // with parameter
+```
+{% include component-try-it.html href='https://dotnetfiddle.net/S42mkU' %}
+
+## LINQ Dynamic - Ordering and Selecting
+You can use any ordering and selecting method with a dynamic C# expression: 
+
+ - OrderByDescendingDynamic
+ - OrderByDynamic
+ - SelectDynamic
+ - SelectMany
+ - ThenByDescendingDynamic
+ - ThenByDynamic
+
+> The **"Dynamic"** suffix is required for not overriding the default behavior (ordering or selecting by a string is valid).
+
+### Example
+```csharp
+var list = new List<int>() { 5, 2, 4, 1, 3 };
+
+// SelectDynamic
+var list2 = list.SelectDynamic(x => "new { y = x + 1 }");
+var list3 = list.SelectDynamic(x => "new { y = x + 1 }", new { y = 1 });
+
+// OrderByDynamic
+var list4 = list.OrderByDynamic(x => "x + 1");
+var list5 = list.OrderByDynamic(x => "x + Y", new { Y = 1 });
+```
+
+## LINQ Dynamic - Execute
+You can push the LINQ Dynamic experience further by using the Execute method and chaining anything else:
+
+- Execute
+- Execute&lt;TResult&gt;
+
+### Example
+```csharp
+var list = new List<int>() { 1, 2, 3, 4, 5 };
+
+var list2 = list.Execute<List<int>>("Where(x => x > 2).OrderBy(x => x).ToList()");
+var list3 = list.Execute<List<int>>("Where(x => x > y).OrderBy(x => x).ToList()", new { y = 2 });
+```