docs2

docs2

Author: zzzprojects

docs2/_data/pages.csv

@@ -0,0 +1,66 @@
+title,url,category
+Overview,overview,tutorials
+Requirements,requirements,tutorials
+Installing,installing,tutorials
+Upgrading,upgrading,tutorials
+Licensing,licensing,tutorials
+Compile & Execute,tutorial-compile-execute,tutorials
+LINQ Dynamic,tutorial-linq-dynamic,tutorials
+API,api,api
+Eval.Execute,eval-execute,api
+Eval.Compile,eval-compile,api
+LINQ Dynamic,linq-dynamic,api
+String Extensions,string-extensions,api
+Compile & Execute,compile-execute,api
+Register & Unregister,register-unregister,api
+Options,options,api
+Eval Manager,eval-manager,api
+Where,linq-dynamic-where-examples,linq
+Select,linq-dynamic-select-examples,linq
+SelectMany,linq-dynamic-selectmany-examples,linq
+Take,linq-dynamic-take-examples,linq
+Skip,linq-dynamic-skip-examples,linq
+TakeWhile,linq-dynamic-takewhile-examples,linq
+SkipWhile,linq-dynamic-skipwhile-examples,linq
+OrderBy,linq-dynamic-orderby-examples,linq
+OrderByDescending,linq-dynamic-orderbydescending-examples,linq
+ThenBy,linq-dynamic-thenby-examples,linq
+ThenByDescending,linq-dynamic-thenbydescending-examples,linq
+Reverse,linq-dynamic-reverse-examples,linq
+GroupBy,linq-dynamic-groupby-examples,linq
+Distinct,linq-dynamic-distinct-examples,linq
+Union,linq-dynamic-union-examples,linq
+Intersect,linq-dynamic-intersect-examples,linq
+Except,linq-dynamic-except-examples,linq
+ToArray,linq-dynamic-toarray-examples,linq
+ToList,linq-dynamic-tolist-examples,linq
+ToDictionary,linq-dynamic-todictionary-examples,linq
+OfType,linq-dynamic-oftype-examples,linq
+First,linq-dynamic-first-examples,linq
+First,linq-dynamic-firstordefault-examples,linq
+ElementAt,linq-dynamic-elementat-examples,linq
+Range,linq-dynamic-range-examples,linq
+Repeat,linq-dynamic-repeat-examples,linq
+Any,linq-dynamic-any-examples,linq
+All,linq-dynamic-all-examples,linq
+Count,linq-dynamic-count-examples,linq
+Sum,linq-dynamic-sum-examples,linq
+Min,linq-dynamic-min-examples,linq
+Max,linq-dynamic-max-examples,linq
+Average,linq-dynamic-average-examples,linq
+Aggregate,linq-dynamic-aggregate-examples,linq
+Concat,linq-dynamic-concat-examples,linq
+EqualAll,linq-dynamic-equalall-examples,linq
+Combine,linq-dynamic-combine-examples,linq
+Articles,articles,articles
+FAQ,faq,faq
+Contact Us,contact-us,faq
+Issue Tracker,issue-tracker,faq
+General,faq-general,faq
+Installation,faq-installation,faq
+License,faq-license,faq
+Troubleshooting,troubleshooting,troubleshooting
+Trial Period Expired,trial-period-expired-exception,troubleshooting
+MD5,md5-exception,troubleshooting
+Eval-Expression.NET,/,home
+Trial, trial, trial

docs2/pages/api/api.md

@@ -0,0 +1,17 @@
+---
+layout: default
+title: API
+permalink: api
+---
+
+{% include template-h1.html %}
+
+## API
+
+<ul>
+{% for num in (0..site.data.pages.size) %}	
+	{% if site.data.pages[num].category == page.permalink and site.data.pages[num].url != page.permalink %}
+		<li><a href="{{ site.data.pages[num].url }}">{{ site.data.pages[num].title }}</a></li>
+	{% endif %}
+{% endfor %}
+</ul>

docs2/pages/api/compile-execute.md

