C# MCQ

Explanation

C# was developed by Microsoft, led by Anders Hejlsberg, and released in 2000 as part of the .NET initiative.

Explanation

C# compiles to CIL (Common Intermediate Language), which is executed by the CLR, the .NET runtime.

Explanation

Console.WriteLine() writes text followed by a newline. Console.Write() writes without a newline.

Explanation

const declares a compile-time constant. readonly allows setting in constructor only and is evaluated at runtime.

Explanation

string is an alias for System.String. It is immutable in C#.

Explanation

static void Main(string[] args) or static int Main() is the entry point. In .NET 6+, top-level statements eliminate the need for Main().

Explanation

Namespaces organize code. System, System.Collections, and System.IO are examples. using System; imports all types from the namespace.

Explanation

var x = 42; infers x as int. var is compile-time inference — the type is fixed. It is not dynamic like dynamic.

Explanation

Interfaces (IDisposable, IEnumerable) define contracts. A class can implement multiple interfaces.

Explanation

Classes are reference types; assignment copies the reference. Structs are value types; assignment copies the entire value.

Explanation

public int Age { get; set; } is an auto-property. Custom getters/setters allow validation or computed values.

Explanation

override redefines a virtual/abstract method with runtime polymorphism. new creates a compile-time shadow (hiding), not true overriding.

Explanation

using System; imports a namespace. using (var f = File.Open(...)) { } disposes IDisposable resources when leaving the block.

Explanation

LINQ enables SQL-like queries: var result = from x in list where x > 5 select x; or fluent: list.Where(x => x > 5).

Explanation

List<T>, Dictionary<TKey, TValue>, and custom generic classes provide type-safe reusability without boxing.

Explanation

delegate int Operation(int a, int b); declares a delegate. Methods with matching signatures can be assigned to it and invoked.

Explanation

Events use the event keyword with a delegate type. Subscribers use += to register handlers; -= to unsubscribe.

Explanation

async methods contain await expressions. await suspends the method until the awaited Task completes, freeing the thread for other work.

Explanation

user?.Address?.City returns null if user or Address is null without throwing NullReferenceException.

Explanation

string name = user.Name ?? "Anonymous"; returns user.Name if not null, otherwise "Anonymous".

Explanation

enum Day { Mon, Tue, Wed } creates named constants. By default, values are ints starting at 0.

Explanation

try { risky code } catch (Exception ex) { handle } finally { cleanup } — finally runs whether or not an exception was thrown.

Explanation

int[] arr = new int[5]; declares an array of 5 integers. Arrays are fixed-size; use List<T> for dynamic sizing.

Explanation

List<T> dynamically resizes, supports Add(), Remove(), Contains(), Sort(), and many other methods.

Explanation

For string specifically, C# overloads == to compare values. For general objects, == compares references. Use string.Equals(a, b, StringComparison) for culture-aware comparison.

Explanation

sealed class MyClass prevents inheritance. sealed override void Method() prevents further overriding in subclasses.

Explanation

$"Hello, {user.Name}! You are {age} years old." compiles to string.Format() calls at compile time.

Explanation

static class MathHelper { public static int Square(int x) => x * x; } cannot be instantiated. Used for utility/helper classes.

Explanation

base.Method() calls the overridden parent method. base(args) in a constructor calls the parent constructor.

Explanation

Implement IDisposable to release file handles, database connections, etc. The using statement automatically calls Dispose() at block end.

Explanation

Func<int, int> square = x => x * x; is a single-expression lambda. Multi-line: x => { return x * x; }.

Explanation

Task is part of the TPL and works with async/await. Thread gives direct control but is heavier. Prefer Task for most async scenarios.

Explanation

abstract class Shape { abstract double Area(); } cannot be instantiated. Derived classes must implement Area().

Explanation

string s = obj as string; returns null if obj is not a string, unlike (string)obj which throws InvalidCastException.

Explanation

object o = 42; boxes the int 42 onto the heap. int x = (int)o; is unboxing. Excessive boxing/unboxing impacts performance.

Explanation

partial class MyForm { } allows splitting a large class across files. The compiler merges them. Used heavily in Windows Forms and ASP.NET codegen.

Explanation

public string FullName => $"{FirstName} {LastName}"; is an expression-bodied property, equivalent to a get { return ...; } property.

Explanation

Array<T> is fixed-size and typed. ArrayList stores object, requiring boxing for value types. List<T> replaced ArrayList in .NET 2.0.

Explanation

this.name = name distinguishes the instance field from the constructor parameter. This syntax also enables method chaining and constructor delegation (this(...)).

Explanation

