.NET and C# Interview Questions India 2026: ASP.NET Core, Entity Framework, and LINQ

C# object-oriented programming and language features are the foundation of every .NET interview in India.

Object-oriented programming in C#:

1. Classes and objects: a class is the blueprint; an object is an instance. Class members: fields, properties, methods, constructors, events
2. Properties: syntactic sugar over getter/setter methods: public string Name { get; set; } or public string Name { get; private set; }
3. Inheritance: a class can inherit from one base class (single inheritance). Use : BaseClass
4. Polymorphism: virtual methods in the base class can be overridden (override keyword) by derived classes; the correct method is called based on the runtime type
5. Abstract class: cannot be instantiated; can have abstract methods (no implementation; derived classes must implement) and concrete methods
6. Interface: a contract; defines method signatures without implementation (in C# versions before 8); a class implements an interface using : IMyInterface; supports multiple interfaces
7. Sealed class: cannot be inherited: sealed class MyClass { }
8. Static class: can only have static members; cannot be instantiated (used for utility/helper classes)

Value types vs reference types:

1. Value types: stored on the stack (for local variables); copied when assigned or passed to a method. Examples: int, double, bool, char, struct, enum
2. Reference types: stored on the heap; the variable holds a reference (pointer) to the object. Examples: class, string, array, delegate, interface
3. Nullable value types: int? salary = null; — the ? suffix makes a value type nullable (wraps in Nullable<T>)
4. Boxing: converting a value type to object (reference type) — allocates heap memory; avoid in performance-critical code
5. Unboxing: converting the object back to a value type — must match the original type or throws InvalidCastException

Async/Await:

1. async marks a method as asynchronous; it must return Task, Task<T>, or void (avoid async void except for event handlers)
2. await suspends the current method until the awaited Task completes, without blocking the calling thread
3. The await expression unwraps Task<T> and returns T
4. Task.Run(() => heavyComputation()) — run CPU-bound work on the thread pool
5. await Task.Delay(1000) — asynchronous delay (does not block the thread)
6. Task.WhenAll(task1, task2) — await multiple tasks in parallel; throws if any task throws
7. Task.WhenAny(task1, task2) — await until the first task completes
8. ConfigureAwait(false): by default, await resumes on the original synchronisation context; ConfigureAwait(false) resumes on any thread pool thread (better for library code; avoids deadlocks in ASP.NET classic)

LINQ is heavily tested in every .NET interview in India. Interviewers ask you to read, write, and optimise LINQ queries.

LINQ (Language Integrated Query):

1. LINQ provides a unified query syntax for in-memory collections (IEnumerable<T>), databases (IQueryable<T> via EF Core), XML (LINQ to XML), and more
2. Method syntax (most common in professional code): list.Where(x => x.Age > 25).OrderBy(x => x.Name).Select(x => x.Name).ToList()
3. Query syntax (SQL-like): from x in list where x.Age > 25 orderby x.Name select x.Name
4. Deferred execution: LINQ queries on IEnumerable<T> and IQueryable<T> are not executed until enumerated (e.g., ToList(), First(), foreach loop)
5. Immediate execution methods: ToList(), ToArray(), Count(), First(), Single(), Any(), All(), Sum(), Average(), Min(), Max()

Common LINQ methods:

1. Where(x => condition) — filter elements
2. Select(x => projection) — transform elements
3. SelectMany(x => x.Children) — flatten nested collections
4. OrderBy(x => x.Name) / OrderByDescending(x => x.Age) — sort
5. ThenBy(x => x.Department) — secondary sort
6. GroupBy(x => x.Department) — group elements; returns IGrouping<TKey, TElement>
7. Join(other, x => x.Id, y => y.UserId, (x, y) => new { x.Name, y.Order }) — join two collections
8. Distinct() — remove duplicates
9. Take(10) / Skip(20) — pagination
10. First() / FirstOrDefault() — first element (FirstOrDefault returns null/default if empty; First throws)
11. Single() / SingleOrDefault() — exactly one element (throws if more than one)
12. Any(x => x.IsActive) — true if any element matches
13. All(x => x.IsValid) — true if all elements match
14. Aggregate(seed, (acc, x) => acc + x.Value) — general fold operation

Generics:

1. Generic types: List<T>, Dictionary<TKey, TValue>, IEnumerable<T>
2. Generic methods: T Max<T>(T a, T b) where T : IComparable<T> { return a.CompareTo(b) > 0 ? a : b; }
3. Constraints: where T : class (reference type), where T : struct (value type), where T : new() (has parameterless constructor), where T : IDisposable

Exception handling:

1. try { } catch (SpecificException ex) { } catch (Exception ex) { } finally { }
2. Catch the most specific exception first; Exception is the base type and should be last
3. finally always executes (even if an exception is thrown or return is called); use for cleanup
4. throw; — rethrow the current exception preserving the stack trace (vs throw ex; which resets the stack trace)
5. Custom exceptions: inherit from Exception: class PaymentException : Exception { public PaymentException(string message) : base(message) { } }

ASP.NET Core and Entity Framework Core are the most tested framework topics at Indian .NET developer interviews.

.NET Core vs .NET Framework:

1. .NET Framework: Windows-only; ships with Windows; not actively developed for new features (only security patches)
2. .NET Core / .NET 5+: cross-platform (Windows, Linux, macOS); open-source; better performance; actively developed. Modern .NET development targets .NET 8 or .NET 9
3. .NET Standard: a specification that both .NET Framework and .NET Core implemented; used for shared libraries that must run on both

ASP.NET Core:

1. Program.cs (minimal hosting model in .NET 6+): configures services (dependency injection container) and the request pipeline (middleware)
2. Middleware: components in the request pipeline; each middleware can handle the request and/or pass it to the next middleware. Built-in: UseRouting, UseAuthentication, UseAuthorization, UseStaticFiles
3. Controller: a class with actions (methods) that handle HTTP requests; inherits from ControllerBase (Web API) or Controller (MVC with views)
4. Routing: [Route("api/[controller]")] attribute on the controller; [HttpGet("{id}")] on the action
5. Model binding: ASP.NET Core maps request data to action parameters: [FromBody] (request body), [FromQuery] (query string), [FromRoute] (route parameter), [FromHeader]
6. Action result types: Ok(data), NotFound(), BadRequest(ModelState), CreatedAtAction(), NoContent()
7. Model validation: [Required], [Range], [MaxLength] data annotations; check ModelState.IsValid in the action

Entity Framework Core:

1. DbContext: the unit of work and connection to the database; derive from DbContext and add DbSet<T> properties for each entity
2. DbSet<T>: represents a table; supports LINQ queries
3. Migrations: code-first schema management; dotnet ef migrations add MigrationName creates a migration; dotnet ef database update applies it
4. LINQ with EF Core: queries are translated to SQL; IQueryable<T> queries are sent to the database; call ToListAsync() to execute
5. Include(): eager loading of related entities: db.Orders.Include(o => o.Customer).Include(o => o.Items).ToListAsync()
6. Tracking vs no-tracking: by default EF Core tracks entities for change detection; use .AsNoTracking() for read-only queries (faster)
7. SaveChangesAsync(): applies all pending changes to the database in a single transaction

Dependency Injection:

1. Services are registered in Program.cs: builder.Services.AddScoped<IOrderService, OrderService>()
2. AddScoped: one instance per HTTP request
3. AddTransient: a new instance every time the service is requested
4. AddSingleton: one instance for the lifetime of the application
5. Constructor injection: declare dependencies in the constructor; the DI container resolves and injects them
6. IServiceProvider.GetService<T>(): resolve a service from the container manually (avoid in application code; prefer constructor injection)
7. Named options pattern: IOptions<T>, IOptionsSnapshot<T>, IOptionsMonitor<T> for injecting typed configuration