Merge pull request #521 from waqasm78/master

update docs

Author: JonathanMagnan

docs2/pages/ef-core-docs/documentations/batch-update/ef-core-batch-update.md

@@ -25,6 +25,11 @@ ctx.Users.Where(x => x.LastLoginDate < date)
 ```
 [Try it](https://dotnetfiddle.net/0CBNK1)
 
+## Scenarios
+
+ - [Query Criteria](scenarios/ef-core-batch-update-query-criteria.md)
+ - [Executing Interceptor](scenarios/ef-core-batch-update-executing-interceptor.md)
+ 
 ## Limitations
 
  - **DO NOT** support Complex Type

docs2/pages/ef-core-docs/documentations/batch-update/scenarios/ef-core-batch-update-executing-interceptor.md

@@ -0,0 +1,27 @@
+---
+Permalink: ef-core-batch-update-executing-interceptor
+---
+
+# Executing Interceptor
+
+### Problem
+
+You need to log the DbCommand information or change the CommandText, Connection or Transaction before the batch is executed.
+
+### Solution
+
+The **Executing** property intercepts the DbCommand with an action before being executed.
+
+{% include template-example.html %} 
+```csharp
+
+// using Z.EntityFramework.Plus; // Don't forget to include this.
+
+string commandText
+var date = DateTime.Now.AddYears(-2);
+ctx.Users.Where(x => x.LastLoginDate < date)
+         .Update(x => new User() { IsSoftDeleted = 1 },
+                 x => { x.Executing = command => commandText = command.CommandText; });
+
+```
+[Try it](https://dotnetfiddle.net/oHJl9R)

docs2/pages/ef-core-docs/documentations/batch-update/scenarios/ef-core-batch-update-query-criteria.md

@@ -0,0 +1,49 @@
+---
+Permalink: ef-core-batch-update-query-criteria
+---
+
+# Batch Update using Query Criteria
+
+## Problem
+
+You need to update one or millions of records based on a query criteria and an expression.
+
+## Solution
+
+The **Update** IQueryable extension method updates rows matching the query criteria with an expression without loading entities in the context.
+
+{% include template-example.html %} 
+```csharp
+
+// using Z.EntityFramework.Plus; // Don't forget to include this.
+
+// UPDATE all users inactive for 2 years
+var date = DateTime.Now.AddYears(-2);
+ctx.Users.Where(x => x.LastLoginDate < date)
+         .Update(x => new User() { IsSoftDeleted = 1 });
+
+```
+[Try it](https://dotnetfiddle.net/kJRdnp)
+
+## Batch UpdateAsync
+
+### Problem
+
+You need to update one or millions of records based on a query criteria and an expression asynchronously.
+
+### Solution
+
+The **UpdateAsync** IQueryable extension method updates asynchronously rows matching the query criteria with an expression without loading entities in the context.
+
+{% include template-example.html %} 
+```csharp
+
+// using Z.EntityFramework.Plus; // Don't forget to include this.
+
+// UPDATE all users inactive for 2 years
+var date = DateTime.Now.AddYears(-2);
+ctx.Users.Where(x => x.LastLoginDate < date)
+         .UpdateAsync(x => new User() { IsSoftDeleted = 1 });
+
+```
+[Try it](https://dotnetfiddle.net/TBfvz6)

docs2/pages/ef-core-docs/documentations/linq-dynamic/ef-core-linq-dynamic.md

@@ -0,0 +1,45 @@
+---
+Permalink: ef-core-linq-dynamic
+---
+
+# LINQ Dynamic
+
+> This feature is now available on [Entity Framework Classic - LINQ Dynamic](http://entityframework-classic.net/linq-dynamic). Entity Framework Classic is a supported version from the latest EF6 code base. It supports .NET Framework and .NET Core and overcomes some EF limitations by adding tons of must-haves built-in features.
+
+## Introduction
+
+**LINQ Dynamic** in Entity Framework is supported through the [Eval-Expression.NET](http://eval-expression.net/) Library.
+
+### Predicate
+
+All LINQ predicate methods are supported. A string expression which return a Boolean function can be used as parameter.
+
+ - Deferred
+ - SkipWhile
+ - TakeWhile
+ - Where
+ - Immediate
+ - All
+ - Any
+ - Count
+ - First
+ - FirstOrDefault
+ - Last
+ - LastOrDefault
+ - LongCount
+ - Single
+ - SingleOrDefault
+
+{% include template-example.html %} 
+```csharp
+
+var list = ctx.Where(x => "x > 2").ToList();
+var list = ctx.Where(x => "x > y", new { y = 2 }).ToList();
+
+```
+[Try it in EF6](https://dotnetfiddle.net/Otm0Aa) | [Try it in EF Core](https://dotnetfiddle.net/1sTQwA)
+
+## Options
+
+ - [Order && Select](options/ef-core-linq-dynamic-order-and-select.md)
+ - [Execute](options/ef-core-linq-dynamic-execute.md)

docs2/pages/ef-core-docs/documentations/linq-dynamic/options/ef-core-linq-dynamic-execute.md

@@ -0,0 +1,19 @@
+---
+Permalink: ef-core-linq-dynamic-execute
+---
+
+# Execute
+
+The Execute method is the LINQ Dynamic ultimate methods which let you evaluate and execute a dynamic expression and return the result.
+
+ - Execute
+ - Execute< TResult >
+
+{% include template-example.html %} 
+```csharp
+ 
+var list = ctx.Execute<IEnumerable<int>>("Where(x => x > 2)");
+var list3 = ctx.Execute("Where(x => x > y).OrderBy(x => x).ToList()", new { y = 2 });
+
+```
+[Try it](https://dotnetfiddle.net/LbU2at)

docs2/pages/ef-core-docs/documentations/linq-dynamic/options/ef-core-linq-dynamic-order-and-select.md

@@ -0,0 +1,23 @@
+---
+Permalink: ef-core-linq-dynamic-order-and-select
+---
+
+# Order && Select
+
+All LINQ selector and order are supported. Most of them require the "Dynamic" suffix to not override default behavior (Ordering or selecting by a string is valid).
+
+ - OrderByDescendingDynamic
+ - OrderByDynamic
+ - SelectDynamic
+ - SelectMany
+ - ThenByDescendingDynamic
+ - ThenByDynamic
+
+{% include template-example.html %} 
+```csharp
+
+var list = context.Customers.OrderByDescendingDynamic(x => "x.Name").ToList();
+var list = context.Customers.SelectDynamic(x => "x.Name").ToList();
+
+```
+[Try it](https://dotnetfiddle.net/8n2Xc0)

docs2/pages/ef-core-docs/documentations/query-cache/ef-core-query-cache.md

@@ -0,0 +1,82 @@
+---
+Permalink: ef-core-query-cache
+---
+
+# Query Cache
+
+> This feature is now available on [Entity Framework Classic - Query Cache](http://entityframework-classic.net/query-cache). Entity Framework Classic is a supported version from the latest EF6 code base. It supports .NET Framework and .NET Core and overcomes some EF limitations by adding tons of must-haves built-in features.
+
+## Introduction
+
+Caching entities or query results to improve an application's performance is a very frequent scenario. Major ORM like NHibernate had this feature for a long time but, unfortunately for Entity Framework Core users, second level caching is only available through third party libraries.
+
+Caching is very simple to understand, the first time a query is invoked, data are retrieved from the database and stored in the memory before being returned. All future calls will retrieve data from the memory to avoid making additional database round trips which drastically increases an application's performance.
+
+**EF+ Query Cache** opens up all caching features for Entity Framework Core users.
+
+To use caching, simply append to the query "FromCache" method before using an immediate resolution method like "ToList()" or "FirstOrDefault()".
+
+{% include template-example.html %} 
+```csharp
+
+// using Z.EntityFramework.Plus; // Don't forget to include this.
+var ctx = new EntitiesContext();
+
+// The first call perform a database round trip
+var countries1 = ctx.Countries.FromCache().ToList();
+
+// Subsequent calls will take the value from the memory instead
+var countries2 = ctx.Countries.FromCache().ToList();
+
+```
+[Try it](https://dotnetfiddle.net/EZZkhP)
+
+## Scenarios
+
+ - [Query Criteria](scenarios/ef-core-query-cache-using-query-criteria.md)
+ - [Query Deferred](scenarios/ef-core-query-cache-query-deferred.md)
+ - [Tag & ExpireTag](scenarios/ef-core-query-cache-tag.md)
+ - [Expiration](scenarios/ef-core-query-cache-expiration.md)
+ - [Query Cache Control](scenarios/ef-core-query-cache-control.md)
+ 
+## Real Life Scenarios
+
+ - Caching read-only data like application configuration.
+ - Caching data that cQuery Cache Controlan only be modified via an importation like states & countries and make all cache entries related expired once the importation is completed (Tag Expiration).
+ - Caching data that are frequently accessed but rarely modified like comments and expire the tag when a new comment is added or after one hour without any access (Tag Expiration & Sliding Expiration).
+ - Caching statistics that don't require to be live like client count and expire them every hour (Absolute Expiration).
+
+## Behind the code
+
+When **FromCache** is invoked, The QueryCacheManager returns the result if a cache entry exists for the cache key. If no cache entry exists, the query is materialized then cached in the memory using the cache key before being returned. If a cache tag is specified, the cache key is also stored in a concurrent dictionary for all tags.
+
+ - **The Cache:** The memory cache is used by default.
+
+ - **The Cache Key:** The cache key is created by combining a cache prefix, all cache tags and the query expression.
+
+ - **The Query Materialized:** The query is materialized by either using "ToList()" method or "Execute()" method for query deferred.
+
+## Limitations
+
+ - Entity Framework Core:
+   - **DO NOT** support Cache Query Deferred (May be available when EF Core will be more stable)
+
+## Requirements
+
+ - **EF+ Query Cache:** Full version or Standalone version
+ - **Database Provider:** All supported
+ - **Entity Framework Version:** EF Core
+ - **Minimum Framework Version:** .NET Framework 4
+
+## Conclusion
+
+As we have seen, EF+ Query Cache follows a good architecture principle:
+
+ - **Flexible:** Tag & Cache Options make it possible to use Query Cache in a various number of scenarios.
+ - **Extensible:** If there is something missing, the library creates your own extension method or your own cache to overcome the problem.
+ - **Maintainable:** The easy to use API, documentation and available source code allows new developers to quickly understand this feature.
+ - **Scalable:** Caching gets only better as the number of user/traffic grows by drastically reducing database round trip.
+
+Need help getting started? [[email protected]](mailto:[email protected])
+
+We welcome all comments, ideas and suggestions to improve our library.

docs2/pages/ef-core-docs/documentations/query-cache/scenarios/ef-core-query-cache-control.md

@@ -0,0 +1,29 @@
+---
+Permalink: ef-core-query-cache-control
+---
+
+# EF Query Cache Control
+
+EF+ Cache is very flexible and lets you have full control over the cache.
+
+You can use your own cache:
+
+{% include template-example.html %} 
+```csharp
+QueryCacheManager.Cache = new MemoryCache(new MemoryCacheOptions());
+context.Customers.FromCache().ToList();
+
+```
+[Try it](https://dotnetfiddle.net/6ISVBT)
+
+You can set default policy
+
+{% include template-example.html %} 
+```csharp
+
+var options = new MemoryCacheEntryOptions() { SlidingExpiration = TimeSpan.FromHours(2)};
+QueryCacheManager.DefaultMemoryCacheEntryOptions = options;
+context.Customers.FromCache().ToList();
+
+```
+[Try it](https://dotnetfiddle.net/k1TOWX)

docs2/pages/ef-core-docs/documentations/query-cache/scenarios/ef-core-query-cache-expiration.md

@@ -0,0 +1,22 @@
+---
+Permalink: ef-core-query-cache-expiration
+---
+
+# EF+ Query Cache Expiration
+
+All common caching features like absolute expiration, sliding expiration, removed callback are supported.
+
+{% include template-example.html %} 
+```csharp
+
+// using Z.EntityFramework.Plus; // Don't forget to include this.
+var ctx = new EntitiesContext();
+
+// Make the query expire after 2 hours of inactivity
+
+var options = new MemoryCacheEntryOptions() { SlidingExpiration = TimeSpan.FromHours(2)};
+
+var states = ctx.States.FromCache(options);
+
+```
+[Try it](https://dotnetfiddle.net/aKPnTD)

docs2/pages/ef-core-docs/documentations/query-cache/scenarios/ef-core-query-cache-query-deferred.md

@@ -0,0 +1,33 @@
+---
+Permalink: ef-core-query-cache-query-deferred
+---
+
+## EF+ Query Cache Query Deferred
+
+Immediate resolution methods like **Count()** and **FirstOrDefault()** cannot be cached since their expected behavior is to cache the count result or only the first item.
+
+{% include template-example.html %} 
+```csharp
+
+// Oops! The query is already executed, we cannot cache it.
+var count = ctx.Customers.Count();
+
+// Oops! All customers are cached instead of customer count.
+var count = ctx.Customers.FromCache().Count();
+```
+[Try it](https://dotnetfiddle.net/3EXZBt)
+
+**EF+ Query Deferred** has been created to resolve this issue, the resolution is now deferred instead of being immediate which lets us cache the expected result.
+
+{% include template-example.html %} 
+```csharp
+// using Z.EntityFramework.Plus; // Don't forget to include this.
+var ctx = new EntitiesContext();
+
+// The count is deferred, it is now cached.
+var count = ctx.Customers.DeferredCount().FromCache();
+
+```
+[Try it](https://dotnetfiddle.net/V0G6pe)
+
+Query Deferred supports all Queryable extension methods and overloads.