class Point(int x, int y) { public int X => x; } captures x and y for use in the class body, reducing boilerplate constructor code.

Explanation

IEnumerable LINQ operates on in-memory data. IQueryable (used by EF) builds expression trees sent to the database, avoiding pulling all data into memory.

Explanation

async void exceptions crash the application unhandled. async Task is awaitable and its exceptions can be caught. async void is only acceptable for event handlers.

Explanation

Iterator methods using yield return produce values on-demand as the consumer iterates, enabling memory-efficient pipelines.

Explanation

Func<int, string> takes an int and returns a string. Action<int> takes an int and returns void.

Explanation

record Person(string Name, int Age); auto-generates equality, deconstruction, and with-expressions: var older = person with { Age = 30 };.

Explanation

Enabling <Nullable>enable</Nullable> makes string non-nullable. string? allows null. The compiler warns on potential NullReferenceExceptions.

Explanation

if (obj is int n) { } or switch(shape) { case Circle c when c.Radius > 5: } are patterns. C# 8-12 continuously expanded pattern types.

Explanation

static int WordCount(this string s) => s.Split().Length; allows "Hello World".WordCount(). LINQ methods are extension methods on IEnumerable.

Explanation

ref int x requires x to be assigned before the call. out int y does not (the method must assign it). int.TryParse uses out.

Explanation

public T this[int i] { get => items[i]; set => items[i] = value; } allows myObj[0] syntax on custom classes.

Explanation

IEnumerable<out T> is covariant — IEnumerable<Dog> can be assigned to IEnumerable<Animal>. IComparer<in T> is contravariant.

Explanation

Pass CancellationToken to async methods. Check token.IsCancellationRequested or call token.ThrowIfCancellationRequested() at safe points.

Explanation

lock (obj) { } compiles to Monitor.Enter(obj, ref lockTaken); try { ... } finally { Monitor.Exit(obj); }. Monitor offers TryEnter with timeout.

Explanation

[Obsolete("Use NewMethod instead")] and [Required] are attributes. Frameworks use Reflection to read them at runtime for validation, routing, etc.

Explanation

var q = list.Where(x => x > 5); doesn't execute until iterated. This allows composing queries lazily. ToList() forces immediate execution.

Explanation

Span<T> slices arrays, strings, or stack memory with zero allocation, enabling high-performance parsing and processing without copying.

Explanation

Without ConfigureAwait(false), await tries to resume on the original context (e.g., UI thread). Library code should use ConfigureAwait(false) to avoid deadlocks.

Explanation

ValueTask<T> avoids Task allocation when the operation completes synchronously (common in cache-hit paths). Task is safe to await multiple times; ValueTask is not.

Explanation

Source generators (IIncrementalGenerator) run during compilation and add generated files to the project. Used by System.Text.Json, regex source gen, and DI containers.

Explanation

public string Name { get; init; } can be set in object initializers (new Person { Name = "Alice" }) but not after the object is constructed.

Explanation

public static implicit operator string(MyType t) allows string s = myTypeValue; automatically. Explicit operators require (string)myTypeValue.

Explanation

class LoggingRepository : IRepository { IRepository _inner; ... } wraps an IRepository and adds logging. Enables Open/Closed Principle compliance.

Explanation

await foreach (var item in GetDataAsync()) processes items as they become available without buffering all results. Useful for database cursors, API pagination.

Explanation

string s = a + b + c creates two intermediate strings. var sb = new StringBuilder(); sb.Append(a); sb.Append(b); sb.Append(c); allocates one buffer.

Explanation

Lazy<HeavyObject> obj = new(() => new HeavyObject()); obj.Value triggers initialization on first access. Thread-safe by default.

Explanation

using var conn = GetConnection(); disposes conn at end of the method instead of requiring a using { } block, reducing indentation.

Explanation

ArrayPool<T>.Shared.Rent(size) and Return() reuse arrays. ObjectPool<T> (Microsoft.Extensions) generalizes this. Crucial for high-throughput scenarios.

Explanation

void Process(IProgress<int> progress) { progress.Report(50); } and new Progress<int>(pct => UpdateUI(pct)) in the caller.

Explanation

Expression<Func<User, bool>> pred = u => u.Age > 18 creates a tree. pred.Compile() gets a runnable Func. EF Core translates the tree to WHERE Age > 18 SQL.

Explanation

Channel<T>.CreateBounded(100) creates a bounded async queue. await writer.WriteAsync(item) and await reader.ReadAsync() are async producer/consumer operations.

Explanation

Action<int, string> replaces delegate void MyDel(int a, string b). Func<int, string, bool> replaces delegate bool MyFunc(int a, string b). Reduces delegate boilerplate.

