أسئلة القسم

Entity Framework Core (EF Core) is Microsoft’s modern Object-Relational Mapper (ORM) for .NET. It lets you work with databases using C# classes instead of SQL directly.

Advantages:

• Cross-platform (works with .NET Core)
• Supports LINQ queries
• Change tracking and relationship management
• Migrations for schema evolution
• Works with many databases (SQL Server, PostgreSQL, MySQL, SQLite)

A way to evolve the database schema as your models change. They keep C# models and DB schema in sync.

Example commands:

• Add-Migration InitialCreate
• Update-Database

Seeding = pre-populating the database with initial/static data. Done in OnModelCreating using .HasData().

Example:

modelBuilder.Entity<Role>().HasData(new Role { Id = 1, Name = "Admin" });

• SaveChanges(): Synchronous, blocks the thread until DB operation finishes.
• SaveChangesAsync(): Asynchronous, does not block, returns a Task. Use SaveChangesAsync() in web apps for better scalability.

Change Tracking means EF keeps track of entity states (Added, Modified, Deleted, Unchanged). Helps generate the correct SQL for SaveChanges().

• IEnumerable: Executes query in memory after fetching data.
• IQueryable: Translates query to SQL and executes in DB.

Example:

// IEnumerable -> loads all then filters in memory
db.Users.AsEnumerable().Where(u => u.Age > 18);

// IQueryable -> SQL WHERE clause executed on server
db.Users.Where(u => u.Age > 18);

• Eager Loading: Related entities loaded immediately (Include()).
• Lazy Loading: Related entities loaded when accessed (requires proxies).

• Add-Migration – create migration
• Update-Database – apply migration
• Remove-Migration – undo last migration Use version control to keep migrations in sync across environments.

Properties not defined in your C# entity, but tracked by EF. Useful for metadata (e.g., CreatedDate, LastModifiedBy).

Filters applied automatically to all queries for an entity. Example: Soft delete or multi-tenancy.

Example:

modelBuilder.Entity<User>().HasQueryFilter(u => !u.IsDeleted);

• Entity: Has identity (Id), tracked by EF.
• Value Object: No identity, compared by value.

• Normal queries: Entities tracked by EF.
• AsNoTracking(): Returns entities not tracked, better for read-only queries.

Complex types owned by another entity, no separate table by default.

Example:

modelBuilder.Entity<User>().OwnsOne(u => u.Address);

• EF assigns states: Added, Modified, Deleted, Unchanged.
• Uses snapshots or proxies to detect changes.
• On SaveChanges(), generates SQL based on state.

• LINQ -> Expression Tree -> SQL via EF Core provider.

Example:

db.Users.Where(u => u.Age > 18);

becomes

SELECT * FROM Users WHERE Age > 18;

Using ILogger or LogTo:

optionsBuilder.LogTo(Console.WriteLine);

• Entities without primary keys, used for read-only queries (e.g., views, raw SQL).
• Defined with .HasNoKey().

• Use AsNoTracking() for read-only.
• Project only needed columns (Select).
• Use eager loading wisely.
• Avoid N+1 queries.
• Use compiled queries for repeated queries.
• Profile queries with logging/SQL Profiler.

• A transaction ensures ACID properties.
• EF Core wraps SaveChanges() in a transaction.
• For multiple operations:

using var transaction = db.Database.BeginTransaction();
try {
    db.SaveChanges();
    transaction.Commit();
}
catch {
    transaction.Rollback();
}

• Interceptors = hooks into EF Core lifecycle (command execution, saving, connections).
• Useful for logging, auditing, multi-tenancy, soft deletes.

• Optimistic: Assumes no conflicts, uses row version or timestamp. If conflict -> exception.
• Pessimistic: Uses locks to prevent conflicts (via transactions).

• EF normally compiles LINQ -> SQL each time.
• Compiled queries cache the translation for reuse.
• Improves performance for frequently executed queries.

• Table Splitting: Multiple entities share one table.
• Inheritance:
  • TPH (Table-per-Hierarchy): All types in one table.
  • TPT (Table-per-Type): Separate table for each class.
  • TPC (Table-per-Concrete Type): Separate table for each concrete type, no joins.

• Problem: One query for main entity + one query per related entity.
• Example: Looping over users and fetching roles separately.
• Solution: Use Eager Loading (Include) or projection with Select.