.NET Developer interview questions

C# is a programming language, .NET is the development platform and runtime ecosystem, and the CLR is the runtime that executes managed .NET code.

• The C# compiler normally produces Common Intermediate Language and assembly metadata.
• The CLR loads assemblies, verifies and compiles methods for execution, and provides runtime services.
• .NET also includes base libraries, an SDK, build tools, and application frameworks.

The JIT compiler translates a method's intermediate language into native machine code when that method is needed at runtime.

• The generated code targets the current operating system and processor architecture.
• A method can be compiled on first use and then reused during the process lifetime.
• .NET also supports ahead-of-time options, but JIT compilation remains a core CLR execution model.

A variable of a value type contains its value directly, while a variable of a reference type contains a reference to an object.

• Assigning a value type normally copies its contained value.
• Assigning a reference type copies the reference, so both variables can point to the same object.
• Structs, enums, and built-in numeric types are value types, while classes, arrays, and delegates are reference types.

A value type is stored inline wherever its containing storage lives, so its location is not always the stack.

• A local value may be stack-allocated when the runtime chooses that representation.
• A value-type field inside a class is stored as part of the class object on the managed heap.
• Boxing also places a copy of a value type inside a heap-allocated object.

A struct is a value type with copy-by-value semantics, while a class is a reference type with reference identity.

• Struct assignment copies the struct value, whereas class assignment copies a reference to the same instance.
• Structs cannot inherit from another class or struct, although they can implement interfaces.
• Small immutable data values are common struct candidates, while entities with identity and shared mutation usually fit classes.

Boxing converts a value type into an object or an interface reference by placing a copy of the value in a managed object.

• It can occur implicitly when a value type is assigned to object.
• Boxing allocates and copies, so repeated boxing can add memory and performance cost.
• Generic collections such as List<int> avoid boxing each integer, unlike older object-based collections.

Unboxing extracts a value type from a boxed object through an explicit cast to the exact boxed value type.

• The object must contain a boxed value of the requested type.
• A null reference causes NullReferenceException, while an incompatible boxed type causes InvalidCastException.
• Unboxing does not perform ordinary numeric conversion, so a boxed int cannot be directly unboxed as long.

C# provides numeric, Boolean, character, string, object, enum, tuple, array, and nullable forms among its common built-in type categories.

• Integral types differ by signedness and width, while float, double, and decimal serve different numeric needs.
• bool represents true or false, and char represents one UTF-16 code unit.
• string is a reference type whose instances are immutable.

decimal is preferred for base-10 financial calculations where values such as monetary fractions should be represented predictably.

• double uses binary floating point and is usually faster with a much wider exponent range.
• Many decimal fractions cannot be represented exactly by double, which can produce visible rounding effects.
• Both types still require an explicit rounding policy for business rules.

var asks the compiler to infer a local variable's static type from its initializer.

• The inferred type is fixed at compile time and does not make the variable dynamically typed.
• An initializer is required because the compiler needs an expression from which to infer the type.
• var is useful when the type is obvious or verbose, but an explicit type can communicate intent more clearly in other cases.

A nullable value type T? can represent either a value of T or no value.

• int? is shorthand for Nullable<int>.
• HasValue and Value expose its state, although Value throws if no value is present.
• The ?? operator supplies a fallback without manually checking HasValue.

Nullable reference types are compile-time annotations and analysis that distinguish references intended to be non-null from those allowed to be null.

• string means non-null intent in an enabled nullable context, while string? permits null.
• The compiler reports warnings when code may dereference null or violate those annotations.
• The feature does not add runtime null checks or create a different CLR reference type.

The operators ?., ??, and ! express different parts of null handling in C#.

• ?. stops member access and produces null when its receiver is null.
• ?? returns its right operand when the left operand is null.
• The postfix ! suppresses nullable warnings but performs no runtime validation and can hide a real null bug.

A constructor initializes a new class instance and establishes the state required by that instance.

• It has the class name, no return type, and can accept parameters.
• Constructors can be overloaded and can delegate to another constructor with this or to a base constructor with base.
• If no instance constructor is declared, the compiler may provide a parameterless one when the language rules allow it.

These access modifiers control where a type or member can be accessed.

• public allows access wherever the containing type is accessible, while private limits access to the containing type.
• protected permits access through the declaring class and its derived classes.
• internal permits access from code in the same assembly.

A field is storage declared directly on a type, while a property exposes accessor methods through field-like syntax.

• A property can validate, calculate, or restrict reading and writing through get, set, or init accessors.
• An auto-property lets the compiler create hidden backing storage.
• Public APIs generally prefer properties because their implementation can evolve without changing member access syntax.

A set accessor allows assignment after construction, while an init accessor limits assignment to object initialization and construction-related contexts.

• Both can be used by an object initializer.
• init helps create objects whose public state should not change after initialization.
• A readonly field is a different construct with its own assignment rules and is not a property accessor.

An instance member belongs to a particular object, while a static member belongs to the type itself.

• Instance methods can access the current object through this.
• Static methods have no instance receiver and can directly access only static members.
• Static state is shared across callers in the process, so mutation of it needs deliberate design.

virtual allows derived classes to replace a method's polymorphic implementation, and override supplies that replacement.

• Calls through a base reference dispatch to the runtime object's override.
• new hides an inherited member based on the reference's compile-time type instead of participating in the same virtual slot.
• The compiler warns about accidental hiding so the choice should be explicit.

An abstract class cannot be instantiated directly and can define members that derived classes must implement.

• Abstract members have no implementation in the base class and require an override in a concrete derived class.
• The abstract class can also contain implemented methods, fields, constructors, and state.
• A concrete class must provide all remaining abstract behavior before instances can be created.