Interview Questions and Answers

Entity Framework (EF) is an object-relational mapping (ORM) framework that enables developers to work with relational data using domain-specific objects.

DbContext is a class in EF that represents a session with the database, allowing you to query and save data.

You can disable Lazy Loading by setting the LazyLoadingEnabled property of the DbContext to false.

The Include method is used to specify related entities that should be loaded along with the main entity. For example, context.Orders.Include(o => o.Customer).ToList();

The AsNoTracking method is used to disable change tracking for a specific query, which can improve performance when you only need to read data.

The [Table] attribute is used to specify the table name for an entity when it does not match the default convention.

Example:

[Table("MyCustomTableName")] public class MyEntity { /* properties */ }

The [Key] attribute is used to specify the primary key property of an entity when it does not match the default convention.

Example:

[Key] public int MyCustomId { get; set; }

The [NotMapped] attribute is used to specify that a property should not be mapped to a column in the database.

Example:

[NotMapped] public string CalculatedProperty { get { /* calculation logic */ } }

The DbSet.Find method is used to retrieve an entity from the database by its primary key value.

Example:

var entity = context.MyEntities.Find(1);

The [MaxLength] attribute is used to specify the maximum length of a string or binary property when creating the database schema.

Example:

[MaxLength(50)] public string Name { get; set; }

The ToListAsync method is used to asynchronously execute a query and return the result as a List.

Example:

var result = await context.Entities.ToListAsync();

The [Required] attribute is used to specify that a property is required and must have a non-null value when saving to the database.

Example:

[Required] public string Name { get; set; }

The [StringLength] attribute is used to specify the maximum length of a string property when creating the database schema.

Example:

[StringLength(100)] public string Description { get; set; }

The Add method is used to add a new entity to the context, marking it as Added, and inserting it into the database when SaveChanges is called.

Example:

context.Entities.Add(newEntity);

The Remove method is used to mark an entity as Deleted in the context, and the entity will be deleted from the database when SaveChanges is called.

Example:

context.Entities.Remove(entityToDelete);

The AsQueryable method is used to convert an IEnumerable to IQueryable, enabling the use of LINQ expressions to query a collection.

Example:

var queryable = list.AsQueryable();

The Set method is used to get a DbSet for a given entity type, allowing you to perform database operations on that entity type.

Example:

var set = context.Set();

The FindAsync method is used to asynchronously retrieve an entity from the database by its primary key value.

Example:

var entity = await context.MyEntities.FindAsync(1);

Code First is an approach where you define your data model using C# or VB.NET classes, and the database is generated based on these classes.

DbContext is a representation of a session with the database, while DbSet is a collection of entities that are used to perform database operations on those entities.

Lazy Loading is a feature in EF where related entities are not loaded from the database until they are explicitly accessed in code.

Eager Loading is the opposite of Lazy Loading. It loads the related entities along with the main entity in a single database query.

Database First is an approach where the data model is generated from an existing database, and the corresponding classes are created in the application.

You can use the SqlQuery method of the Database property in DbContext to execute raw SQL queries.

Example:

var result = context.Database.SqlQuery("SELECT * FROM MyTable");

Migrations are a way to manage database schema changes over time. They allow you to evolve your database schema as your application evolves.

EntityState is an enumeration that represents the state of an entity being tracked by the DbContext. It can be used to determine whether an entity is new, modified, or deleted.

The DatabaseGenerated attribute is used to configure how values for a property are generated by the database when inserting a new record.

Example:

[DatabaseGenerated(DatabaseGeneratedOption.Identity)] public int Id { get; set; }

The ExecuteSqlCommand method is used to execute a SQL command that does not return any results, such as an UPDATE or DELETE statement.

Example:

context.Database.ExecuteSqlCommand("UPDATE MyTable SET Column1 = 1 WHERE Id = 1");

The IDbSet interface is an interface that represents a collection of entities in the context. It is implemented by DbSet.

You can execute stored procedures in EF using the context.Database.SqlQuery method or by creating a method on your DbContext that calls SqlQuery or ExecuteSqlCommand.

ChangeTracker is a property of DbContext that keeps track of the changes made to entities, allowing you to inspect and revert changes before saving to the database.

The [ForeignKey] attribute is used to specify the foreign key property in a relationship when the default convention is not followed.

Example:

[ForeignKey("CategoryId")] public int CategoryId { get; set; }

The Entry method is used to access the EntityEntry object, which provides information about an entity being tracked by the context and allows you to perform actions like updating and deleting.

Example:

var entry = context.Entry(entity);

The State property of EntityEntry is used to get or set the state of an entity being tracked by the context, such as Added, Modified, or Deleted.

Example:

entry.State = EntityState.Modified;

The FromSqlRaw method is used to create a query based on raw SQL and map the result to entities. It is often used for executing stored procedures.

Example:

var result = context.Entities.FromSqlRaw("EXEC dbo.GetEntities");

The IsDeleted property is often used in soft delete scenarios where instead of actually deleting a record, a flag is set to mark it as deleted.

Example:

public bool IsDeleted { get; set; }

The Attach method is used to reattach a disconnected entity to the context, allowing you to update it without having to retrieve it again from the database.

Example:

context.Entities.Attach(disconnectedEntity);

Code First Conventions are a set of rules that automatically configure the database schema based on the shape of your entity classes and their relationships.

The Fluent API is an alternative to the Data Annotations for configuring the model in Entity Framework. It provides a more programmatic way to configure the database schema.

The InverseProperty attribute is used to specify the inverse navigation property in a relationship when the default convention is not followed.

The Database.Log property is used to log SQL statements and other information related to database operations. It can be useful for debugging and performance tuning.

Example:

context.Database.Log = Console.WriteLine;

The [ConcurrencyCheck] attribute is used to specify that a property should be included in the WHERE clause of an UPDATE or DELETE statement to check for concurrency conflicts.

Example:

[ConcurrencyCheck] public byte[] RowVersion { get; set; }

The AsSplitQuery method is used to enable split queries for a LINQ query, allowing EF to generate separate SQL queries for different parts of the LINQ query.

The AsNoFilter method is used to disable query filters defined in the model, allowing you to retrieve entities without applying those filters.

The Keyless attribute is used to specify that an entity type does not have a primary key, and it is used for query types that represent database views or tables without primary keys.

Example:

[Keyless] public class MyQueryType { /* properties */ }

The Entry.StateChanged event is triggered when the state of an entity being tracked by the context changes. It can be used for implementing custom logic based on entity state changes.

Example:

entry.StateChanged += (sender, e) => { /* custom logic */ };