1. Utilizing AsNoTracking for Read-Only Operations

Utilizing the AsNoTracking method allows you to fetch data without the overhead of tracking changes. This is especially useful in scenarios where data is read-only, resulting in faster query execution.

var users = context.Users.AsNoTracking().ToList();

The example above retrieves all users without the associated tracking overhead, enhancing performance in data-intensive applications.

2. Implementing Explicit Loading

Explicit loading refers to the practice of loading related data from the database at a later stage rather than during the initial query.

var book = context.Books.Single(b => b.BookId == 1);

context.Entry(book).Collection(b => b.Authors).Load();

In this case, the book entity is loaded first, followed by the Authors collection only when explicitly requested.

3. Choosing Configuration Over Conventions

EF Core's conventions can be configured using the OnModelCreating method to define the database schema more explicitly.

public class MyContext : DbContext

{

protected override void OnModelCreating(ModelBuilder modelBuilder)

{

modelBuilder.Entity<User>()

.Property(u => u.Username)

.IsRequired()

.HasMaxLength(100);

}

}

This customization helps ensure that the database schema aligns precisely with your application requirements.

4. Utilizing Query Filters for Multi-Tenancy

Query filters can be set up to apply LINQ predicates globally within the DbContext, allowing you to restrict data access based on specific criteria.

protected override void OnModelCreating(ModelBuilder modelBuilder)

{

modelBuilder.Entity<TenantData>().HasQueryFilter(p => p.TenantId == _tenantId);

}

This effectively filters all queries to include only data pertinent to a specific tenant.

5. Enhancing Query Performance with Index Attributes

Adding index attributes to frequently queried properties can greatly improve performance by narrowing down the data that needs to be scanned.

public class User

{

[Key]

public int UserId { get; set; }

[Required]

[MaxLength(256)]

[Index]

public string Username { get; set; }

}

By indexing the Username property, search operations on this field become significantly more efficient.

6. Reducing Database Roundtrips with Batch Saves

When dealing with multiple inserts or updates, it's advantageous to employ batch operations to limit the number of database roundtrips.

var users = new List<User>

{

new User { Username = "user1" },

new User { Username = "user2" }

};

context.Users.AddRange(users);

context.SaveChanges();

This method of adding multiple users in a single operation optimizes database connection usage.

7. Preventing N+1 Queries in EF Core

The N+1 query problem arises when a single query retrieves primary data, followed by multiple queries for related data. You can mitigate this issue through eager loading.

var departments = context.Departments.Include(d => d.Employees).ToList();

This retrieves departments and their associated employees in one query, avoiding multiple secondary queries.

8. Managing Concurrency with Optimistic Concurrency

Optimistic concurrency is crucial for handling potential conflicts when multiple transactions might modify the same record.

[ConcurrencyCheck]

public string Email { get; set; }

This attribute ensures that the Email field remains unchanged by other transactions during the current operation, thus maintaining data integrity.

9. Judicious Use of Lazy Loading

Lazy loading allows for automatic data retrieval when a navigation property is accessed for the first time.

public virtual ICollection<Order> Orders { get; set; }

This means that Orders will only be loaded when they are specifically accessed, minimizing initial load times.

10. Efficient Pagination Implementation

Implementing efficient pagination helps manage large datasets by fetching only the necessary records.

int pageNumber = 2;

int pageSize = 10;

var users = context.Users.OrderBy(u => u.UserId)

.Skip((pageNumber - 1) * pageSize)

.Take(pageSize)

.ToList();

This approach efficiently limits the results to a specific page of users.

11. Using Select to Shape Data

To minimize memory usage, utilize the Select method to retrieve only necessary fields from the database.

var userProfiles = context.Users

.Select(u => new UserProfileDto

{

UserId = u.Id,

Username = u.Username,

Email = u.Email

})

.ToList();

This retrieves only the required fields, reducing the amount of data transferred.

12. Minimizing Database Hits with Asynchronous Calls

Using asynchronous methods like FirstOrDefaultAsync improves application performance, especially under heavy loads.

var user = await context.Users

.Where(u => u.Username == "john.doe")

.FirstOrDefaultAsync();

This non-blocking call enhances efficiency during high traffic.

13. Pre-Compiling Queries for Repeated Use

Pre-compiling queries can be beneficial when the same query is executed frequently.

var compiledQuery = EF.CompileQuery(

(MyDbContext context, int userId) => context.Users.FirstOrDefault(u => u.UserId == userId)

);

// Usage

var user = compiledQuery.Invoke(context, 5);

This technique is particularly useful in high-load scenarios.

14. Utilizing Transaction Scopes for Consistency

Using transaction scopes ensures that multiple operations either all succeed or fail together.

using (var transaction = context.Database.BeginTransaction())

{

try

{

context.Users.Add(newUser);

context.SaveChanges();

context.Purchases.Add(newPurchase);

context.SaveChanges();

transaction.Commit();

}

catch

{

transaction.Rollback();

}

}

This maintains data consistency across related operations.

15. Optimizing Model Building with OnModelCreating

Leverage the OnModelCreating method to optimize entity configuration, including indexes and relationships.

protected override void OnModelCreating(ModelBuilder modelBuilder)

{

modelBuilder.Entity<User>()

.HasIndex(u => u.Email)

.IsUnique();

}

Creating unique indexes can significantly improve query performance.

16. Implementing Caching for Performance Gains

Caching can decrease database load for static data, enhancing UI responsiveness.

var cacheKey = "Top10Users";

var topUsers = memoryCache.GetOrCreate(cacheKey, entry =>

{

entry.SlidingExpiration = TimeSpan.FromMinutes(10);

return context.Users.OrderBy(u => u.SignupDate).Take(10).ToList();

});

This example caches the top 10 users, refreshing every 10 minutes.

17. Managing Large Datasets with AsSplitQuery

Using split queries is advantageous for handling large data sets with complex includes.

var orders = context.Orders

.Include(o => o.Customer)

.Include(o => o.OrderDetails)

.AsSplitQuery()

.ToList();

This approach breaks down the query into multiple simpler SQL queries.

18. Preventing Memory Leaks with Detach

To avoid memory leaks, detach entities from the DbContext once they are no longer needed.

context.Entry(user).State = EntityState.Detached;

This action helps manage memory usage effectively.

19. Deep Loading with Include and ThenInclude

When loading complex object graphs, utilize Include and ThenInclude for related data.

var books = context.Books

.Include(b => b.Author)

.ThenInclude(a => a.ContactDetails)

.ToList();

This retrieves books along with their authors and contact details in one go.

20. Streaming Large Data Sets with AsAsyncEnumerable

For large datasets, AsAsyncEnumerable allows for asynchronous streaming, reducing memory consumption.

await foreach (var user in context.Users.AsAsyncEnumerable())

{

Console.WriteLine(user.Username);

}

This method enables efficient processing of large data sets.