@@ -0,0 +1,64 @@
+---
+layout: default
+title: Compile & Execute
+description: Compile and execute a C# expression at runtime.
+permalink: compile-execute
+---
+
+{% include template-h1.html %}
+
+## Description
+{{ page.description }}
+
+## Execute
+Execute a C# expression and return the result: 
+
+- Execute<TResult>(string code)
+- Execute<TResult>(string code, object parameters)
+- Execute<TResult>(string code, params object[] parameters)
+- Execute(string code)
+- Execute(string code, object parameters)
+- Execute(string code, params object[] parameters)
+
+### Example
+{% highlight csharp %}
+// using Z.Expressions; // Don't forget to include this.
+
+var context = new EvalContext();
+// ... context options ...
+
+string code = "Price * Quantity";
+var price = context.Execute<decimal>(code, orderItem);
+{% endhighlight %}
+{% include  component-try-it.html href='https://dotnetfiddle.net/tzBdMI' %}
+
+## Compile
+Compile a C# expression and return a delegate: 
+
+- Compile&lt;TDelegate&gt;(string code)
+- Compile&lt;TDelegate&gt;(string code, IEnumerable&lt;string&gt; parameterNames)
+- Compile&lt;TDelegate&gt;(string code, params string[] parameterNames)
+- Compile(string): **Func&lt;object&gt;**
+- Compile(string, Type type1): **Func&lt;object, object&gt;**
+- Compile(string, Type type1, ... , Type type9): **Func&lt;object, ... , object, object&gt;**
+- Compile(string, IEnumerable&lt;Type&gt;): **Func&lt;IEnumerable, object&gt;**
+- Compile(string, params Type[]): **Func&lt;IEnumerable, object&gt;**
+- Compile(string, IDictionary&lt;string, Type&gt;): **Func&lt;IDictionary, object&gt;**
+
+### Example
+{% highlight csharp %}
+// using Z.Expressions; // Don't forget to include this.
+
+var context = new EvalContext();
+// ... context options ...
+
+string code = "Price * Quantity";
+var compiled = context.Compile<Func<OrderItem, decimal>>(code);
+
+decimal totals = 0;
+foreach(var item in list)
+{
+    totals += compiled(item);
+}
+{% endhighlight %}
+{% include  component-try-it.html href='https://dotnetfiddle.net/00YSGK' %}

docs2/pages/api/eval-compile.md

@@ -0,0 +1,70 @@
+---
+layout: default
+title: Eval.Compile
+description: Compile a C# expression and return a delegate.
+permalink: eval-compile
+---
+
+{% include template-h1.html %}
+
+## Description
+{{ page.description }}
+
+Under the hood, the expression is parsed into tokens and then transformed into syntax node before being compiled using Expression Tree.
+
+## 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
+{% highlight 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);
+{% endhighlight %}
+{% 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
+{% highlight 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);
+{% endhighlight %}
+{% include  component-try-it.html href='https://dotnetfiddle.net/870F71' %}
+
+

docs2/pages/api/eval-execute.md

@@ -0,0 +1,76 @@
+---
+layout: default
+title: Eval.Execute
+description: Execute a C# expression and return the result.
+permalink: eval-execute
+---
+
+{% include template-h1.html %}
+
+## Description
+{{ page.description }}
+
+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
+
+{% highlight 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);
+{% endhighlight %}
+{% 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)
+
+{% highlight 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);
+{% endhighlight %}
+{% include  component-try-it.html href='https://dotnetfiddle.net/8mtLH8' %}  

docs2/pages/api/eval-manager.md

@@ -0,0 +1,47 @@
+---
+layout: default
+title: Eval Manager
+description: Static manager class for options shared between all instances.
+permalink: eval-manager
+---
+
+{% include template-h1.html %}
+
+## Description
+{{ page.description }}
+
+## Cache
+Gets or sets the cache to use to cache compiled delegate.
+
+### Example
+{% highlight csharp %}
+// using Z.Expressions; // Don't forget to include this.
+EvalManager.Cache = MemoryCache.Default;
+{% endhighlight %}
+
+> You can use your own cache provider inheriting from System.Runtime.Caching.ObjectCache
+
+## DefaultContext
+Gets or sets the default context to use for all operations using the default context.
+
+You can also directly change options
+ - [Register & Unregister](register-unregister)
+ - [Options](options)
+
+The default context is used in static methods:
+- [Eval.Execute](eval-execute)
+- [Eval.Compile](eval-compile)
+- [LINQ Dynamic](linq-dynamic)
+- [string".Execute](string-extensions#stringexecute)
+- [string".Compile](string-extensions#stringcompile)
+
+### Example
+{% highlight csharp %}
+// using Z.Expressions; // Don't forget to include this.
+EvalManager.DefaultContext.RegisterExtensionMethod(typeof(Z.ExtensionMethods))
+
+// Make member case insensitive (Math.pOW = Math.Pow)
+EvalManager.DefaultContext.BindingFlags = BindingFlags.IgnoreCase | context.BindingFlags
+{% endhighlight %}
+
+