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 and LoadIntoCache ignore StoreAs in CachingOptions for query deferred APIs.

• FromCacheOnly only supports Aggregate operators in QueryDeferred.

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.