- How do you create and manage multiple tasks (`Task.WhenAll()`, `Task.WhenAny()`)?
- How do you handle exceptions in `async` methods?
- How do you implement progress reporting in async operations?
- How do you use `async` streams (`IAsyncEnumerable<T>`)?
- How do you use the `async` and `await` keywords in C#?
- How does `await` work behind the scenes?
- What are `ValueTask<T>`?
- What are `async void` methods and when should you avoid them?
- What are cancellation tokens (`CancellationToken`)?
- What is `ConfigureAwait(false)` and when should you use it?
- What is `Task.Run()` and when should you use it?
- What is a `Task` and `Task<T>`?
- What is asynchronous programming and why is it important?
- What is the Task Parallel Library (TPL)?
- What is the difference between synchronous and asynchronous methods?
- Can the `finally` block be skipped? If so, under what circumstances?
- How do you create and use custom exception types?
- How do you declare and initialize variables in C#?
- How do you define methods, properties, and constructors in C#?
- How do you handle multiple exceptions in a single `catch` block (exception filters)?
- How do you implement custom collection classes?
- How do you implement inheritance in C# using `:`?
- How do you iterate over elements in a Collection in C# (using `foreach`, `for`, LINQ)?
- How do you sort a Collection in C# (`List<T>.Sort()`, LINQ `OrderBy`)?
- How do you throw custom exceptions in C# (using `throw` and `throw ex`)?
- How do you use `break` and `continue` statements in loops?
- How do you use `try`, `catch`, `finally` blocks in C#?
- How do you use `yield return` for custom iterators?
- How do you use string interpolation?
- How does exception handling affect performance?
- How does the `switch` statement work in C#?
- Should you catch general `Exception`?
- What are access modifiers in C# (public, private, protected, internal, protected internal)?
- What are best practices for exception handling in C#?
- What are common exception types and when do they occur?
- What are events and delegates?
- What are exception filters and how do they work?
- What are extension methods?
- What are indexers?
- What are nullable value types?
- What are observable collections (`ObservableCollection<T>`)?
- What are partial classes and methods?
- What are records in C# 9.0 and later?
- What are sealed classes?
- What are the differences between `IComparable<T>` and `IComparer<T>`?
- What are the differences between `System.Exception` and its derived classes?
- What are the differences between arrays and lists?
- What are the different implementations of the `Set<T>` interface (`HashSet<T>`, `SortedSet<T>`)?
- What are the different types of loops in C# (for, while, do-while, foreach)?
- What are the different types of operators in C#?
- What are the four pillars of OOP?
- What are the main interfaces in the .NET Collections Framework (`IEnumerable`, `ICollection`, `IList`, `ISet`, `IDictionary`)?
- What are the primitive data types in C#?
- What are thread-safe Collection classes in .NET (`ConcurrentBag<T>`, `ConcurrentDictionary<TKey, TValue>`, etc.)?
- What are tuples in C#?
- What are value types and reference types?
- What is a class and a struct in C#, and when to use each?
- What is an exception in C#?
- What is boxing and unboxing?
- What is encapsulation, and why is it important in C#?
- What is method overloading and method overriding (using `virtual` and `override`)?
- What is polymorphism in C#, and how is it achieved (inheritance, interfaces, generics)?
- What is the Common Language Runtime (CLR)?
- What is the `var` keyword and type inference?
- What is the difference between .NET Framework, .NET Core, and .NET 5+?
- What is the difference between `==` and `.Equals()`?
- What is the difference between `List<T>`, `ArrayList`, and `LinkedList<T>`?
- What is the difference between abstract classes and interfaces (including default interface methods)?
- What is the exception hierarchy in .NET?
- What is the purpose of `Exception.InnerException`?
- What is the purpose of generics in C# Collections (`<T>`)?
- What is the purpose of the `static` keyword in C#?
- What is the purpose of the `throw` keyword by itself?
- What is type casting in C#, and what are the different types (implicit, explicit)?
- When should you use `Dictionary<TKey, TValue>` vs `Hashtable`?
- Authentication and Authorization (Identity, JWT, custom policies)
- AutoMapper for object-to-object mapping
- BenchmarkDotNet for performance benchmarking
- Blazor for client-side web UI with C# (components, routing, data binding)
- Building RESTful APIs with ASP.NET Core Web API (controllers, routing, response codes)
- Code-First, Database-First, and Model-First approaches
- Concurrency control (optimistic, pessimistic)
- Configuration and Options (appsettings.json, environment variables)
- Connecting to different database providers (SQL Server, PostgreSQL, MySQL, SQLite)
- Controllers and Actions (MVC and Razor Pages)
- DbContext and DbSet (configuration, contexts)
- Dependency Injection in ASP.NET Core (services, lifetimes)
- Eager loading, lazy loading, and explicit loading
- FluentValidation for data validation
- GraphQL libraries (.NET GraphQL)
- Hangfire for background job processing
- How to deploy ASP.NET Core applications?
- How to handle disconnected entities?
- How to handle state management in ASP.NET Core?
- How to handle static files?
- How to implement database seeding?
- How to implement logging in ASP.NET Core?
- How to use DbContext pooling?
- IdentityServer4/Duende IdentityServer for security (OpenID Connect, OAuth 2.0)
- JSON serialization and deserialization (`System.Text.Json`, Newtonsoft.Json)
- Logging frameworks (`Serilog`, NLog, `Microsoft.Extensions.Logging`)
- MediatR for in-process messaging (CQRS)
- Migrations (creating, applying, reverting)
- Model Binding and Validation (Data Annotations, Custom Validation) in ASP.NET Core
- Moq for mocking
- Performance optimization in EF Core (no-tracking queries, compiled queries, indexing)
- Polly for resilience and fault handling (retries, circuit breaker)
- Querying data with LINQ to Entities (filtering, sorting, projection)
- Refit for type-safe REST client generation
- Relationships (one-to-one, one-to-many, many-to-many, fluent API configuration)
- Routing in ASP.NET Core (attribute routing, conventional routing)
- SignalR for real-time communication (hubs, clients)
- System.Reactive (Rx.NET) for reactive programming
- Tag Helpers and HTML Helpers in Razor Pages and MVC
- Tracking and saving changes (SaveChanges, Add, Update, Remove)
- Transactions (explicit, implicit)
- Understanding the request pipeline and middleware
- Unit testing frameworks (xUnit.net, NUnit, MSTest)
- Using raw SQL queries and stored procedures
- What are Razor Components?
- What are change trackers and how do they work?
- What are filters in ASP.NET Core?
- What are split queries and single queries?
- What are value converters?
- What is ASP.NET Core and its benefits?
- What is EF Core and its benefits as an ORM?
- What is the Unit of Work pattern in the context of EF Core?
- Working with databases using Entity Framework Core (migrations, querying, saving)
- YamlDotNet for YAML serialization/deserialization
- gRPC for efficient API communication (protobuf, services)
- Asynchronous file I/O (`File.ReadAllTextAsync`, `FileStream.ReadAsync`, etc.)
- Building web servers with ASP.NET Core Kestrel
- Creating TCP/IP sockets (`TcpClient`, `TcpListener`)
- Creating UDP sockets (`UdpClient`)
- File and directory information (`FileInfo`, `DirectoryInfo`)
- Handling HTTP responses (`HttpResponseMessage`)
- Handling network exceptions (`SocketException`, `HttpRequestException`)
- How to compress and decompress files (`GZipStream`, `DeflateStream`)?
- How to download files asynchronously?
- How to handle cookies and sessions in HTTP?
- How to handle large files efficiently?
- How to monitor file system changes (`FileSystemWatcher`)?
- How to use gRPC for inter-service communication?
- How to work with paths (`Path` class)?
- Implementing client-server communication
- Making HTTP requests with `HttpClient`
- Memory-mapped files
- Overview of .NET networking namespaces (`System.Net`, `System.Net.Http`, `System.Net.Sockets`)
- Overview of .NET stream classes (`Stream`, `FileStream`, `MemoryStream`, `BufferedStream`)
- Reading and writing binary files (`BinaryReader`, `BinaryWriter`)
- Reading and writing text files (`StreamReader`, `StreamWriter`, `File.ReadAllText`, `File.WriteAllText`)
- Serialization and deserialization (`System.Text.Json`, `System.Xml.Serialization`, `BinaryFormatter`)
- What are network security concepts in .NET?
- What are the different file access modes?
- Working with DNS (`Dns` class)
- Working with URIs (`Uri` class)
- Working with WebSockets (`ClientWebSocket`, `WebSocket`)
- Working with different file encodings (`Encoding` class)
- Working with directories (`Directory` class)
- Working with isolated storage
- Asynchronous LINQ queries (`ToListAsync()`, etc.)
- Common LINQ operators (`where`, `select`, `orderby`, `groupby`, `join`, `let`, `take`, `skip`, etc.)
- Deferred execution in LINQ
- Deferred execution in LINQ to Entities
- Different types of joins in LINQ?
- How to handle transactions in EF Core with LINQ?
- How to use `FirstOrDefault()`, `SingleOrDefault()`, etc.?
- How to use `GroupBy()` for data grouping?
- How to use `Include()` and `ThenInclude()` for eager loading?
- How to use `SelectMany()` for flattening sequences?
- How to write custom LINQ extension methods?
- How to write raw SQL queries in EF Core?
- Immediate execution in LINQ (`ToList()`, `ToArray()`, etc.)
- Introduction to LINQ to Entities
- Loading related data (eager loading, lazy loading, explicit loading)
- Performance considerations in LINQ to Entities
- Performance considerations with LINQ
- Projecting data with `select` and anonymous types
- Querying databases with LINQ
- Understanding LINQ query expressions
- Using LINQ with stored procedures
- Using lambda expressions with LINQ
- What are LINQ aggregation methods (`Sum()`, `Average()`, `Min()`, `Max()`, `Count()`)?
- What are LINQ query syntax and method syntax?
- What are database migrations and how to use them with LINQ?
- What are queryable interfaces (`IQueryable<T>`)?
- What are shadow properties in EF Core?
- What is LINQ and its benefits?
- What is change tracking in EF Core?
- Writing LINQ queries for complex database operations
- Disposable pattern (`IDisposable` interface and `using` statement)
- Finalizers (`~ClassName()`) and their implications
- Generational garbage collection (Gen 0, Gen 1, Gen 2)
- How can you trigger garbage collection (not recommended)?
- How does the garbage collector decide when to collect?
- Large Object Heap (LOH)
- Managed heap and garbage collection
- Memory profiling tools (e.g., dotMemory)
- Performance considerations related to memory management
- Understanding memory leaks in .NET
- Understanding the Common Language Runtime (CLR) memory model
- Weak references (`WeakReference<T>`)
- What are the different garbage collection modes?
- What is object pooling?
- What is the difference between managed and unmanaged resources?
- Explain `Span<T>` and `ReadOnlySpan<T>` and their importance for performance.
- Explain collection expressions in C# 12 and their syntax.
- Explain file-scoped namespaces in C# 10 and their benefits.
- Explain indices and ranges and how they simplify working with collections.
- Explain pattern matching in C# with examples of `is` and `switch` expressions.
- Explain raw string literals in C# 11 and their use cases.
- Explain target-typed `new` expressions in C# 9.0 with an example.
- Explain target-typed conditional expressions with an example.
- Explain target-typed switch expressions.
- How can `stackalloc` be used in nested contexts?
- How do tuples with element names improve code readability?
- How does deconstruction work with tuples and objects?
- How does pattern matching work on `Span<char>` or `ReadOnlySpan<char>`?
- How does the null-conditional operator (`?.`) work and why is it useful?
- How has target typing improved in recent C# versions?
- What are UTF-8 string literals in C# 11?
- What are async streams (`IAsyncEnumerable<T>`) and how are they used?
- What are constant interpolated strings?
- What are covariant return types and how are they implemented?
- What are default interface methods and how can they be used?
- What are discards (`_`) and how are they used?
- What are expression-bodied members and what are their use cases?
- What are extended property patterns?
- What are file-local types?
- What are function pointers in C# 9.0 and what scenarios do they address?
- What are generic attributes?
- What are generic math interfaces in C# 11 and what do they enable?
- What are global using directives in C# 10 and what problem do they solve?
- What are init-only setters in C# 9.0 and when would you use them?
- What are inline arrays in C# 12 and when might you use them?
- What are list patterns in C# 11 and how can you use them for matching?
- What are local functions and what are their advantages?
- What are module initializers in C# 9.0 and what are their use cases?
- What are native sized integers (`nint`, `nuint`)?
- What are non-nullable reference types (NRTs) and how do they improve null safety?
- What are primary constructors in C# 12 and how do they simplify class definitions?
- What are record structs in C# 10 and how do they differ from record classes?
- What are record types in C# 9.0 and what are their key characteristics?
- What are recursive patterns in C# 8.0?
- What are ref readonly parameters and what are their benefits?
- What are required members in C# 11 and how do they ensure initialization?
- What are static anonymous functions?
- What are static local functions and what are their restrictions?
- What are the improvements to definite assignment in C# 11?
- What are the improvements to pointer arithmetic in C# 9.0?
- What are throw expressions and how do they simplify code?
- What are top-level statements in C# 9.0 and what is their purpose?
- What are unmanaged generic constraints?
- What are using declarations and how do they simplify resource management?
- What are using directives on methods?
- What are value tasks (`ValueTask<T>`) and when should you use them over `Task<T>`?
- What is 'skip locals init'?
- What is `scoped ref`?
- What is asynchronous disposable (`IAsyncDisposable`) and how is it implemented?
- What is auto-default struct?
- What is better support for natural types in C# 11?
- What is string interpolation and how do you use it?
- What is the `CallerArgumentExpressionAttribute` and how can it be used?
- What is the extended scope of `nameof`?
- What is the null-coalescing assignment operator (`??=`)?
- What is the null-coalescing operator (`??`) and how do you use it for default values?
- What is the null-forgiving operator (`!`) and when should it be used?
- Analyzing exceptions and stack traces (understanding the flow of execution)
- Assertions and test cases (Assert class methods)
- Code coverage analysis (tools and metrics)
- Data-driven tests (`[Theory]` with inline or member data)
- Debugging C# applications in Visual Studio or VS Code (breakpoints, stepping)
- Debugging LINQ queries
- Debugging Memory Issues in C#
- Debugging asynchronous code (task window)
- Debugging multithreaded applications (threads window)
- Fluent Assertions for more readable assertions
- Inspecting variables and the call stack (Locals, Watch, Autos windows)
- Integration testing strategies (testing interactions between components)
- Isolation of tests
- Mocking dependencies with Moq (creating mocks, setting up behaviors, verifying calls)
- Profiling code for performance issues (Visual Studio Profiler, PerfView)
- Remote debugging (debugging applications running on other machines)
- Setting breakpoints and stepping through code (step over, step into, step out)
- Test fixtures and setup/teardown methods (`[Fact]`, `[Theory]`, `[ClassFixture]`, `[CollectionFixture]`)
- Test runners and execution
- Test-Driven Development (TDD) principles
- Testing asynchronous code
- Understanding test doubles (mocks, stubs, fakes)
- Using IntelliTrace or similar tools for historical debugging
- Using conditional breakpoints and tracepoints
- Using diagnostic tools and events
- Using logging output for debugging (`Console.WriteLine`, logging frameworks)
- Writing maintainable tests
- Writing unit tests with xUnit.net, NUnit, or MSTest (attributes, test methods)