C# Interview Questions and Answers 2025

A namespace is a container for classes and other types, used to organize code.

'ref' requires the variable to be initialized before passing, while 'out' does not.

It ensures the proper disposal of resources like files or database connections.

'struct' is a value type, while 'class' is a reference type.

'abstract' methods must be implemented in derived classes, while 'virtual' methods can be overridden.

It denotes that a member belongs to the type itself rather than an instance.

'==' compares references for reference types, while '.Equals()' checks for value equality.

It prevents a class from being inherited.

'throw' preserves the original stack trace, while 'throw ex' resets it.

It checks if an object is compatible with a given type.

'readonly' can be assigned at runtime or in the constructor, while 'const' is assigned at compile time.

It ensures that a block of code runs by only one thread at a time.

'IEnumerable' is used for in-memory collections, while 'IQueryable' is used for querying data from out-of-memory sources.

It is used to create an iterator method that returns elements one at a time.

'Task' is a higher-level abstraction for asynchronous programming, while 'Thread' is a lower-level construct.

They are used to write asynchronous code more easily and avoid blocking the main thread.

'Array' is strongly typed, while 'ArrayList' can store objects of any type.

It is used to release unmanaged resources explicitly.

'override' modifies a base class method, while 'new' hides it.

It forces garbage collection to reclaim unused memory.

'protected' allows access within the class and derived classes, while 'internal' allows access within the same assembly.

They allow adding new methods to existing types without modifying them.

An abstract class can have implementations, while an interface cannot.

It allows value types to represent null values.

'Boxing' converts a value type to an object, while 'unboxing' extracts the value type from the object.

It defines a type that references methods with a specific signature.

'Func' returns a value, while 'Action' does not.

It provides a query syntax to manipulate data collections.

'Early binding' occurs at compile time, while 'late binding' occurs at runtime.

It allows splitting a class, struct, or interface into multiple files.

They allow asynchronous iteration over data streams using 'await foreach'.

'Span<T>' is a stack-only type for contiguous memory, while 'Memory<T>' can be used on the heap.

It is used to define immutable reference types with value-based equality.

Covariance allows a method to return a more derived type, while contravariance allows a method to accept a less derived type.

It bypasses compile-time type checking, enabling runtime type resolution.

'ValueTask' is used for performance optimization when the result is already available or completed.

They allow interfaces to have method implementations.

'in' passes arguments by reference but prevents modification, while 'ref readonly' ensures the reference itself is read-only.

It provides methods for low-level memory manipulation.

'Task.WhenAll' waits for all tasks to complete, while 'Task.WhenAny' waits for any one task to complete.

It defines a mechanism for releasing unmanaged resources asynchronously.

'ConcurrentDictionary' is thread-safe, while 'Dictionary' is not.

It is used to propagate notifications that operations should be canceled.

'Reflection.Emit' generates IL code dynamically, while 'Expression Trees' represent code as data structures.

It allows obtaining the method or property name of the caller.

'HttpClient' is a modern, higher-level API for HTTP requests, while 'HttpWebRequest' is older and more complex.

It provides a type-safe, memory-efficient view over contiguous memory.

'IL' (Intermediate Language) and 'CIL' (Common Intermediate Language) are synonymous terms for .NET's intermediate code.

It provides a mechanism for loading and managing assemblies dynamically.

'AppDomain' is used for isolation in .NET Framework, while 'AssemblyLoadContext' is its replacement in .NET Core.