Entity
Framework Core interview questions you might encounter:
1.
How does Entity
Framework Core handle data concurrency conflicts?
·
EF Core uses optimistic concurrency control. When multiple users
try to modify the same record simultaneously, it checks if the record has
changed since it was loaded. If so, it throws a DbUpdateConcurrencyException.
2.
What are the core
differences between Entity Framework 6 and Entity Framework Core?
·
EF Core is lightweight, cross-platform, and designed for modern
applications. It lacks some features of EF 6 (e.g., lazy loading, EDMX
designer), but offers better performance and flexibility.
3.
How would you map a
database schema to entities in Entity Framework Core?
·
Use data annotations or Fluent API to define relationships,
keys, and constraints. Customize the model by configuring entity properties and
navigation properties.
When optimizing
performance in Entity Framework Core (EF Core), consider the following
strategies:
Retrieve Only
Necessary Data:
Fetch only the columns you need from the
database. Use .Select() to project specific properties and minimize data
retrieval.
Split Large Data
Contexts:
Divide a large data context into smaller ones.
This can improve performance by reducing the overhead of tracking entities.
Batch Updates:
For bulk updates, use batch operations
(SaveChanges() with multiple entities). This reduces the number of database
round trips.
Disable Change Tracking
for Read-Only Queries:
If you’re querying data for read-only
purposes, disable change tracking to avoid unnecessary overhead.
DbContext Pooling:
Reuse DbContext instances using pooling. This
minimizes the cost of creating and disposing of contexts.
Use IQueryable Instead
of IEnumerable:
Prefer IQueryable over IEnumerable for better
query translation and execution.
Eager Loading:
Explicitly load related entities using .Include() to avoid lazy loading overhead.
DbContext pooling is
a feature in Entity Framework Core (EF Core) that helps improve performance and
resource utilization when working with database contexts. Let’s dive into the
details:
What is DbContext?
DbContext is a fundamental class in EF Core. It
represents a session with the database and provides an abstraction over the
underlying database connection. It allows you to query, insert, update, and
delete data.
Why Use DbContext Pooling?
Creating a new DbContext instance for every
database operation can be expensive. It involves overhead such as connection
establishment, model initialization, and change tracking setup.
DbContext pooling addresses this by reusing existing
instances, reducing the overhead of creating new contexts.
How Does DbContext Pooling Work?
When you enable pooling, EF Core maintains a pool of
pre-initialized DbContext instances.
When you request a context, it’s taken from the pool
(if available) rather than creating a new one.
After use, the context is returned to the pool for
reuse.
Enabling DbContext Pooling:
To enable pooling, set the UseDbContextPooling option
in your DbContext configuration:
C#
services.AddDbContext<MyDbContext>(options =>
{
options.UseSqlServer(connectionString);
options.UseDbContextPooling();
});
DbContext pooling is most beneficial in scenarios with
frequent short-lived database operations (e.g., web applications).
Be cautious with long-lived contexts (e.g., background
services) as they may accumulate state over time.
Fluent API in
Entity Framework Core (EF Core) allows you to configure domain classes and
override conventions without modifying your entity classes directly. It
provides fine-grained control over how your entities map to database tables.
Fluent API and DbContext Configuration:
The most powerful way to configure your model in EF
Core is by overriding the OnModelCreating method in your derived
context.
Within this method, you can use Fluent API to specify
how entities map to tables, define relationships, and more.
Fluent API configuration has the highest precedence
and overrides conventions and data annotations.
1.
Conventions:
o
Conventions are the default rules that EF
Core follows to map your domain model to the database schema.
o
For example, EF Core assumes that a
property named Id is the primary key, and it pluralizes entity names
to find corresponding table names.
o
Conventions simplify development by
providing sensible defaults.
2.
Data
Annotations:
o
Data annotations are attributes you apply
directly to your entity classes or properties.
o
They allow you to customize aspects of the
model, such as specifying column names, defining keys, or setting data types.
o
Examples include [Key], [Column],
and [MaxLength].
3.
Fluent
API:
o
Fluent API provides a more flexible and
explicit way to configure your model.
o
You override the OnModelCreating method
in your DbContext and use fluent methods to define mappings,
relationships, and other details.
o
It allows fine-grained control, such as
specifying composite keys, unique constraints, and custom column names.
4.
Precedence:
o
When there’s a conflict between
conventions, data annotations, and fluent configuration, fluent
configuration wins.
o
If you explicitly configure something
using fluent API, it overrides any conventions or data annotations related to
the same aspect.
Fluent
API in
Entity Framework Core (EF Core), you can specify which properties form the
composite key. Here’s an example:
Suppose we have an entity named Employee with
properties Id and Name. We want to create a composite key using
both properties. Here’s how you can do it:
C#
public class Employee
{
public int
Id { get; set; }
public string
Name { get; set; }
}
public class YourContext : DbContext
{
public DbSet<Employee>
employee { get; set; }
protected override
void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity<Employee>().HasKey(emp => new { emp.Id, emp.Name
});
}
}
In this example, the HasKey method specifies
that the composite key consists of both Id and Name. This
ensures uniqueness based on the combination of these properties
No comments :
Post a Comment