EF Core Extension Methods - Query Deferred API
In Entity Framework Core (EF Core), 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. The NCache EF Core Extension Methods offer deferred queries to resolve this issue. The resolution is deferred instead of being immediate which caches the expected result instead of the entities themselves. This means that the deferred APIs have dedicated FromCache
and FromCacheOnly
APIs that cache the result.
Note
This feature is also available in NCache Professional.
Points to be noted about this API:
Query deferred results cannot be stored as separate entities as they are not entities themselves so the
Cache.Insert
API will fail for them.FromCache
andLoadIntoCache
ignoreStoreAs
inCachingOptions
for query deferred APIs.FromCacheOnly
only supports Aggregate operators inQueryDeferred
.
Aggregate Operators Supported for EFCore
Aggregate operators are supported by both methods: FromCache
and FromCacheOnly
.
Operator | Description |
---|---|
DeferredAverage |
Calculates the average of a set of numeric values after deferring the query. This operator returns the average of a sequence of numeric values (e.g., UnitPrice ) and caches the result for subsequent calls. Example: database.Products.Select(o => o.UnitPrice).DeferredAverage().FromCache(options); |
DeferredCount |
Counts the number of elements in a collection or group, deferring the actual calculation until necessary. This caches the count result rather than the entities themselves, reducing database hits when querying large collections or groups. Example: database.Customers.Select(c => c.Country).GroupBy(c => c).DeferredCount().FromCacheOnly(); |
DeferredMin |
Returns the minimum value from a sequence after deferring the query. Useful for querying collections where you need the smallest value (e.g., earliest RequiredDate ), and caching helps avoid repeated calculations on large datasets. Example: database.Orders.Where(o => o.CustomerId == "VINET").Select(o => o.RequiredDate).DeferredMin().FromCache(options); |
DeferredMax |
Retrieves the maximum value in a collection after deferring the calculation. It finds the largest value (e.g., latest RequiredDate ) and caches it for performance optimization, reducing database access for repeated requests. Example: database.Orders.Select(o => o.RequiredDate).DeferredMax().FromCacheOnly(); |
DeferredSum |
Computes the sum of a sequence of numeric values, deferring the execution. It totals values such as prices or quantities (e.g., UnitPrice ) and caches the final sum to prevent recalculations in frequently accessed datasets. Example: database.OrderDetails.Select(o => o.UnitPrice).DeferredSum().FromCache(options); |
Element Operators
Element operators are only supported by FromCache
.
Operator | Description |
---|---|
DeferredElementAtOrDefault |
Returns the element at a specified index in a sequence, or a default value if the index is out of range, with deferred execution and caching. This is useful when querying specific positions in a collection. Example: database.Customers.DeferredElementAtOrDefault(c => c.City == "London").FromCache(options); |
DeferredFirst |
Retrieves the first element in a sequence that matches the condition, caching the result to improve performance on subsequent queries. Useful when you know there is at least one match. Example: database.Customers.DeferredFirst(c => c.ContactTitle == "Sales Representative").FromCache(options); |
DeferredFirstOrDefault |
Returns the first matching element or a default value if no match is found. The query is deferred and the result is cached, which helps when querying large datasets with optional conditions. Example: database.Customers.DeferredFirstOrDefault(c => c.ContactTitle == "Sales Representative").FromCache(options); |
DeferredLast |
Retrieves the last element in a sequence that satisfies the condition. This operator defers execution and caches the result, useful when ordering is important, such as finding the latest entry. Example: database.Customers.DeferredLast(c => c.City == "London").FromCache(options); |
DeferredLastOrDefault |
Similar to DeferredLast , but returns a default value if no matching element is found. This prevents exceptions and is useful for handling optional data while caching results for future use. Example: database.Customers.DeferredLastOrDefault(c => c.City == "London").FromCache(options); |
DeferredSingle |
Retrieves exactly one element from a sequence based on a condition. The query is deferred and cached, ideal for fetching records like unique IDs or specific user accounts. Example: database.Customers.DeferredSingle(c => c.CustomerId == "ALFKI").FromCache(options); |
DeferredSingleOrDefault |
Returns a single matching element or a default value if none exists, ensuring that queries with optional results don’t throw exceptions. Cached for fast subsequent retrieval. Example: database.Customers.DeferredSingleOrDefault(c => c.CustomerId == "ANATR").FromCache(options); |
Miscellaneous LINQ Operators
The following operators are only supported by FromCache
.
Operator | Description |
---|---|
DeferredAll |
Checks if all elements in a sequence satisfy a given condition. This operator defers the execution, and the result is cached, which is beneficial when validating datasets against a condition. Example: database.Products.DeferredAll(expression).FromCache(options); |
DeferredLongCount |
Returns the total number of elements in a sequence, designed for large datasets where the count might exceed the range of an int . The query is deferred, and results are cached for performance. Example: database.Products.DeferredLongCount().FromCache(options); |
DeferredContains |
Determines if a sequence contains a specified element. This operator defers execution, caches the result, and is useful for checking the existence of specific records in large datasets. Example: database.Products.DeferredContains(new Products { ProductId = 1 }); |
See Also
.NET: Alachisoft.NCache.EntityFrameworkCore and Alachisoft.NCache.Runtime.Caching namespace.