• Products
  • Solutions
  • Customers
  • Resources
  • Company
  • Pricing
  • Download
Try Playground
  • .NET Third Party Integrations
  • Entity Framework (EF) Core
  • EF Core Extension Methods
  • Query Deferred API
Show / Hide Table of Contents
  • Programmer's Guide
  • Setting Up Development Environment
    • .NET
      • Client API Prerequisites
      • Server-side API Prerequisites
    • Java
      • Client API Prerequisites
      • Server-side API Prerequisites
    • Python
      • Client API Prerequisites
    • Node.js
      • Client API Prerequisites
  • Client Side API Programming
    • Error Handling
    • Troubleshooting
    • Cache Keys and Data
    • How to Connect to Cache
    • Basic Operations - An Overview
      • Add Data
      • Update/Insert Data
      • Retrieve Data
      • Remove Data
    • Groups
      • Overview
      • Add/Update Data with Groups
      • Retrieve Data with Groups
      • Remove Data with Group
      • Search Group Data Using SQL
      • Delete Group Data Using SQL
    • Tags
      • Overview
      • Add/Update Data with Tags
      • Retrieve Data with Tags
      • Remove Data with Tags
      • Search Tag Data Using SQL
      • Delete Tag Data Using SQL
    • Named Tags
      • Overview
      • Add/Update Data with Named Tags
      • Remove Data with Named Tags
      • Search Data with Named Tags Using SQL
      • Delete Data with Named Tags Using SQL
    • Expirations
      • Overview
      • Absolute Expiration
      • Sliding Expiration
    • Data Dependency
      • Key Dependency
      • Multi-Cache Dependency
    • Dependency on Database
      • SQL Server
      • Oracle
      • OleDB with Polling
      • CLR Procedures in SQL Server
    • Dependency on External Source
      • File Dependency
      • Custom Dependency
      • Aggregate Dependency
    • Locks
      • Types of Locking
      • Pessimistic Locking
      • Optimistic Locking
    • SQL Query
      • Overview
      • Define Indexes Programmatically
      • Query with ExecuteReader and ExecuteScalar
      • Delete Data with ExecuteNonQuery
      • SQL Reference
    • LINQ Query
      • Overview
      • LINQ Query for Objects
      • LINQ Reference
    • Data Structures
      • Overview
      • List
      • Queue
      • Set
      • Dictionary
      • Counter
      • Invalidation Attributes
      • Searchable Attributes
      • Query on Data Structures
      • Remove from Data Structure
    • Events
      • Cache Level Events
      • Item Level Events
      • Management Level Events
    • Pub/Sub Messaging
      • Overview
      • Topics
      • Publish Messages
      • Subscribe to a Topic
      • Pub/Sub Events
    • Continuous Query
      • Overview
      • Use Continuous Query
    • Stream Processing
      • Add/Update Stream Data
      • Retrieve Stream Data
    • JSON
      • Overview
      • Use JSON Objects
      • Query JSON Data
    • Security API
      • Login with Credentials
    • Management API
    • Clear Cache
    • Error Logging
    • Location Affinity
  • Server-side API Programming
    • Loader and Refresher
      • Overview
      • Implement Loader and Refresher
      • Components of Loader/Refresher
    • Data Source Providers
      • Read-through
        • Implement Read-through
        • Use Read-through
      • Write-through
        • Implement Write-through
        • Use Write-through
        • Use Write-behind
    • Custom Dependency
      • Implement Extensible Dependency
      • Implement Bulk Extensible Dependency
      • Implement Notify Extensible Dependency
    • Bridge Conflict Resolver
    • Entry Processor
      • Overview
      • Implement Entry Processor
    • MapReduce
      • Overview
      • Implement MapReduce
      • Use MapReduce
    • MapReduce Aggregator
      • Overview
      • Implement and Use Aggregator
    • Compact Serialization
  • Client Side Features
    • ASP.NET Core Caching
      • Session Storage
        • Session Provider
        • IDistributedCache
        • Sessions Usage
        • Multi-site Session Provider
        • Session Sharing with ASP.NET
      • SignalR
        • NCache Extension for SignalR Core
      • Response Caching
        • Configure and Use
        • Configure with IDistributedCache
      • Data Caching
        • NCache API
        • IDistributedCache API
      • Data Protection Provider
        • Configure
    • Java Web App Caching
      • Web Sessions
        • Overview
        • Configure App
          • Add Maven Dependencies
          • Deploy Application
        • Multi-site Sessions
    • Node.js App Caching
      • Web Sessions
    • ASP.NET Caching Benefits and Overview
      • ASP.NET Session State Provider Properties
      • Multi-region ASP.NET Session State Provider Configuration
      • Session Sharing between ASP.NET and ASP.NET Core
      • ASP.NET SignalR Backplane
        • NCache Extension for SignalR
      • ASP.NET View State Caching
        • View State Content Optimization Configuration
        • Group View State with Sessions
        • Limit View State Caching
        • Page Level Grouping
      • ASP.NET Output Cache
        • Output Caching Provider Overview
        • Output Cache with Custom Hooks
  • .NET Third Party Integrations
    • Entity Framework (EF) Core
      • Installation
      • Configure
      • EF Core Extension Methods
        • Extension Methods
        • Cache Handle
        • Caching Options
        • Query Deferred API
      • Logging in EF Core
    • Entity Framework EF 6
      • EF Second Level Cache
      • EF Caching Resync Provider
      • EF Caching Configuration File
    • NHibernate
      • Second Level Cache
      • Query Caching
      • Synchronize Database with Cache
    • Debug NCache Providers in Visual Studio
  • Java Third Party Integrations
    • Hibernate
      • Second Level Cache
      • Configure Cacheable Objects and Regions
      • Configure Application
      • Query Caching
    • Spring
      • Overview
      • Use NCache with Spring
        • Configure Generic Provider
        • Configure JCache Spring Caching Provider
        • Configure Caching Declaration
        • Configure Spring Sessions
    • JCache API
      • CRUD Operations
      • Expiration
      • Events
  • Third-Party Wrappers
    • AppFabric to NCache Migration
      • AppFabric API vs. NCache API
      • Configuration Differences Between AppFabric and NCache
      • Migrating from an AppFabric Application to NCache
    • Redis to NCache Migration
      • Redis to NCache Migration
    • Memcached Wrapper
      • Memcached Gateway Approach
      • Memcached Client Plugin for .NET

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.