Explanation

interface ILogger { void Log(string msg); void LogError(string msg) => Log($"ERROR: {msg}"); } — implementors get LogError for free but can override it.

Explanation

A file with just Console.WriteLine("Hello"); is a valid .NET 6 program — the compiler generates the Program class and Main() method implicitly.

Explanation

Roslyn exposes the compiler as an API. Source generators, analyzers, and code fixers use Roslyn's SyntaxTree, SemanticModel, and compilation APIs.

Explanation

namespace MyApp.Models; at the top of a file removes the { } block, reducing indentation for all types in the file.

Explanation

.NET 6+ project templates add global using System; and others automatically. You can define them in a GlobalUsings.cs file for the project.

Explanation

int[] a = [1, 2, 3]; List<int> b = [4, 5]; int[] c = [..a, ..b]; Collection expressions work for arrays, spans, and any type with a CollectionBuilder attribute.

Explanation

FrozenDictionary<string, int> is built once from an IEnumerable and optimized for fast reads. Ideal for configuration data loaded at startup.

Explanation

Prefer IReadOnlyCollection<T> in APIs when callers need Count without materializing. Use IEnumerable<T> only when lazy evaluation is intentional.

Explanation

void Log(string msg, params object[] args) can be called as Log("x", 1, "y", 2). Internally the args are an array.

Explanation

Gen 0 collections are fast and frequent. Objects that survive are promoted to Gen 1, then Gen 2. Gen 2 (full GC) is expensive and should be infrequent.

Explanation

The GC handles managed memory automatically. Unmanaged resources (OS handles, COM objects) need Dispose() or finalizers to be released.

Explanation

Finalizers (~MyClass) are a safety net for unmanaged resources. They delay GC and should be suppressed via GC.SuppressFinalize(this) when Dispose() is called.

Explanation

IL enables cross-language and cross-platform portability. The JIT (or AOT via NativeAOT) compiles IL to native code. Methods are JIT-compiled on first invocation.

Explanation

SemaphoreSlim.WaitAsync() is async-compatible, crucial for async code. Semaphore wraps a Win32 kernel object and supports cross-process synchronization.

Explanation

Expression<Func<User, bool>> expr = u => u.Age > 18; creates an expression tree. EF Core translates it to SQL. Call .Compile() to get a runnable Func.

Explanation

unsafe blocks allow pointer arithmetic (int* p = &x). Requires /unsafe compile flag. Used for interop, performance-critical code, and Span<T> internals.

Explanation

class Animal { virtual Animal Create() ... } class Dog : Animal { override Dog Create() ... } is valid in C# 9 — the override returns a more specific type.

Explanation

Thread.Sleep(1000) blocks the OS thread for 1 second. await Task.Delay(1000) suspends the async method, returning the thread to the pool during the wait.

Explanation

ref structs (Span<T>, ReadOnlySpan<T>) cannot be stored on the heap. This enables the runtime to guarantee their lifetime without GC tracking.

Explanation

NativeAOT compiles all managed code to native ahead-of-time. The result is a self-contained native binary with fast startup. Reflection and dynamic code generation are constrained.

Explanation

Tiered compilation (enabled by default) starts with Tier 0 (quick JIT) for fast startup, then promotes hot methods to Tier 1 (full optimized JIT) improving peak throughput.

Explanation

int[] result = new int[n] on hot paths allocates GC-tracked memory. stackalloc + Span<int> puts the array on the stack — zero GC impact for small, scoped buffers.

Explanation

abstract record Shape; record Circle(double R) : Shape; switch(shape) { case Circle(var r): ... } uses positional deconstruction pattern matching on the record hierarchy.

Explanation

Adding a finalizer puts the object on the finalization queue (extra GC cycle). GC.SuppressFinalize() after explicit Dispose() avoids this overhead.

Explanation

[JsonSerializable(typeof(User))] attribute on a JsonSerializerContext generates optimal serializers. Eliminates reflection, enabling NativeAOT compatibility.

Explanation

Thread pool reuse amortizes thread creation overhead. async/await enables millions of concurrent I/O operations with just a handful of OS threads.

Explanation

INotifyPropertyChanged.PropertyChanged triggers UI updates. Commands (ICommand) handle interactions. MVVM enables testable UI logic without direct UI references.

Explanation

C# volatile prevents read/write reordering for that specific variable but doesn't have Java's full happens-before guarantee for surrounding operations. Use Thread.MemoryBarrier() or Interlocked for stronger guarantees.

Explanation

Debug preserves debuggable stack frames and disables inlining. Release enables inlining, loop unrolling, dead code elimination via JIT. Can be 2-10x faster.