In This Article
  • Aggregate Operators Supported for EFCore
  • Element Operators
  • Miscellaneous LINQ Operators
  • See Also

Contact Us

PHONE

+1 (214) 764-6933   (US)

+44 20 7993 8327   (UK)

 
EMAIL

sales@alachisoft.com

support@alachisoft.com

NCache
  • NCache Enterprise
  • NCache Professional
  • Edition Comparison
  • NCache Architecture
  • Benchmarks
Download
Pricing
Try Playground

Deployments
  • Cloud (SaaS & Software)
  • On-Premises
  • Kubernetes
  • Docker
Technical Use Cases
  • ASP.NET Sessions
  • ASP.NET Core Sessions
  • Pub/Sub Messaging
  • Real-Time ASP.NET SignalR
  • Internet of Things (IoT)
  • NoSQL Database
  • Stream Processing
  • Microservices
Resources
  • Magazine Articles
  • Third-Party Articles
  • Articles
  • Videos
  • Whitepapers
  • Shows
  • Talks
  • Blogs
  • Docs
Customer Case Studies
  • Testimonials
  • Customers
Support
  • Schedule a Demo
  • Forum (Google Groups)
  • Tips
Company
  • Leadership
  • Partners
  • News
  • Events
  • Careers
Contact Us

  • EnglishChinese (Simplified)FrenchGermanItalianJapaneseKoreanPortugueseSpanish

  • Contact Us
  •  
  • Sitemap
  •  
  • Terms of Use
  •  
  • Privacy Policy
© Copyright Alachisoft 2002 - 2025. All rights reserved. NCache is a registered trademark of Diyatech Corp.
Back to top