# C# Cheat Sheet ## Introduction C# (pronounced "C-Sharp") is a modern, object-oriented, and type-safe programming language developed by Microsoft that runs on the .NET platform. It enables developers to build a wide variety of secure and robust applications that run across multiple platforms including Windows, Linux, macOS, and mobile devices. C# is particularly valuable for its comprehensive support of object-oriented programming principles (abstraction, encapsulation, inheritance, and polymorphism), its rich standard library, and its powerful features like LINQ, async/await, and strong type safety. This cheat sheet provides a comprehensive overview of C# syntax, features, best practices, and modern language capabilities from fundamental concepts to advanced techniques, organized into meaningful categories for quick reference and deep learning. --- ## Table 1: Data Types and Variables | Technique/Approach/Type | Description | Main Usages | Advantages | Considerations | Example | Reference | |------------------------|-------------|-------------|------------|----------------|---------|-----------| | **Value Types (Primitive)** | Built-in types that directly store data values in memory (stack). Includes int, long, float, double, decimal, char, bool, byte, short, etc. | Store simple data like numbers, characters, and boolean values. Used for performance-critical operations and mathematical calculations. | Fast access, minimal memory overhead, stored on stack for better performance. Value semantics (copying creates independent copies). | Cannot be null (unless nullable), fixed size limitations, boxing overhead when converted to reference types. | `int age = 25;`
`double price = 99.99;`
`bool isValid = true;`
`char grade = 'A';` | 1, 2 | | **Reference Types** | Types that store memory addresses (references) pointing to data on the heap. Includes classes, interfaces, delegates, arrays, strings. | Complex objects, collections, custom data structures. Objects that need to be shared across methods. | Can be null, support inheritance and polymorphism, flexible size, passed by reference efficiently. | Slower than value types, require garbage collection, null reference exceptions possible, heap allocation overhead. | `string name = "John";`
`object obj = new Person();`
`int[] numbers = new int[5];` | 1, 3 | | **Nullable Value Types** | Value types that can represent null in addition to their normal range. Declared using `?` suffix (e.g., `int?`). | Optional values, database fields that can be null, API responses, representing absence of value. | Explicitly handle null cases, avoid default value confusion, improved type safety for optional data. | Additional memory overhead, requires HasValue checks, can complicate logic if overused. | `int? nullableAge = null;`
`if (nullableAge.HasValue)`
` Console.WriteLine(nullableAge.Value);` | 1, 7 | | **var (Implicit Typing)** | Compiler infers the type from the assigned value. Only for local variables with immediate initialization. | Reduce verbosity, especially with complex generic types. Improve readability with LINQ queries and anonymous types. | Cleaner code, less repetition, IDE provides type information. Type-safe (not dynamic). | Can reduce readability if type isn't obvious, cannot use without initialization, not for fields or return types. | `var count = 10; // int`
`var name = "Alice"; // string`
`var person = new Person();` | 1, 2 | | **const (Constants)** | Compile-time constants whose values cannot change. Evaluated at compile time. Must be initialized at declaration. | Mathematical constants, configuration values that never change, magic numbers replacement. | Performance optimization (inlined), prevents accidental modification, expresses intent clearly. | Must be compile-time constant, value copied to calling code (versioning issues), limited to primitive types and strings. | `const int MaxRetries = 3;`
`const double Pi = 3.14159;`
`const string AppName = "MyApp";` | 1, 2 | | **readonly (Read-Only Fields)** | Runtime constants that can only be assigned in declaration or constructor. Can be instance or static. | Dependency injection, configuration loaded at runtime, values set once per object instance. | Can use runtime values, different per instance, supports reference types, set in constructor. | Cannot be modified after construction, slightly less performant than const, cannot use in constant expressions. | `readonly ILogger _logger;`
`public MyClass(ILogger logger) {`
` _logger = logger;`
`}` | 1, 5 | | **dynamic** | Runtime type resolution that bypasses compile-time type checking. Uses Dynamic Language Runtime (DLR). | COM interop, working with dynamic languages, reflection scenarios, JSON deserialization. | Flexible for dynamic scenarios, simplifies certain interop scenarios, duck typing support. | No compile-time type safety, performance overhead, no IntelliSense, runtime errors, avoid in most modern code. | `dynamic value = 5;`
`value = "Hello"; // OK`
`value.AnyMethod(); // Checked at runtime` | 1, 2 | | **Decimal** | 128-bit precise decimal type with 28-29 significant digits. Designed for financial calculations. | Financial calculations, monetary values, precise decimal arithmetic where rounding errors are unacceptable. | No binary floating-point rounding errors, exact decimal representation, suitable for money. | Slower than float/double, larger memory footprint, limited range compared to double. | `decimal price = 19.99m;`
`decimal tax = price * 0.08m;`
`decimal total = price + tax;` | 1, 2 | | **String (Immutable)** | Reference type representing immutable sequences of Unicode characters. | Text storage, user input, display messages, data serialization. | Built-in operators, rich API, interning optimization, thread-safe due to immutability. | Immutable (modifications create new strings), performance issues with concatenation in loops, memory overhead for large strings. | `string greeting = "Hello";`
`string full = greeting + " World";`
`string upper = greeting.ToUpper();` | 1, 2, 8 | | **StringBuilder** | Mutable string class for efficient string manipulation operations. | String concatenation in loops, building large strings, dynamic string construction. | Efficient memory usage, avoids creating many string objects, better performance for multiple modifications. | Not thread-safe, overhead for small operations, more complex API than string. | `var sb = new StringBuilder();`
`for (int i = 0; i < 100; i++)`
` sb.Append(i);`
`string result = sb.ToString();` | 1, 8 | | **Enum (Enumerations)** | Named integer constants that define a set of named values. Can specify underlying type. | Represent fixed set of options, state machines, configuration flags, improving code readability. | Type-safe constants, IntelliSense support, self-documenting code, can use [Flags] for bit fields. | Limited to integer types, can be cast to int (type safety breach), serialization considerations. | `enum DayOfWeek { Mon, Tue, Wed }`
`enum FileAccess { Read = 1, Write = 2 }`
`DayOfWeek today = DayOfWeek.Mon;` | 1, 2 | | **Tuple (Value Tuples)** | Lightweight data structure grouping multiple values. Syntax: `(Type1, Type2, ...)`. | Return multiple values from methods, temporary grouping, deconstructing patterns. | Lightweight, value semantics, supports named elements, easy destructuring, no need for custom types. | Less readable than custom types for complex data, limited functionality, mutable by default. | `(int, string) person = (25, "John");`
`var point = (X: 10, Y: 20);`
`var (x, y) = point;` | 1, 9 | | **Span<T> and Memory<T>** | High-performance types for working with contiguous memory regions without allocation. | Performance-critical code, array slicing, buffer manipulation, avoiding allocations. | Zero-allocation operations, works with stack and heap, high performance, safe memory access. | Cannot be stored in fields (Span), complex lifetime rules, limited use cases, learning curve. | `Span numbers = stackalloc int[10];`
`Span slice = str.AsSpan(0, 5);`
`ReadOnlySpan bytes = data;` | 10, 11 | --- ## Table 2: Operators and Expressions | Technique/Approach/Type | Description | Main Usages | Advantages | Considerations | Example | Reference | |------------------------|-------------|-------------|------------|----------------|---------|-----------| | **Arithmetic Operators** | Basic mathematical operations: `+` (addition), `-` (subtraction), `*` (multiplication), `/` (division), `%` (modulus). | Mathematical calculations, counters, algorithms, data processing. | Intuitive syntax, works with all numeric types, follows standard mathematical precedence. | Integer division truncates, potential overflow, division by zero throws exception. | `int sum = 5 + 3; // 8`
`int product = 4 * 2; // 8`
`int remainder = 10 % 3; // 1` | 2, 12 | | **Comparison Operators** | Compare values: `==` (equal), `!=` (not equal), `>`, `<`, `>=`, `<=`. Return boolean. | Conditional logic, filtering, validation, sorting algorithms. | Clear semantics, works with all comparable types, essential for control flow. | Value vs reference equality for reference types, floating-point comparison issues, null reference exceptions. | `bool isEqual = (x == y);`
`bool isGreater = (a > b);`
`bool isValid = (age >= 18);` | 2, 12 | | **Logical Operators** | Boolean logic: `&&` (AND), `\|\|` (OR), `!` (NOT), `&` (non-short-circuit AND), `\|` (non-short-circuit OR). | Combining conditions, boolean expressions, control flow logic. | Short-circuit evaluation (&&, \|\|) for performance, clear boolean logic, essential for conditionals. | Short-circuit vs non-short-circuit behavior, operator precedence can be confusing, side effects in expressions. | `if (age > 18 && hasLicense)`
`bool result = !isValid`
`if (x > 0 \|\| y > 0)` | 2, 12 | | **Assignment Operators** | Assign values: `=` (assign), `+=`, `-=`, `*=`, `/=`, `%=`, `&=`, `\|=`, `^=` (compound assignment). | Variable initialization, value updates, accumulation, state changes. | Compound operators reduce code verbosity, clear intent, commonly used in loops. | Compound assignment can be less readable, operator precedence affects evaluation, side effects. | `int x = 5;`
`x += 3; // x = x + 3 (8)`
`count *= 2; // count = count * 2` | 2, 12 | | **Bitwise Operators** | Bit-level operations: `&` (AND), `\|` (OR), `^` (XOR), `~` (NOT), `<<` (left shift), `>>` (right shift). | Low-level programming, flags/permissions, performance-critical code, cryptography. | Very fast operations, compact flag storage, precise bit manipulation. | Less readable, easy to make mistakes, limited use cases in high-level code, endianness considerations. | `int flags = 0b1010;`
`int result = flags & 0b0011; // 0b0010`
`int shifted = 1 << 3; // 8` | 2, 12 | | **Null-Coalescing (??)** | Returns left operand if not null, otherwise returns right operand. | Providing default values for nullable types, simplifying null checks. | Cleaner code than if-else, concise null handling, works with nullable value and reference types. | Only checks for null (not other falsy values), can chain but reduces readability, evaluation order matters. | `string name = input ?? "Unknown";`
`int count = nullableInt ?? 0;`
`var user = cached ?? GetFromDb();` | 1, 7 | | **Null-Conditional (?.)** | Safely access members only if object is not null. Returns null if object is null. | Safe navigation, avoiding null reference exceptions, chaining operations. | Prevents NullReferenceException, cleaner than null checks, supports chaining, works with indexers. | Can hide logic issues, returns null (may need null handling), performance overhead for chains. | `int? length = text?.Length;`
`var city = person?.Address?.City;`
`array?[0]?.ToString()` | 1, 7 | | **Null-Coalescing Assignment (??=)** | Assigns right operand to left only if left is null. Introduced in C# 8.0. | Lazy initialization, default value assignment, reducing boilerplate. | Concise null-check-and-assign, avoids repeated null checks, improves readability. | Only assigns if null, evaluation order matters, can mask initialization issues. | `list ??= new List();`
`_cache ??= LoadCache();`
`Name ??= "Default";` | 7, 13 | | **Ternary Operator (?:)** | Conditional expression: `condition ? trueValue : falseValue`. Returns one of two values. | Inline conditional assignment, concise if-else replacement, initialization. | More concise than if-else, works in expressions, improves readability for simple conditions. | Can reduce readability if nested, must return compatible types, doesn't support statements. | `int max = (a > b) ? a : b;`
`string msg = isValid ? "OK" : "Error";`
`var result = (x != 0) ? y/x : 0;` | 2, 12 | | **is Operator (Type Testing)** | Tests if object is compatible with a given type. Can include pattern matching. | Type checking, polymorphic code, casting safely, pattern matching. | Safe type checking, no exceptions, supports patterns, can declare variables inline. | Runtime overhead, can indicate poor design if overused, pattern complexity. | `if (obj is string)`
`if (obj is string str)`
`if (value is > 0 and < 100)` | 1, 14 | | **as Operator (Safe Casting)** | Attempts to cast to specified type, returns null if cast fails. Only for reference/nullable types. | Safe type conversion, avoiding InvalidCastException, polymorphic operations. | Returns null instead of throwing, cleaner than try-catch for casts, works with nullable types. | Only for reference and nullable types, requires null check, less common with pattern matching. | `string str = obj as string;`
`if (str != null) { ... }`
`var person = obj as Person;` | 1, 2 | | **typeof Operator** | Returns System.Type object for a type. Used with reflection. | Reflection, type metadata, generic constraints, serialization. | Access to type information at runtime, essential for reflection, works with generics. | Runtime overhead, cannot use with instances (use GetType()), requires using System namespace. | `Type t = typeof(string);`
`Type generic = typeof(List<>);`
`if (t == typeof(int))` | 2, 15 | | **nameof Operator** | Returns string name of variable, type, or member. Compile-time evaluation. | Logging, exception messages, property change notifications, refactoring safety. | Refactoring-safe, compile-time checked, no magic strings, improves maintainability. | Only returns simple name (not qualified), cannot use for expressions, limited use cases. | `string name = nameof(age);`
`throw new ArgumentNullException(nameof(param));`
`PropertyChanged(nameof(Name));` | 1, 2 | --- ## Table 3: Control Flow Statements | Technique/Approach/Type | Description | Main Usages | Advantages | Considerations | Example | Reference | |------------------------|-------------|-------------|------------|----------------|---------|-----------| | **if-else Statement** | Executes code block based on boolean condition. Supports else-if for multiple conditions. | Conditional logic, branching, validation, decision making. | Clear semantics, supports complex conditions, can nest, else-if for multiple conditions. | Can become nested/complex, harder to test with many branches, performance impact if deeply nested. | `if (age >= 18) { ... }`
`else if (age >= 13) { ... }`
`else { ... }` | 1, 2 | | **switch Statement** | Matches value against multiple patterns/cases. Supports fall-through with goto. | Multiple value matching, state machines, menu selection, enum handling. | Clearer than many if-else, can be optimized by compiler, supports patterns (C# 7+), default case for unmatched. | Fall-through requires goto/break, limited patterns in old C#, can be verbose, case values must be constants. | `switch (day) {`
` case DayOfWeek.Mon:`
` Console.Write("Monday");`
` break;`
` default: break;`
`}` | 1, 2 | | **switch Expression (C# 8+)** | Expression-based switch returning values. More concise than switch statement. | Value mapping, pattern matching, functional-style code, concise transformations. | Concise syntax, expression-based (returns value), exhaustive checking, supports patterns. | Newer syntax (C# 8+), less familiar, can be cryptic for complex patterns, no fall-through. | `var result = day switch {`
` DayOfWeek.Mon => "Monday",`
` DayOfWeek.Tue => "Tuesday",`
` _ => "Other"`
`};` | 14, 16 | | **for Loop** | Iterates with initialization, condition, and increment. Index-based iteration. | Known iteration count, array traversal by index, counter-based logic. | Full control over iteration, supports break/continue, can access index, optimal for arrays. | More verbose than foreach, manual index management, off-by-one errors possible. | `for (int i = 0; i < 10; i++) {`
` Console.WriteLine(i);`
`}` | 1, 2 | | **foreach Loop** | Iterates over collections implementing IEnumerable. No manual index. | Collection traversal, LINQ results, when index not needed, simplifying iteration. | Cleaner syntax, no index management, works with any IEnumerable, less error-prone. | No index access (without workarounds), cannot modify collection during iteration, slightly slower than for. | `foreach (var item in collection) {`
` Console.WriteLine(item);`
`}` | 1, 2 | | **while Loop** | Repeats while condition is true. Checks condition before execution. | Unknown iteration count, condition-based loops, user input loops. | Simple syntax, checks condition first, supports break/continue, clear intent. | Infinite loop risk, requires manual state management, condition evaluated every iteration. | `while (condition) {`
` // code`
` // update condition`
`}` | 1, 2 | | **do-while Loop** | Executes at least once, then repeats while condition is true. Checks condition after execution. | Ensure one execution, menu loops, validation loops. | Guarantees at least one execution, useful for input validation, clear semantics. | Can be overlooked (less common), infinite loop risk, condition checked after execution. | `do {`
` // code`
` // update condition`
`} while (condition);` | 1, 2 | | **break Statement** | Exits loop or switch immediately. Transfers control out of enclosing statement. | Early loop exit, switch case termination, stopping on condition. | Clear intent, prevents unnecessary iterations, essential for switch, supports labels. | Can make flow harder to follow, avoid for complex control flow, use sparingly. | `for (int i = 0; i < 100; i++) {`
` if (found) break;`
`}` | 1, 2 | | **continue Statement** | Skips remaining loop iteration, continues with next iteration. | Skip certain values, filtering, conditional processing within loops. | Clearer than nested ifs, reduces indentation, skip invalid data, improves readability. | Can make flow harder to follow, alternative to early returns, use judiciously. | `foreach (var item in items) {`
` if (item == null) continue;`
` // process item`
`}` | 1, 2 | | **return Statement** | Exits method and optionally returns value. Transfers control to caller. | Method termination, returning results, early exits, guard clauses. | Clear method exit, returns values, early return pattern, ends execution immediately. | Multiple returns can complicate logic, resource cleanup considerations, use finally for cleanup. | `public int Add(int a, int b) {`
` return a + b;`
`}` | 1, 2 | | **goto Statement** | Unconditional jump to labeled statement. Generally discouraged. | Switch fall-through, breaking nested loops, error handling (rare), state machines. | Can break nested loops in one statement, required for switch fall-through. | Makes code harder to follow (spaghetti code), considered bad practice, avoid in most cases. | `goto errorHandler;`
`// code`
`errorHandler:`
` Console.WriteLine("Error");` | 1, 2 | | **Pattern Matching (is/switch)** | Match values against patterns, including type, constant, relational, and property patterns. | Type checking with conversion, complex matching, discriminated unions, cleaner conditionals. | Concise syntax, combines type checking and casting, supports complex patterns, reduces boilerplate. | Newer syntax (C# 7+), learning curve, can be complex for advanced patterns, performance overhead. | `if (obj is Person { Age: > 18 } p)`
` Console.WriteLine(p.Name);`
`var result = value switch { ... };` | 14, 16 | --- ## Table 4: Object-Oriented Programming Concepts | Technique/Approach/Type | Description | Main Usages | Advantages | Considerations | Example | Reference | |------------------------|-------------|-------------|------------|----------------|---------|-----------| | **Classes** | Reference types defining blueprint for objects with fields, properties, methods, and events. | Object modeling, encapsulating data and behavior, creating reusable components. | Support inheritance, polymorphism, encapsulation, flexible design, can implement interfaces. | Heap allocation overhead, reference semantics, null references possible, slower than structs. | `public class Person {`
` public string Name { get; set; }`
` public void Greet() { ... }`
`}` | 1, 17 | | **Structs** | Value types for lightweight objects. Stored on stack, value semantics. | Small data structures, performance-critical code, immutable types, POD (Plain Old Data). | Stack allocation (faster), value semantics, no null references, better cache locality. | Copied by value (performance if large), no inheritance, cannot have parameterless constructor (C# 9-), boxing overhead. | `public struct Point {`
` public int X { get; set; }`
` public int Y { get; set; }`
`}` | 1, 2 | | **Interfaces** | Contracts defining members without implementation. Classes/structs implement interfaces. | Abstraction, dependency injection, polymorphism, defining contracts, multiple inheritance of behavior. | Multiple interface inheritance, contract enforcement, loose coupling, testability through mocking. | No implementation (until C# 8 default interface methods), cannot contain fields, versioning challenges. | `public interface ILogger {`
` void Log(string message);`
`}`
`public class FileLogger : ILogger { ... }` | 1, 17 | | **Inheritance** | Derive classes from base classes, inheriting members. Single inheritance for classes. | Code reuse, hierarchical relationships, polymorphism, extending existing types. | Code reuse, is-a relationships, polymorphism, override base behavior. | Single inheritance only, tight coupling, fragile base class problem, prefer composition over inheritance. | `public class Animal { ... }`
`public class Dog : Animal {`
` public void Bark() { ... }`
`}` | 1, 17 | | **Encapsulation** | Hiding implementation details, exposing only necessary members. Using access modifiers. | Data hiding, maintaining invariants, reducing coupling, API design. | Protects internal state, improves maintainability, reduces dependencies, allows implementation changes. | Can be verbose, requires discipline, over-encapsulation reduces usability, balance needed. | `public class BankAccount {`
` private decimal _balance;`
` public void Deposit(decimal amt) {...}`
`}` | 1, 17 | | **Polymorphism** | Objects of derived classes treated as objects of base class. Method overriding with virtual/override. | Flexible designs, extensibility, strategy pattern, plugin architectures. | Runtime flexibility, open/closed principle, extensibility without modifying base, loose coupling. | Virtual call overhead, harder to debug, complexity, can hide actual type. | `Animal pet = new Dog();`
`pet.MakeSound(); // Dog's implementation`
`public virtual void MakeSound() { }` | 1, 17 | | **Abstraction** | Abstract classes/methods defining template with partial implementation. Cannot instantiate. | Base classes with shared logic, template method pattern, forcing derived implementations. | Partial implementation sharing, enforce implementation in derived classes, clear contracts. | Cannot instantiate, single inheritance limit, more rigid than interfaces. | `public abstract class Shape {`
` public abstract double Area();`
` public void Display() { ... }`
`}` | 1, 17 | | **Properties** | Class members providing get/set accessors for fields. Encapsulate fields with logic. | Encapsulated field access, validation, computed values, change notifications. | Syntax like fields but method control, validation in setters, computed properties, supports interfaces. | Slight overhead vs fields, can hide complexity, getter/setter abuse, prefer readonly when possible. | `public string Name {`
` get { return _name; }`
` set { _name = value; }`
`}`
`public int Age { get; set; }` | 1, 2 | | **Auto-Implemented Properties** | Properties without explicit backing fields. Compiler generates field. | Simple properties without logic, reducing boilerplate, quick prototypes. | Less code, cleaner syntax, generated backing field, supports init/readonly. | No custom logic, cannot access backing field directly, less control. | `public string Name { get; set; }`
`public int Age { get; private set; }`
`public string Id { get; init; }` | 1, 2 | | **Constructors** | Special methods called when creating instances. Initialize object state. | Object initialization, dependency injection, parameter validation, setting defaults. | Ensure valid state, required parameters, multiple overloads, chaining constructors. | Can become complex, multiple constructors maintenance, initialization order matters. | `public Person(string name) {`
` Name = name;`
`}`
`public Person() : this("Unknown") { }` | 1, 17 | | **Static Members** | Members belonging to type rather than instances. Shared across all instances. | Utility methods, shared state, factory methods, constants, extension methods. | No instance needed, single copy, access via type name, useful for helpers. | Cannot access instance members, testing challenges, concurrency issues, tight coupling. | `public static class Math {`
` public static int Add(int a, int b)`
` { return a + b; }`
`}` | 1, 2 | | **Indexers** | Special properties allowing object indexing like arrays. Syntax: `this[type index]`. | Collection-like access, custom indexing, dictionary-like objects. | Array-like syntax, multiple overloads, supports multiple parameters, clear intent. | Overhead vs direct access, can be confusing, error-prone if misused. | `public class MyList {`
` public T this[int index] {`
` get {...} set {...}`
` }`
`}` | 1, 2 | | **Access Modifiers** | Keywords controlling visibility: public, private, protected, internal, protected internal, private protected. | Encapsulation, API design, security, controlling member visibility. | Control access levels, encapsulation support, assembly boundaries, reduce coupling. | Can be too restrictive or permissive, understand assembly boundaries, default is private for class members. | `public class MyClass {`
` private int _field;`
` protected void Method() {...}`
` internal string Prop {get;set;}`
`}` | 1, 2, 17 | --- ## Table 5: Advanced Features | Technique/Approach/Type | Description | Main Usages | Advantages | Considerations | Example | Reference | |------------------------|-------------|-------------|------------|----------------|---------|-----------| | **Generics** | Type parameters allowing types/methods to work with any data type. Compile-time type safety. | Collections, reusable algorithms, type-safe code, avoiding boxing, frameworks/libraries. | Type safety, no boxing, code reuse, performance, IntelliSense support. | Complexity, cannot use with primitive operations without constraints, verbose syntax. | `public class List { ... }`
`public T GetValue() { ... }`
`var list = new List();` | 1, 18 | | **Delegates** | Type-safe function pointers. Reference to methods with specific signature. | Callbacks, event handlers, function parameters, asynchronous programming. | Type-safe callbacks, multicast (multiple methods), flexibility, base for events. | Syntax complexity, null reference issues, memory leaks if not unsubscribed, harder to debug. | `public delegate void MyDelegate(string msg);`
`MyDelegate handler = Console.WriteLine;`
`handler("Hello");` | 1, 19 | | **Events** | Special delegates for publisher-subscriber pattern. Built on delegates. | GUI programming, observer pattern, decoupling components, notifications. | Encapsulated delegates, add/remove only, prevents reassignment, clear semantics. | Memory leaks if not unsubscribed, event ordering issues, null check required, debugging challenges. | `public event EventHandler MyEvent;`
`MyEvent?.Invoke(this, EventArgs.Empty);`
`obj.MyEvent += Handler;` | 1, 19 | | **Lambda Expressions** | Anonymous functions using `=>` syntax. Concise method definitions. | LINQ queries, event handlers, delegates, callbacks, functional programming. | Concise syntax, captures variables (closures), IntelliSense support, readability. | Captured variable lifetime issues, harder to debug, can be less readable if complex, performance overhead. | `Func square = x => x * x;`
`list.Where(x => x > 5)`
`(a, b) => a + b` | 1, 19, 20 | | **LINQ (Language Integrated Query)** | Query syntax and methods for querying collections. Both query and method syntax. | Data querying, filtering, transformations, aggregations, database queries. | Declarative syntax, type-safe, IntelliSense support, unified query model, deferred execution. | Performance considerations, deferred execution can be confusing, learning curve, debugging challenges. | `var adults = people.Where(p => p.Age >= 18);`
`var names = from p in people select p.Name;`
`var avg = numbers.Average();` | 1, 21 | | **Extension Methods** | Static methods extending existing types without modifying them. First parameter with `this`. | Extending sealed classes, fluent APIs, adding utility methods, LINQ implementation. | Extend types without inheritance, works with sealed classes, clean syntax, organized in namespaces. | Can clutter IntelliSense, discoverability issues, cannot override, only when you cannot modify type. | `public static class StringExt {`
` public static bool IsEmpty(this string s)`
` { return string.IsNullOrEmpty(s); }`
`}` | 1, 22 | | **Async/Await** | Asynchronous programming pattern for non-blocking operations. Task-based. | I/O operations, web requests, database calls, UI responsiveness, parallel operations. | Non-blocking, improved responsiveness, scalable, natural control flow, error handling with try-catch. | Viral (spreads through call stack), deadlock risks, complexity, overhead for CPU-bound work, state machine generation. | `public async Task GetDataAsync() {`
` return await httpClient.GetStringAsync(url);`
`}` | 1, 23 | | **Nullable Reference Types (C# 8+)** | Opt-in feature marking reference types as nullable or non-nullable. Static analysis. | Reducing null reference exceptions, explicit null handling, improving code quality. | Compiler warnings for potential nulls, explicit intent, better null safety, gradual adoption. | Not enforced at runtime, migration challenges, annotation burden, can be verbose. | `#nullable enable`
`string? nullable = null; // OK`
`string nonNull = ""; // Cannot be null`
`string? value = GetValue();` | 7, 24 | | **Records (C# 9+)** | Reference types with value semantics for equality. Concise immutable data types. | DTOs, data models, immutable data, value objects, configuration. | Value-based equality, concise syntax, with-expressions for copying, immutable by default. | Reference type (heap allocation), newer syntax (C# 9+), learning curve, limited scenarios. | `public record Person(string Name, int Age);`
`var p1 = new Person("John", 30);`
`var p2 = p1 with { Age = 31 };` | 1, 25 | | **Pattern Matching** | Match values against patterns including type, property, relational, logical patterns. | Type switches, data extraction, validation, discriminated unions. | Expressive syntax, combines checks and extraction, reduces boilerplate, supports complex patterns. | Newer syntax (C# 7+), learning curve, can be cryptic, performance considerations. | `if (obj is Person { Age: > 18 } p)`
`var type = shape switch {`
` Circle c => "Circle",`
` Rectangle r => "Rect"`
`};` | 14, 16 | | **Attributes** | Metadata added to code elements. Used by compiler, runtime, or custom tools. | Serialization control, validation, code generation, reflection, configuration. | Declarative metadata, separation of concerns, framework extensibility, tooling support. | Reflection overhead, can be overused, magic behavior, learning curve for custom attributes. | `[Serializable]`
`[Obsolete("Use NewMethod")]`
`[Required]`
`public string Name { get; set; }` | 1, 15 | | **Reflection** | Inspect and manipulate types, methods, properties at runtime. | Dynamic invocation, serialization, dependency injection, plugin systems, testing. | Runtime type inspection, dynamic code, metadata access, powerful for frameworks. | Performance overhead, breaks type safety, complexity, security considerations, avoid if possible. | `Type t = typeof(Person);`
`var props = t.GetProperties();`
`object instance = Activator.CreateInstance(t);` | 1, 15 | | **Dynamic Keyword** | Bypass compile-time type checking. Resolved at runtime. | COM interop, dynamic languages, reflection scenarios, flexible APIs. | Flexibility, simplifies certain interop, duck typing, less boilerplate. | No compile-time safety, no IntelliSense, performance overhead, runtime errors, avoid in most code. | `dynamic value = GetValue();`
`value.AnyMethod(); // No compile check`
`int result = value + 5;` | 1, 2 | --- ## Table 6: Collections and Data Structures | Technique/Approach/Type | Description | Main Usages | Advantages | Considerations | Example | Reference | |------------------------|-------------|-------------|------------|----------------|---------|-----------| | **Arrays** | Fixed-size, zero-indexed collections of same-type elements. Value/reference types. | Fixed-size collections, performance-critical code, known element count, matrix operations. | Fast access O(1), type-safe, contiguous memory, better cache locality, minimal overhead. | Fixed size, cannot grow, resizing expensive, no Add/Remove methods. | `int[] numbers = new int[5];`
`string[] names = {"A", "B", "C"};`
`numbers[0] = 10;` | 1, 2, 26 | | **List<T>** | Generic dynamic array. Resizable collection with type safety. | Dynamic collections, unknown size, frequent additions, most common collection. | Dynamic size, type-safe, rich API, LINQ support, fast access, widely used. | Resizing overhead, slower than arrays for small fixed-size, not thread-safe. | `var list = new List();`
`list.Add(5);`
`list.Remove(5);`
`int count = list.Count;` | 1, 26 | | **Dictionary<TKey, TValue>** | Hash table storing key-value pairs. Fast lookup by key. | Key-value storage, caching, lookups, indexing, mapping. | Fast lookups O(1), type-safe, no duplicate keys, widely used. | Hash collisions, key must be immutable, unordered, memory overhead. | `var dict = new Dictionary();`
`dict["key"] = 10;`
`int value = dict["key"];`
`bool exists = dict.ContainsKey("key");` | 1, 26 | | **HashSet<T>** | Unordered collection of unique values. Set operations support. | Unique collections, set operations, fast membership testing, removing duplicates. | Fast lookups, uniqueness enforced, set operations (Union, Intersect), no duplicates. | Unordered, no indexing, no duplicate values allowed, memory overhead. | `var set = new HashSet();`
`set.Add(5);`
`bool contains = set.Contains(5);`
`set.UnionWith(otherSet);` | 26, 27 | | **Queue<T>** | First-In-First-Out (FIFO) collection. Enqueue at end, dequeue from front. | Task queues, breadth-first search, buffering, processing in order. | FIFO semantics, clear intent, efficient enqueue/dequeue, thread-safe version available. | No random access, fixed order, not for searching, limited use cases. | `var queue = new Queue();`
`queue.Enqueue(1);`
`int first = queue.Dequeue();`
`int peek = queue.Peek();` | 26, 27 | | **Stack<T>** | Last-In-First-Out (LIFO) collection. Push to add, Pop to remove from top. | Undo operations, depth-first search, parsing, function call stack emulation. | LIFO semantics, clear intent, efficient push/pop, useful for backtracking. | No random access, fixed order, not for searching, limited use cases. | `var stack = new Stack();`
`stack.Push(1);`
`int top = stack.Pop();`
`int peek = stack.Peek();` | 26, 27 | | **LinkedList<T>** | Doubly-linked list. Efficient insertions/deletions at any position. | Frequent insertions/removals, no indexing needed, LRU caches, when order matters. | Fast insertion/removal O(1), no resizing, bidirectional traversal. | No random access O(n), more memory per element, slower iteration than List, less commonly used. | `var list = new LinkedList();`
`list.AddFirst(1);`
`list.AddLast(2);`
`list.Remove(1);` | 26, 27 | | **SortedList<TKey, TValue>** | Sorted list of key-value pairs. Maintains sorted order by key. | Small sorted collections, range queries, ordered key-value pairs. | Sorted order, binary search, less memory than SortedDictionary, range queries. | Slower insertions O(n), more memory than Dictionary, rebalancing overhead. | `var sorted = new SortedList();`
`sorted.Add(3, "three");`
`sorted.Add(1, "one");` | 26, 27 | | **SortedDictionary<TKey, TValue>** | Binary search tree of key-value pairs. Maintains sorted order. | Ordered key-value storage, large sorted collections, range queries. | Sorted order, fast operations O(log n), better for large collections than SortedList. | Slower than Dictionary, more memory, complex implementation, tree overhead. | `var sorted = new SortedDictionary();`
`sorted[2] = "two";`
`sorted[1] = "one";` | 26, 27 | | **SortedSet<T>** | Binary search tree of unique values. Maintains sorted order. | Sorted unique values, range operations, ordered sets. | Sorted order, fast operations O(log n), set operations, uniqueness. | Slower than HashSet, more memory, overhead for sorting. | `var set = new SortedSet();`
`set.Add(3); set.Add(1);`
`var subset = set.GetViewBetween(1, 3);` | 26, 27 | | **ConcurrentDictionary<TKey, TValue>** | Thread-safe dictionary. Lock-free for reads, fine-grained locking for writes. | Multi-threaded scenarios, caching, shared state, parallel operations. | Thread-safe, lock-free reads, good scalability, no external locking needed. | Overhead vs Dictionary, atomic operations complexity, memory overhead, only when needed. | `var dict = new ConcurrentDictionary();`
`dict.TryAdd("key", 1);`
`dict.AddOrUpdate("key", 1, (k,v) => v+1);` | 26, 28 | | **BlockingCollection<T>** | Thread-safe collection with blocking operations. Producer-consumer pattern. | Producer-consumer scenarios, pipeline patterns, work queues, throttling. | Thread-safe, blocking Add/Take, bounded capacity support, cancellation support. | Blocking operations (can deadlock), overhead, complexity, limited use cases. | `var bc = new BlockingCollection(10);`
`bc.Add(item);`
`int item = bc.Take();` | 26, 28 | --- ## Table 7: Exception Handling | Technique/Approach/Type | Description | Main Usages | Advantages | Considerations | Example | Reference | |------------------------|-------------|-------------|------------|----------------|---------|-----------| | **try-catch** | Handle exceptions with try block and one or more catch blocks. | Error handling, exception catching, preventing crashes, logging errors. | Prevents crashes, graceful error handling, can have multiple catch blocks, exception details available. | Performance overhead, can hide bugs, avoid using for control flow, catch specific exceptions first. | `try {`
` int result = 10 / 0;`
`} catch (DivideByZeroException ex) {`
` Console.WriteLine(ex.Message);`
`}` | 1, 29 | | **try-finally** | Execute cleanup code regardless of exceptions. Finally block always executes. | Resource cleanup, connection closing, file closing, ensuring cleanup. | Guaranteed execution, proper resource cleanup, works with using, runs even with return/throw. | No exception handling, cannot prevent exception propagation, still need try-catch for handling. | `try {`
` // risky code`
`} finally {`
` // cleanup`
` connection?.Close();`
`}` | 1, 29 | | **try-catch-finally** | Combine exception handling with cleanup. Catch handles, finally cleans up. | Complete error handling with cleanup, database operations, file I/O. | Complete exception handling, guaranteed cleanup, comprehensive error management. | Verbose, complex control flow, exception in finally can mask original, careful ordering needed. | `try {`
` // code`
`} catch (Exception ex) {`
` // handle`
`} finally {`
` // cleanup`
`}` | 1, 29 | | **throw** | Throw new exception or rethrow caught exception. | Error signaling, validation failures, exceptional conditions, propagating errors. | Clear error signaling, preserves stack trace (rethrow), custom exceptions, control flow. | Performance overhead, breaks control flow, overuse anti-pattern, use for exceptional cases only. | `if (value < 0)`
` throw new ArgumentException("Negative");`
`catch (Exception) { throw; }` | 1, 29 | | **Custom Exceptions** | Create application-specific exception classes inheriting from Exception. | Domain-specific errors, providing additional context, categorizing errors. | Specific error types, additional properties, clear semantics, better error handling. | Proliferation of exception types, maintenance overhead, documentation needed, consider built-in first. | `public class ValidationException : Exception {`
` public ValidationException(string msg)`
` : base(msg) { }`
`}` | 1, 29 | | **Exception Filters (when)** | Conditional catch blocks using `when` keyword. Only catch if condition true. | Conditional exception handling, logging with rethrow, fine-grained control. | More granular control, can inspect exception, cleaner than nested try-catch, preserves stack trace. | Complex conditions can reduce readability, newer syntax (C# 6+), avoid complex logic in filter. | `try { ... }`
`catch (HttpException ex) when (ex.StatusCode == 404) {`
` // handle 404 only`
`}` | 29, 30 | | **using Statement** | Automatic disposal of IDisposable objects. Ensures Dispose called. | Resource management, file/connection cleanup, automatic disposal, avoiding leaks. | Automatic cleanup, exception-safe, concise syntax, prevents resource leaks. | Only for IDisposable types, nesting can be verbose, limited to block scope. | `using (var file = File.OpenRead(path)) {`
` // use file`
`} // Dispose called automatically` | 1, 2 | | **using Declaration (C# 8+)** | Shorter using syntax. Disposal at end of enclosing scope. | Resource management with less nesting, cleaner code, automatic disposal. | Less nesting, cleaner code, automatic disposal, scope-based lifetime. | Newer syntax (C# 8+), disposal timing different from using statement, less explicit. | `using var file = File.OpenRead(path);`
`// use file`
`// Dispose called at end of scope` | 1, 2 | | **Catch-All (catch Exception)** | Catch any exception. Should be last catch block. | Top-level handlers, logging all errors, preventing crashes, final fallback. | Catches everything, prevents unhandled exceptions, useful for logging. | Too broad, hides specific errors, can mask bugs, should be last resort, log and rethrow often. | `try { ... }`
`catch (SpecificException) { ... }`
`catch (Exception ex) {`
` Log(ex);`
` throw;`
`}` | 29, 30 | | **Rethrow (throw;)** | Rethrow caught exception without losing stack trace. | Logging then propagating, cleanup before rethrow, preserving error context. | Preserves stack trace, allows logging and rethrow, maintains exception details. | Still propagates exception, requires careful design, ensure proper logging. | `catch (Exception ex) {`
` Log(ex);`
` throw; // Preserves stack`
`}`
`// NOT: throw ex; (loses stack)` | 29, 30 | | **AggregateException** | Contains multiple exceptions. Used with parallel/async operations. | Parallel.ForEach, Task.WaitAll, multiple errors, async operations. | Groups multiple exceptions, parallel operation errors, flatten method available. | Complex to handle, need to iterate InnerExceptions, flatten for nested, specific to parallel/async. | `try {`
` Task.WaitAll(tasks);`
`} catch (AggregateException ae) {`
` ae.Flatten().Handle(ex => ...);`
`}` | 23, 29 | --- ## Table 8: Modern C# Features (C# 7.0 - 13.0) | Technique/Approach/Type | Description | Main Usages | Advantages | Considerations | Example | Reference | |------------------------|-------------|-------------|------------|----------------|---------|-----------| | **Local Functions (C# 7.0)** | Functions defined within methods. Scoped to containing method. | Helper functions, iterators, async methods, encapsulation within method. | Encapsulation, can access local variables, clearer than private methods, supports generic and async. | Not reusable outside method, can complicate method, testing challenges, avoid deep nesting. | `public void Method() {`
` int Helper(int x) => x * 2;`
` var result = Helper(5);`
`}` | 1, 31 | | **Tuples with Names (C# 7.0)** | Value tuples with named elements. Lightweight data structures. | Multiple return values, temporary grouping, deconstructing, avoiding DTOs. | Named elements improve readability, value semantics, deconstruction support, lightweight. | Less discoverable than custom types, mutable by default, limited for complex data. | `(int count, string name) = GetData();`
`var point = (X: 10, Y: 20);`
`Console.WriteLine(point.X);` | 1, 9 | | **Deconstructors (C# 7.0)** | Deconstruct objects into constituent parts. Tuple-like syntax. | Pattern matching, extracting values, tuple syntax for custom types. | Clean syntax, works with patterns, natural for value extraction. | Need to implement Deconstruct method, less discoverable, limited use cases. | `(var name, var age) = person;`
`// Requires:`
`public void Deconstruct(out string n, out int a)` | 9, 16 | | **Out Variables (C# 7.0)** | Declare out variables inline in method call. | TryParse patterns, method calls with out parameters, cleaner code. | Less code, inline declaration, clearer intent, reduced boilerplate. | Limited scope, can be overlooked, only for out parameters. | `if (int.TryParse(input, out var number))`
` Console.WriteLine(number);` | 1, 31 | | **Throw Expressions (C# 7.0)** | Throw exceptions in expression context. Null-coalescing, ternary, etc. | Validation, null-coalescing, expression-bodied members, concise error handling. | Concise validation, works in expressions, clearer intent, less boilerplate. | Can reduce readability, limited to expressions, error messages should be clear. | `_name = name ?? throw new ArgumentNullException(nameof(name));`
`var value = condition ? val : throw new Exception();` | 1, 31 | | **Binary Literals and Digit Separators (C# 7.0)** | Binary numbers with `0b` prefix. Underscores for readability in numbers. | Bit masks, binary constants, improving number readability. | Clear binary representation, improved readability for large numbers. | Only for literals, limited use cases, not widely used. | `int binary = 0b1010_1100;`
`long big = 1_000_000_000;`
`int hex = 0xFF_FF_FF;` | 1, 31 | | **Ref Returns and Locals (C# 7.0)** | Return references to variables. Store references in locals. | Performance optimization, large struct manipulation, avoiding copies. | Avoid copying, high performance, useful for large structs. | Complex semantics, easy to misuse, safety considerations, limited use cases. | `ref int GetRef(int[] arr, int i) => ref arr[i];`
`ref int r = ref GetRef(array, 0);`
`r = 10; // Modifies array` | 31, 32 | | **Pattern Matching Enhancements (C# 8.0-9.0)** | Property patterns, positional patterns, relational patterns, logical patterns. | Complex matching, data validation, exhaustive checking, switch expressions. | Expressive matching, reduces boilerplate, type safety, supports complex patterns. | Learning curve, can be cryptic, newer syntax, performance considerations. | `obj is Person { Age: > 18 }`
`value is > 0 and < 100`
`x is not null` | 14, 16 | | **Null-Coalescing Assignment (C# 8.0)** | Assign value only if null using `??=`. | Lazy initialization, default values, reducing boilerplate. | Concise null-check-and-assign, clearer intent, reduces duplicate code. | Only assigns if null, can mask initialization issues. | `list ??= new List();`
`_cache ??= LoadCache();` | 7, 13 | | **Indices and Ranges (C# 8.0)** | Index from end using `^`, ranges using `..`. Easy slicing. | Array/string slicing, getting last elements, substring operations. | Intuitive syntax, concise slicing, works with arrays/strings/spans, clear intent. | Can be confusing at first, range excludes end index, not all types support. | `int last = array[^1]; // Last element`
`var slice = array[1..^1]; // Skip first and last`
`var str = text[0..5];` | 1, 13 | | **Using Declarations (C# 8.0)** | Dispose at end of scope without braces. Cleaner than using statement. | Resource management, reducing nesting, cleaner code. | Less nesting, cleaner code, automatic disposal. | Different disposal timing, less explicit, newer syntax. | `using var file = File.OpenRead(path);`
`// use file`
`// Disposed at end of scope` | 1, 2, 13 | | **Nullable Reference Types (C# 8.0)** | Opt-in feature making reference types non-nullable by default. | Null safety, preventing NullReferenceException, explicit null handling. | Compiler warnings, explicit intent, better null safety, gradual adoption. | Not runtime enforced, migration effort, annotation burden, can be verbose. | `#nullable enable`
`string? nullable = null;`
`string nonNull = ""; // Cannot be null` | 7, 24 | | **Default Interface Members (C# 8.0)** | Interfaces can provide default implementations for members. | Interface evolution, backward compatibility, traits-like functionality. | Extend interfaces without breaking implementations, shared code, versioning. | Complex semantics, diamond problem, not like abstract classes, limited use. | `interface ILogger {`
` void Log(string msg) =>`
` Console.WriteLine(msg);`
`}` | 1, 13 | | **Switch Expressions (C# 8.0)** | Expression-based switch returning values. More concise. | Value mapping, pattern matching, functional style, reducing boilerplate. | Concise syntax, expression-based, exhaustive checking, supports patterns. | Newer syntax, no fall-through, learning curve, can be cryptic. | `var result = value switch {`
` 1 => "one",`
` 2 => "two",`
` _ => "other"`
`};` | 14, 16 | | **Records (C# 9.0)** | Reference types with value-based equality. Immutable by default. | DTOs, data models, value objects, immutable data, configuration. | Value equality, concise syntax, with-expressions, immutable, ToString support. | Heap allocation, newer syntax, limited scenarios, mutable if not careful. | `public record Person(string Name, int Age);`
`var p2 = p1 with { Age = 31 };` | 1, 25 | | **Init-Only Properties (C# 9.0)** | Properties that can only be set during initialization. | Immutable objects, object initializers, avoiding mutable public setters. | Immutability, initialization flexibility, clearer than readonly, supports initializers. | Cannot change after initialization, requires newer C#, limited to initialization. | `public string Name { get; init; }`
`var p = new Person { Name = "John" };`
`// p.Name = "Jane"; // Error` | 1, 25, 33 | | **Top-Level Statements (C# 9.0)** | Remove boilerplate class/Main in simple programs. Implicit Main. | Scripts, simple programs, learning, reducing ceremony. | Less boilerplate, cleaner simple programs, faster prototyping. | Only one file per program, not for complex apps, hiding program structure. | `// No class or Main needed`
`Console.WriteLine("Hello");`
`using System;` | 1, 33 | | **Global using (C# 10.0)** | Using directives applied to all files in project. | Common namespaces, reducing repetition, project-wide imports. | Less repetition, cleaner files, project-wide configuration, implicit usings. | Less visible, can be confusing, conflicts, prefer explicit for clarity. | `// In GlobalUsings.cs or any file:`
`global using System;`
`global using System.Linq;` | 33, 34 | | **File-Scoped Namespaces (C# 10.0)** | Namespace declaration without braces. Reduces indentation. | Reducing indentation, cleaner files, single namespace per file. | One less indentation level, cleaner code, modern style. | One namespace per file, newer syntax, formatting considerations. | `namespace MyApp.Services;`

`public class MyService { ... }` | 33, 34 | | **Required Members (C# 11.0)** | Mark properties/fields as required. Must be set during construction. | Ensuring required data, validation, preventing invalid objects. | Compile-time checks, clear intent, prevents invalid objects. | Newer syntax (C# 11+), requires setting in initializers, constructor complexity. | `public class Person {`
` public required string Name { get; init; }`
`}`
`var p = new Person { Name = "John" };` | 34, 35 | | **Raw String Literals (C# 11.0)** | Multi-line strings with `"""`. No escape sequences. | JSON, XML, regex, SQL, multi-line strings, avoiding escaping. | No escaping needed, multi-line support, clear for complex strings, indentation handling. | Newer syntax (C# 11+), verbose for simple strings, requires 3+ quotes. | `string json = """`
`{`
` "name": "John",`
` "age": 30`
`}`
`""";` | 34, 35 | | **List Patterns (C# 11.0)** | Pattern matching for lists/arrays with specific structures. | Data validation, parsing, pattern matching collections. | Expressive list matching, concise syntax, supports complex patterns. | Newer syntax, learning curve, limited performance optimization. | `if (array is [1, 2, 3])`
`if (list is [var first, .., var last])`
`if (data is [> 0, > 0, > 0])` | 34, 35 | | **Primary Constructors (C# 12.0)** | Constructor parameters in class/struct declaration. Concise syntax. | Reducing boilerplate, dependency injection, simple classes. | Very concise, clear dependencies, less code, modern syntax. | Newest syntax (C# 12+), parameter scope throughout type, can be confusing, limited refactoring. | `public class Person(string name, int age) {`
` public void Print() =>`
` Console.WriteLine(name);`
`}` | 35, 36 | | **Collection Expressions (C# 12.0)** | New syntax for creating collections: `[1, 2, 3]`. | Concise collection initialization, array/list creation, spread operator. | Very concise, works with various types, spread support, modern syntax. | Newest syntax (C# 12+), type inference needed, limited backwards compatibility. | `int[] arr = [1, 2, 3];`
`List list = [1, 2, 3];`
`int[] combined = [..arr1, ..arr2];` | 35, 36 | --- ## Table 9: Asynchronous Programming | Technique/Approach/Type | Description | Main Usages | Advantages | Considerations | Example | Reference | |------------------------|-------------|-------------|------------|----------------|---------|-----------| | **async/await** | Asynchronous programming pattern with async methods returning Task/Task<T>. | I/O operations, web requests, file access, database calls, UI responsiveness. | Non-blocking, natural control flow, exception handling with try-catch, scalability. | Viral pattern, deadlock risks (ConfigureAwait), complexity, overhead, state machine generation. | `public async Task GetAsync() {`
` return await httpClient.GetStringAsync(url);`
`}` | 1, 23 | | **Task** | Represents asynchronous operation. Returned by async methods. | Async operations, parallel work, composition, cancellation. | Composable, built-in error handling, cancellation support, waiting/continuation. | Not started until awaited (cold), exception handling timing, disposal considerations. | `Task task = GetValueAsync();`
`int result = await task;`
`await Task.Delay(1000);` | 23, 37 | | **Task<T>** | Task returning a value of type T. Generic version of Task. | Async methods returning values, data fetching, computations. | Type-safe return values, same benefits as Task, composable. | Same considerations as Task, result access requires await. | `Task GetNumberAsync() {`
` return Task.FromResult(42);`
`}`
`int num = await GetNumberAsync();` | 23, 37 | | **ValueTask<T>** | Struct-based task for high-performance scenarios. Reduces allocations. | High-performance scenarios, frequently completed synchronously, pooling. | Zero allocation if completes synchronously, better performance, cache-friendly. | Complex lifetime rules, only await once, cannot use after await, limited scenarios. | `public ValueTask GetCached() {`
` return cache != null`
` ? new ValueTask(cache)`
` : new ValueTask(LoadAsync());`
`}` | 23, 37, 38 | | **Task.Run** | Execute delegate on thread pool thread. CPU-bound work. | CPU-bound work on UI thread, offloading work, parallelization. | Simple parallelization, offload from UI thread, composable with async. | Thread pool overhead, not for I/O operations, context switch cost, avoid for short operations. | `int result = await Task.Run(() => {`
` return ComputeExpensiveValue();`
`});` | 23, 37 | | **Task.WhenAll** | Wait for all tasks to complete. Returns when all finish. | Parallel I/O, multiple async operations, batch processing. | Efficient parallelism, single await point, exception aggregation. | One exception stops all (aggregate), difficult to handle individual failures, no short-circuiting. | `var tasks = urls.Select(DownloadAsync);`
`await Task.WhenAll(tasks);`
`// All downloads complete` | 23, 37 | | **Task.WhenAny** | Wait for first task to complete. Returns when any finishes. | Timeout patterns, redundancy, racing operations, cancellation. | Flexible patterns, timeout support, first-wins semantics. | Other tasks continue running, cleanup needed, exception handling complex. | `var first = await Task.WhenAny(task1, task2);`
`var timeoutTask = Task.Delay(5000);`
`var result = await Task.WhenAny(op, timeout);` | 23, 37 | | **ConfigureAwait(false)** | Don't capture context when awaiting. Library code pattern. | Library code, avoiding deadlocks, performance, no UI context needed. | Avoids deadlocks, better performance, reduces context switches, essential for libraries. | Cannot access UI after, must understand contexts, default is true, complex behavior. | `await httpClient.GetStringAsync(url)`
` .ConfigureAwait(false);`
`// No UI context captured` | 23, 37 | | **CancellationToken** | Cooperative cancellation mechanism. Pass to async methods. | Canceling operations, timeouts, user cancellation, resource cleanup. | Cooperative cancellation, composable, polling and callbacks, proper resource cleanup. | Cooperative (method must check), requires passing through methods, cancellation not immediate. | `async Task DoWork(CancellationToken ct) {`
` ct.ThrowIfCancellationRequested();`
` await Task.Delay(1000, ct);`
`}` | 23, 39 | | **CancellationTokenSource** | Create and control cancellation tokens. Can cancel and set timeouts. | Creating cancellation tokens, timeout enforcement, explicit cancellation. | Simple cancellation, timeout support, can cancel multiple operations, linked tokens. | Need to dispose, cancellation callbacks can throw, manage lifetime carefully. | `var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));`
`await DoWork(cts.Token);`
`cts.Cancel();` | 23, 39 | | **IAsyncEnumerable<T> (C# 8+)** | Async version of IEnumerable. Yield return with await. | Streaming data, paging results, async iteration, large datasets. | Streaming, backpressure, async iteration, efficient memory, natural syntax. | Newer feature (C# 8+), requires understanding async streams, disposal considerations. | `async IAsyncEnumerable GetNumbers() {`
` for (int i = 0; i < 10; i++) {`
` await Task.Delay(100);`
` yield return i;`
` }`
`}` | 23, 40 | | **Parallel.ForEach** | Parallel iteration over collections. Not async/await based. | CPU-bound parallel work, data parallelism, batch processing. | Simple parallelism, automatic work distribution, degree of parallelism control. | CPU-bound only (not async), exception aggregation, thread safety required, blocking. | `Parallel.ForEach(items, item => {`
` ProcessItem(item);`
`});` | 37, 41 | --- ## Table 10: LINQ (Language Integrated Query) | Technique/Approach/Type | Description | Main Usages | Advantages | Considerations | Example | Reference | |------------------------|-------------|-------------|------------|----------------|---------|-----------| | **Where (Filtering)** | Filter collection based on predicate. Deferred execution. | Filtering data, conditional selection, removing unwanted elements. | Clear intent, composable, lazy evaluation, works with any IEnumerable. | Deferred execution, multiple enumerations, performance considerations for complex predicates. | `var adults = people.Where(p => p.Age >= 18);`
`var even = numbers.Where(n => n % 2 == 0);` | 1, 21 | | **Select (Projection)** | Transform each element. Maps collection to new form. | Data transformation, extracting properties, shaping data, DTOs. | Powerful transformation, lazy evaluation, clear mapping, composable. | Creates new objects (memory), deferred execution, can be inefficient if misused. | `var names = people.Select(p => p.Name);`
`var dtos = data.Select(d => new Dto { ... });` | 1, 21 | | **OrderBy / OrderByDescending** | Sort collection by key. Stable sort. | Sorting data, ordering results, ranking, presentation. | Stable sort, composable (ThenBy), works with any comparable, clear syntax. | Performance impact on large collections, creates new sequence, multiple passes for complex sorting. | `var sorted = people.OrderBy(p => p.Age);`
`var desc = people.OrderByDescending(p => p.Name);` | 1, 21 | | **ThenBy / ThenByDescending** | Secondary sorting after OrderBy. Chained sorting. | Multi-level sorting, complex ordering, tie-breaking. | Multiple sort keys, clear syntax, stable sort, composable. | Requires OrderBy first, performance considerations, careful key selection. | `var sorted = people`
` .OrderBy(p => p.LastName)`
` .ThenBy(p => p.FirstName);` | 1, 21 | | **GroupBy** | Group elements by key. Returns groups with key and elements. | Grouping data, aggregation, categorization, reporting. | Flexible grouping, supports complex keys, composable, powerful for reporting. | Creates group objects, deferred execution, memory intensive for large data, complex queries. | `var grouped = people.GroupBy(p => p.City);`
`foreach (var group in grouped) {`
` Console.WriteLine($"{group.Key}: {group.Count()}");`
`}` | 1, 21 | | **Join** | Inner join two collections based on keys. | Combining related data, SQL-like joins, merging collections. | SQL-like syntax, type-safe, composable, works with any collections. | Inner join only (no left/right), complex syntax, performance considerations, prefer navigation properties. | `var result = people.Join(orders,`
` p => p.Id,`
` o => o.PersonId,`
` (p, o) => new { p.Name, o.Total });` | 1, 21 | | **GroupJoin** | Left outer join. Groups right collection elements. | Left joins, one-to-many relationships, hierarchical data. | Preserves left side, groups matches, SQL-like semantics. | Complex syntax, less intuitive than SelectMany, performance considerations. | `var result = people.GroupJoin(orders,`
` p => p.Id, o => o.PersonId,`
` (p, orders) => new { p.Name, Orders = orders });` | 1, 21 | | **First / FirstOrDefault** | Get first element. First throws if empty, FirstOrDefault returns default. | Getting single result, finding first match, accessing collections. | Simple syntax, clear intent, overload with predicate, common pattern. | Throws if empty (First), enumerates collection, potential multiple enumeration. | `var first = numbers.First();`
`var adult = people.FirstOrDefault(p => p.Age >= 18);` | 1, 21 | | **Single / SingleOrDefault** | Get single element. Throws if zero or multiple. Ensures uniqueness. | Unique results, validation, expecting exactly one, enforcing constraints. | Validates uniqueness, clear intent, overload with predicate. | Enumerates entire collection, throws on multiple, performance impact. | `var user = users.Single(u => u.Id == id);`
`var match = items.SingleOrDefault(predicate);` | 1, 21 | | **Any** | Check if collection contains any elements or matches predicate. | Existence check, validation, conditional logic, short-circuit evaluation. | Short-circuits (stops at first match), efficient, clear intent, better than Count() > 0. | Deferred execution, can enumerate collection, predicate evaluation. | `bool hasAdults = people.Any(p => p.Age >= 18);`
`bool isEmpty = !items.Any();` | 1, 21 | | **All** | Check if all elements match predicate. | Validation, ensuring conditions, all-or-nothing checks. | Short-circuits on first fail, clear intent, efficient. | Enumerates entire collection if all match, predicate evaluation. | `bool allAdults = people.All(p => p.Age >= 18);`
`bool allPositive = numbers.All(n => n > 0);` | 1, 21 | | **Count / LongCount** | Count elements or elements matching predicate. | Counting elements, statistics, validation, conditional counts. | Simple counting, overload with predicate, clear intent. | Enumerates entire collection, use Count property if available, performance considerations. | `int count = people.Count();`
`int adults = people.Count(p => p.Age >= 18);` | 1, 21 | | **Sum / Average / Min / Max** | Aggregate functions for numeric collections. | Statistics, calculations, reporting, aggregations. | Built-in aggregations, overloads with selectors, common operations. | Enumerates entire collection, type-specific overloads, empty collection considerations. | `int total = numbers.Sum();`
`double avg = people.Average(p => p.Age);`
`int max = scores.Max();` | 1, 21 | | **Aggregate** | Custom aggregation with accumulator function. | Custom aggregations, folding, complex reductions, functional programming. | Flexible aggregation, seed value support, powerful for complex operations. | Complex syntax, less readable than specific methods, performance considerations. | `int product = numbers.Aggregate(1, (acc, n) => acc * n);`
`string csv = names.Aggregate((a, b) => a + "," + b);` | 1, 21 | | **SelectMany** | Flatten nested collections. Projects and flattens. | Flattening hierarchies, many-to-many relationships, nested collections. | Powerful flattening, composable, works with nested structures, clear intent. | Complex syntax, multiple enumeration possible, performance considerations. | `var allOrders = customers.SelectMany(c => c.Orders);`
`var allItems = orders.SelectMany(o => o.Items);` | 1, 21 | | **Distinct** | Remove duplicates from collection. | Removing duplicates, unique values, cleaning data. | Simple deduplication, works with custom comparers, clear intent. | Performance impact, requires equality comparison, memory for tracking seen items. | `var unique = numbers.Distinct();`
`var uniqueNames = people.Select(p => p.Name).Distinct();` | 1, 21 | | **Take / Skip** | Take first N or skip first N elements. Pagination support. | Pagination, limiting results, sampling, skipping headers. | Simple pagination, composable, efficient, clear intent. | Doesn't validate bounds, use with caution, zero-based indexing. | `var firstTen = items.Take(10);`
`var page = items.Skip(20).Take(10);` | 1, 21 | | **ToList / ToArray / ToDictionary** | Materialize query into collection. Execute immediately. | Forcing execution, caching results, avoiding multiple enumeration, final result. | Forces execution, multiple enumeration safe, snapshot of data. | Memory allocation, eager evaluation, performance impact, use when needed. | `List list = numbers.ToList();`
`int[] array = items.ToArray();`
`var dict = people.ToDictionary(p => p.Id);` | 1, 21 | | **AsEnumerable / AsQueryable** | Change query provider. AsQueryable enables IQueryable features. | Switching providers, client vs server evaluation, EF Core queries. | Control evaluation location, enable query translation, optimization opportunities. | Subtle behavior changes, understand providers, performance implications. | `var query = dbSet.AsQueryable().Where(...);`
`var local = query.AsEnumerable().Where(...);` | 21, 42 | --- ## Table 11: Delegates, Events, and Functional Programming | Technique/Approach/Type | Description | Main Usages | Advantages | Considerations | Example | Reference | |------------------------|-------------|-------------|------------|----------------|---------|-----------| | **Action<T>** | Delegate for methods with no return value. Generic delegate. | Callbacks, event handlers, passing methods, LINQ ForEach. | No custom delegate needed, type-safe, up to 16 parameters, commonly used. | No return value, parameter count limit, generic constraints. | `Action log = Console.WriteLine;`
`Action add = (a, b) => Console.WriteLine(a+b);`
`list.ForEach(item => Process(item));` | 1, 19 | | **Func<T, TResult>** | Delegate for methods with return value. Last type parameter is return type. | Transformations, predicates, LINQ, functional programming, callbacks. | No custom delegate needed, type-safe, up to 16 input parameters, very common. | Parameter count limit, generic constraints, less expressive name than custom delegate. | `Func square = x => x * x;`
`Func length = s => s.Length;`
`Func add = (a, b) => a + b;` | 1, 19 | | **Predicate<T>** | Delegate representing method returning bool. Used for testing conditions. | Filtering, testing conditions, Find/Exists on List, conditional logic. | Clear semantic for conditions, type-safe, specific purpose. | Single parameter only, Func more flexible, less commonly used than Func. | `Predicate isEven = x => x % 2 == 0;`
`var found = list.Find(isEven);`
`bool exists = list.Exists(x => x > 10);` | 1, 19 | | **Custom Delegates** | User-defined delegate types with specific signature. | Domain-specific callbacks, expressive naming, complex signatures. | Meaningful names, expresses intent, supports ref/out parameters. | Extra type definition, Func/Action often sufficient, maintenance overhead. | `public delegate void ProcessData(Data data);`
`ProcessData processor = ProcessItem;`
`processor(myData);` | 1, 19 | | **Multicast Delegates** | Delegates referencing multiple methods. Invoked sequentially. | Event handlers, observer pattern, notification systems. | Multiple subscribers, += and -= operators, null propagation needed. | Last return value only, exception handling tricky, order not guaranteed, memory leaks if not unsubscribed. | `Action notify = Method1;`
`notify += Method2;`
`notify += Method3;`
`notify?.Invoke(); // Calls all` | 1, 19 | | **Anonymous Methods** | Unnamed inline methods using delegate keyword. Older syntax (pre-lambda). | Legacy code, when lambda not available, capturing variables. | Inline code, variable capture, type inference. | Verbose vs lambdas, mostly replaced by lambdas, less readable. | `Action log = delegate(string msg) {`
` Console.WriteLine(msg);`
`};`
`log("Hello");` | 1, 19 | | **Closures (Variable Capture)** | Lambdas/delegates capturing variables from enclosing scope. | Stateful callbacks, sharing state, event handlers with context. | Convenient state sharing, no explicit parameter passing, powerful pattern. | Variable lifetime extended, modified closure problem in loops, memory implications, debugging harder. | `int count = 0;`
`Action increment = () => count++;`
`increment();`
`Console.WriteLine(count); // 1` | 19, 20 | | **Expression<TDelegate>** | Expression tree representing code as data. Used in LINQ to SQL/EF. | ORM query translation, dynamic queries, code analysis, runtime code generation. | Code as data, query translation to SQL, analyzable, powerful for frameworks. | Cannot use all C# features, complexity, performance overhead, mostly for ORMs. | `Expression> expr =`
` p => p.Age > 18;`
`// Used by EF to generate SQL` | 21, 42 | | **Func Chaining (Composition)** | Compose functions together. Functional programming pattern. | Data pipelines, transformations, functional style, reusable operations. | Reusable compositions, declarative, functional programming, clear data flow. | Can be hard to debug, performance overhead, stack depth considerations, less common in C#. | `Func add5 = x => x + 5;`
`Func mult2 = x => x * 2;`
`Func combined = x => mult2(add5(x));` | 19, 20 | | **Lazy<T>** | Lazy initialization wrapper. Creates value on first access. | Expensive initialization, deferred object creation, thread-safe initialization. | Deferred creation, thread-safe by default, single initialization, memory savings. | One-time initialization only, exception caching, thread safety modes, slight overhead. | `Lazy lazy = new(() => new ExpensiveObject());`
`var obj = lazy.Value; // Created here` | 43, 44 | --- ## Table 12: Memory Management and Performance | Technique/Approach/Type | Description | Main Usages | Advantages | Considerations | Example | Reference | |------------------------|-------------|-------------|------------|----------------|---------|-----------| | **Stack vs Heap** | Stack stores value types and references; Heap stores reference type objects. | Understanding memory allocation, performance optimization, avoiding unnecessary allocations. | Stack is fast (LIFO), heap allows dynamic sizing, automatic management by GC. | Stack overflow possible, heap requires GC, understand allocation patterns, value vs reference semantics. | `int x = 5; // Stack`
`var obj = new MyClass(); // Heap (obj reference on stack)`
`struct Point { } // Stack if local variable` | 45, 46 | | **Value Types** | Stored directly in memory. Includes primitives, structs, enums. | Small data structures, performance-critical code, avoiding heap allocation. | Stack allocation (usually), value semantics, no null, better cache locality, no GC pressure. | Copied by value, boxing overhead, limited to small sizes, no inheritance. | `int x = 10;`
`Point p = new Point(1, 2);`
`DateTime dt = DateTime.Now;` | 1, 45 | | **Reference Types** | Store reference to object on heap. Includes classes, arrays, delegates. | Complex objects, polymorphism, shared state, large objects. | Heap allocation, reference semantics, inheritance support, flexible sizing, null support. | GC overhead, null references, heap allocation slower, indirection cost. | `Person p = new Person();`
`int[] arr = new int[100];`
`string s = "hello";` | 1, 45 | | **Garbage Collection (GC)** | Automatic memory management. Collects unreferenced objects. | Memory cleanup, avoiding memory leaks, automatic resource management. | Automatic, no manual memory management, reduces leaks, generational approach. | Non-deterministic timing, performance pauses, finalization overhead, not for unmanaged resources. | `// GC automatically manages`
`GC.Collect(); // Force (avoid)`
`GC.GetTotalMemory(false);` | 45, 47 | | **IDisposable Pattern** | Interface for releasing unmanaged resources. Implement Dispose method. | File handles, connections, unmanaged memory, resources requiring cleanup. | Deterministic cleanup, using statement support, clear ownership, explicit resource management. | Requires discipline, easy to forget, double-dispose handling, finalizer considerations. | `public class MyResource : IDisposable {`
` public void Dispose() {`
` // Cleanup`
` }`
`}`
`using (var r = new MyResource()) { }` | 1, 48 | | **Finalizers (Destructors)** | Special method called by GC before collecting object. Syntax: `~ClassName()`. | Unmanaged resource cleanup, backup disposal, critical cleanup. | Last resort cleanup, handles missed Dispose, unmanaged resources. | Non-deterministic, performance impact, delays GC, avoid if possible, use only for unmanaged resources. | `~MyClass() {`
` // Cleanup unmanaged`
` // Not called deterministically`
`}` | 45, 48 | | **Object Pooling** | Reuse objects instead of creating/destroying. Reduces GC pressure. | High-frequency allocations, expensive object creation, performance optimization. | Reduced allocations, less GC pressure, improved performance, resource reuse. | Complexity, state reset required, memory footprint, thread safety, only for expensive objects. | `var pool = new ObjectPool();`
`var obj = pool.Get();`
`// use`
`pool.Return(obj);` | 47, 49 | | **ArrayPool<T>** | Built-in array pooling. Rent and return arrays. | Reducing array allocations, temporary buffers, performance-critical paths. | Reduced allocations, built-in, thread-safe, good for temporary arrays. | Must return arrays, size may be larger than requested, state not cleared, limited to arrays. | `var array = ArrayPool.Shared.Rent(1024);`
`try { /* use */ }`
`finally { ArrayPool.Shared.Return(array); }` | 47, 49 | | **Span<T>** | Stack-allocated or sliced array view. Zero-allocation slicing. | Performance-critical code, string/array slicing, buffer manipulation, avoiding allocations. | Zero allocations, works with stack/heap, safe slicing, high performance. | Cannot be stored in fields, ref struct limitations, learning curve, limited scope. | `Span span = stackalloc int[100];`
`Span slice = str.AsSpan(0, 5);`
`ReadOnlySpan bytes = data;` | 10, 11, 50 | | **Memory<T>** | Similar to Span but can be stored in fields. Slicing support. | Async code with buffers, field storage, slicing, replacing byte[]. | Like Span but storable, async-compatible, slicing, zero-allocation. | Slightly more overhead than Span, less common, newer API. | `Memory buffer = new byte[1024];`
`Memory slice = buffer.Slice(0, 512);`
`await WriteAsync(slice);` | 10, 11, 50 | | **ref struct** | Struct that can only exist on stack. Span is ref struct. | Performance-critical code, ensuring stack-only allocation, interop. | Guaranteed stack allocation, prevents boxing, high performance, clear semantics. | Cannot be stored in fields (except ref fields), cannot implement interfaces, cannot be async local. | `ref struct StackOnlyStruct {`
` public Span Data;`
`}`
`// Cannot be boxed or stored on heap` | 10, 50 | | **stackalloc** | Allocate memory on stack instead of heap. Used with Span. | Small buffers, avoiding allocations, performance-critical paths. | No heap allocation, very fast, no GC pressure, deterministic cleanup. | Stack overflow risk, limited stack size, only for small allocations, careful size management. | `Span buffer = stackalloc int[256];`
`Span bytes = stackalloc byte[128];` | 10, 50 | | **String Interning** | Store single copy of identical strings. String.Intern. | Reducing memory for duplicate strings, comparison optimization. | Reduced memory for duplicates, fast equality checks, automatic for literals. | Strings never collected, memory overhead, use judiciously, impacts GC. | `string s1 = "hello";`
`string s2 = "hello"; // Same reference`
`string s3 = String.Intern(dynamic);` | 8, 47 | | **Large Object Heap (LOH)** | Separate heap for objects > 85KB. Not compacted by default. | Large arrays, buffers, images, avoiding fragmentation. | Avoids copying large objects, separate collection, predictable addresses. | Fragmentation issues, not compacted (until .NET 4.5.1), careful sizing, GC implications. | `byte[] large = new byte[100000]; // LOH`
`// Consider pooling or streaming` | 45, 47 | --- ## Table 13: Naming Conventions and Code Style | Technique/Approach/Type | Description | Main Usages | Advantages | Considerations | Example | Reference | |------------------------|-------------|-------------|------------|----------------|---------|-----------| | **PascalCase** | First letter of each word capitalized, no separators. | Public types, methods, properties, namespaces, public/protected members. | Standard C# convention, readable, professional, consistent. | Must be consistent, applies to visible members, distinguish from private. | `public class PersonManager`
`public void ProcessData()`
`public string FirstName { get; set; }` | 51, 52 | | **camelCase** | First word lowercase, subsequent words capitalized. | Private fields, local variables, method parameters, local functions. | Clear distinction from public members, readable, standard for internals. | Underscore prefix for private fields common, consistency needed. | `private int itemCount;`
`public void Method(string userName)`
`int localVariable = 5;` | 51, 52 | | **_camelCase (Underscore Prefix)** | camelCase with leading underscore. | Private instance fields. | Clear distinction from parameters/locals, field visibility obvious, common pattern. | Not in official guidelines but widely adopted, underscore can be controversial. | `private string _userName;`
`private int _count;`
`private readonly ILogger _logger;` | 51, 52 | | **s_camelCase (Static Fields)** | Static field with s_ prefix. | Private static fields. | Distinguishes static from instance, clear intent, visibility. | Less universal, configure in editorconfig, not official standard. | `private static int s_instanceCount;`
`private static readonly HttpClient s_client;` | 51, 52 | | **UPPER_CASE** | All uppercase with underscores. | Constants (const), public static readonly. | Clear constant indication, distinguishable, traditional. | Less common in C# than other languages, PascalCase also used for const. | `public const int MAX_SIZE = 100;`
`public const string API_KEY = "key";` | 51, 52 | | **IPascalCase (Interface Prefix)** | Interface names start with 'I' followed by PascalCase. | All interface declarations. | Immediately recognizable as interface, C# standard, clear intent. | Required convention, don't skip, distinguishes from classes. | `public interface ILogger { }`
`public interface IRepository { }`
`public interface IDisposable { }` | 1, 51 | | **TPascalCase (Type Parameters)** | Generic type parameters prefix with 'T', then PascalCase. | Generic type parameters. | Recognizable as type parameter, C# convention, clear for generics. | Single 'T' acceptable for simple cases, descriptive for complex. | `public class List { }`
`public interface IMapper { }`
`public void Process(TItem item)` | 1, 51 | | **Async Method Suffix** | Async methods end with 'Async' suffix. | All async methods returning Task/Task. | Clear async indication, discoverable, standard pattern, prevents confusion. | Don't use for event handlers, add to all async methods, helps with overloads. | `public async Task GetDataAsync()`
`public async Task SaveAsync()`
`public async Task CalculateAsync()` | 23, 51 | | **Avoid Abbreviations** | Use full words instead of abbreviations. | All identifiers: types, members, variables, parameters. | Clearer intent, more readable, self-documenting, avoid confusion. | Common abbreviations OK (Id, Html, Xml), balance readability, consistency. | `// Good: UserManager`
`// Bad: UsrMgr`
`// Good: CustomerId`
`// OK: HtmlParser` | 51, 52 | | **Meaningful Names** | Use descriptive, intent-revealing names. | All identifiers. | Self-documenting, clearer code, easier maintenance, reduces comments. | Avoid overly long names, balance clarity and length, context matters. | `// Good: ProcessOrderPayment()`
`// Bad: Process()`
`// Good: isValid`
`// Bad: flag` | 51, 52 | | **Boolean Naming** | Prefix booleans with is, has, can, should. | Boolean variables, properties, methods returning bool. | Clear true/false semantics, readable conditions, expresses intent. | Not always applicable, use natural language, avoid double negatives. | `bool isActive;`
`bool hasChildren;`
`bool CanExecute();`
`bool ShouldRetry;` | 51, 52 | | **Event Naming** | Events use verb or verb phrase, often past tense. | Event declarations. | Clear indication of action, standard pattern, recognizable. | Past tense for after action, present for before, use EventHandler. | `public event EventHandler Clicked;`
`public event EventHandler DataLoaded;`
`public event EventHandler ItemAdded;` | 1, 51 | | **Avoid Underscores (Public)** | No underscores in public member names (except type params). | Public APIs. | Professional appearance, C# standard, consistency with framework. | OK for private fields, OK for type parameters (_), distinguish public/private. | `// Good: FirstName`
`// Bad: First_Name`
`// OK: _privateField (private)` | 51, 52 | --- ## Table 14: Best Practices and Design Patterns | Technique/Approach/Type | Description | Main Usages | Advantages | Considerations | Example | Reference | |------------------------|-------------|-------------|------------|----------------|---------|-----------| | **SOLID Principles** | Five design principles: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion. | Object-oriented design, maintainable code, loosely coupled systems. | Better design, maintainability, testability, flexibility, industry standard. | Can be over-applied, learning curve, balance with pragmatism. | `// Single Responsibility:`
`class OrderProcessor { }`
`class OrderValidator { }`
`// Not one OrderManager doing all` | 53, 54 | | **Dependency Injection (DI)** | Provide dependencies from outside rather than creating internally. | Decoupling, testability, configuration, ASP.NET Core. | Loose coupling, testable, flexible, framework support, inversion of control. | Complexity, can be overused, runtime errors if misconfigured, learning curve. | `public class UserService {`
` public UserService(ILogger logger, IRepo repo) {...}`
`}`
`// Dependencies injected by DI container` | 1, 55 | | **Repository Pattern** | Abstracts data access. Provides collection-like interface. | Data access abstraction, testability, separating concerns, swapping implementations. | Testable, abstracts data source, clear separation, maintainable. | Can be over-abstraction, boilerplate, EF Core makes less necessary, added complexity. | `public interface IUserRepository {`
` Task GetByIdAsync(int id);`
` Task SaveAsync(User user);`
`}` | 54, 56 | | **Unit of Work** | Coordinates multiple repositories. Ensures transactional consistency. | Transaction management, coordinating changes, database operations. | Transaction boundaries, consistency, coordinated save, clear pattern. | Complexity, can be over-engineering, EF DbContext is unit of work, coupling. | `public interface IUnitOfWork {`
` IUserRepository Users { get; }`
` Task SaveChangesAsync();`
`}` | 54, 56 | | **Factory Pattern** | Create objects without specifying exact class. | Object creation abstraction, complex initialization, polymorphism. | Encapsulates creation, flexible, supports DI, hides complexity. | Extra classes, can be overused, simple cases don't need it. | `public interface ILoggerFactory {`
` ILogger CreateLogger(string name);`
`}`
`var logger = factory.CreateLogger("name");` | 54, 57 | | **Singleton Pattern** | Ensure only one instance exists. | Shared resources, configuration, caching, logging. | Single instance, global access, lazy initialization, thread-safe (with care). | Global state issues, testing challenges, thread safety complexity, prefer DI. | `public class Singleton {`
` private static readonly Lazy _instance;`
` public static Singleton Instance => _instance.Value;`
`}` | 54, 57 | | **Strategy Pattern** | Define family of algorithms, make them interchangeable. | Varying algorithms, configuration, polymorphic behavior. | Flexible algorithms, open/closed principle, testable, clear separation. | More classes, complexity, may be overkill for simple cases. | `public interface IPaymentStrategy {`
` void ProcessPayment(decimal amount);`
`}`
`public class CreditCard : IPaymentStrategy { }` | 54, 57 | | **Guard Clauses** | Early validation and exit. Check preconditions at method start. | Parameter validation, reducing nesting, fail-fast principle. | Clearer intent, reduced nesting, fail-fast, easier to read. | Multiple exit points, can be verbose, balance with readability. | `public void Process(string data) {`
` if (string.IsNullOrEmpty(data))`
` throw new ArgumentNullException(nameof(data));`
` // main logic`
`}` | 53, 58 | | **Null Object Pattern** | Provide default object instead of null. Implements same interface. | Avoiding null checks, default behavior, reducing NullReferenceException. | No null checks, clearer code, default behavior, prevents exceptions. | Extra class, can hide issues, not always appropriate, explicitness needed. | `public class NullLogger : ILogger {`
` public void Log(string msg) { } // Do nothing`
`}`
`ILogger logger = GetLogger() ?? new NullLogger();` | 54, 57 | | **Builder Pattern** | Construct complex objects step by step. Fluent API. | Complex object construction, fluent APIs, optional parameters, immutable objects. | Readable construction, handles complexity, fluent API, optional params. | Boilerplate code, extra classes, may be overkill for simple objects. | `var person = new PersonBuilder()`
` .WithName("John")`
` .WithAge(30)`
` .Build();` | 54, 57 | | **Options Pattern** | Configuration through strongly-typed classes. ASP.NET Core pattern. | Configuration, settings, dependency injection, strongly-typed config. | Type-safe, DI support, validation, binding, reloadable, testable. | Specific to .NET, complexity for simple config, requires setup. | `public class MyOptions {`
` public string Setting { get; set; }`
`}`
`services.Configure(Configuration.GetSection("MyOptions"));` | 55, 59 | | **Async All The Way** | Use async/await throughout call stack. Avoid sync over async. | Asynchronous programming, scalability, avoiding deadlocks. | Scalability, no thread blocking, prevents deadlocks, best practice. | Viral (spreads), complexity, overhead for CPU-bound, requires discipline. | `// Good: async all the way`
`async Task A() => await B();`
`async Task B() => await C();`
`// Bad: task.Result, task.Wait()` | 23, 58 | | **Avoid Premature Optimization** | Optimize only when needed after measuring. | Performance tuning, development priorities, avoiding complexity. | Cleaner code, faster development, measure first, focus on correctness. | Real performance issues exist, measure with profiler, balance needed. | `// Write clear code first`
`// Measure performance`
`// Optimize bottlenecks only` | 53, 58 | --- ## References ### Official Microsoft Documentation 1. **C# Documentation - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/csharp/ Official comprehensive C# language documentation covering all language features, fundamentals, and advanced topics. 2. **C# Language Reference - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/ Detailed reference for C# keywords, operators, and language constructs. 3. **Object-Oriented Programming (C#) - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/tutorials/oop Tutorial on OOP concepts including inheritance, polymorphism, encapsulation, and abstraction. ### C# Language Features and Syntax 5. **Dependency Injection - .NET - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/core/extensions/dependency-injection Built-in dependency injection in .NET with design patterns and best practices. 7. **Nullable Reference Types - C# - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/csharp/nullable-references Overview of nullable reference types feature introduced in C# 8.0 for null safety. 8. **String Manipulation - C#** https://learn.microsoft.com/en-us/dotnet/csharp/how-to/index#strings String operations, manipulation methods, and best practices. 9. **Tuple types - C# Reference - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/value-tuples Value tuples, deconstruction, and tuple syntax in C#. 10. **Span<T> and Memory<T> - Performance - .NET** https://learn.microsoft.com/en-us/dotnet/standard/memory-and-spans/ High-performance memory types for zero-allocation operations. 11. **Memory<T> and Span<T> usage guidelines** https://learn.microsoft.com/en-us/dotnet/standard/memory-and-spans/memory-t-usage-guidelines Best practices for using Memory and Span. 12. **Operators and Expressions - C# Reference** https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/ Comprehensive guide to C# operators including arithmetic, logical, bitwise, and more. 13. **What's new in C# 8.0 - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-8 Features introduced in C# 8.0 including nullable reference types, patterns, indices and ranges. 14. **Pattern matching overview - C# - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/functional/pattern-matching Comprehensive guide to pattern matching including type, property, relational, and logical patterns. 15. **Attributes - C# Programming Guide - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/csharp/advanced-topics/reflection-and-attributes/ Using attributes for metadata and reflection in C#. 16. **Switch expression - C# Reference - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/switch-expression Expression-based switch syntax introduced in C# 8.0. 17. **C# Classes and Objects - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/types/classes Fundamental concepts of classes, objects, and object-oriented programming. 18. **Generic classes and methods - C# Programming Guide** https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/types/generics Using generics for type-safe, reusable code. 19. **Delegates - C# Programming Guide - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/delegates/ Type-safe function pointers and event handling with delegates. 20. **Lambda expressions - C# Reference - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/lambda-expressions Anonymous functions using lambda syntax. 21. **Language Integrated Query (LINQ) - C# - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/csharp/linq/ Comprehensive LINQ documentation including query syntax and method syntax. 22. **Extension Methods - C# Programming Guide** https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/extension-methods Extending existing types without modifying them. ### Asynchronous and Parallel Programming 23. **Async/Await - Asynchronous programming - C# - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/csharp/asynchronous-programming/ Comprehensive guide to asynchronous programming with async/await. 37. **Task-based asynchronous pattern - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/standard/asynchronous-programming-patterns/task-based-asynchronous-pattern-tap Task-based asynchronous pattern (TAP) overview and best practices. 38. **Understanding the Whys, Whats, and Whens of ValueTask - .NET Blog** https://devblogs.microsoft.com/dotnet/understanding-the-whys-whats-and-whens-of-valuetask/ Deep dive into ValueTask and when to use it. 39. **Cancellation in Managed Threads - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/standard/threading/cancellation-in-managed-threads Cooperative cancellation using CancellationToken. 40. **IAsyncEnumerable - Async Streams - C# 8.0** https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-8#asynchronous-streams Async streams for asynchronous iteration. 41. **Parallel Programming in .NET - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/standard/parallel-programming/ Task Parallel Library (TPL) and parallel programming patterns. ### Collections and Data Structures 26. **Collections - C# Programming Guide - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/collections Overview of generic and non-generic collections in .NET. 27. **System.Collections.Generic Namespace - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/api/system.collections.generic Reference for generic collection types. 28. **Thread-Safe Collections - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/standard/collections/thread-safe/ Concurrent collections for multi-threaded scenarios. ### Exception Handling 29. **Best practices for exceptions - .NET - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/standard/exceptions/best-practices-for-exceptions Best practices for exception handling in .NET. 30. **Exception-handling statements - C# Reference - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/statements/exception-handling-statements Try, catch, finally, and throw statements. ### Modern C# Features 31. **What's new in C# 7.0 - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-7 Features introduced in C# 7.0 including tuples, local functions, pattern matching. 33. **What's new in C# 9.0 - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-9 Records, init-only properties, top-level statements. 34. **What's new in C# 10 - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-10 Global using, file-scoped namespaces, record structs. 35. **What's new in C# 11 - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-11 Raw string literals, list patterns, required members. 36. **What's new in C# 12 - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-12 Primary constructors, collection expressions. ### Memory Management and Performance 45. **C# Data Types: Memory Allocation, Garbage Collection - Medium** https://dotnetfullstackdev.medium.com/c-data-types-memory-allocation-garbage-collection-and-beyond-79f0719b5ee4 Understanding memory allocation for value and reference types. 46. **C# Heap(ing) Vs Stack(ing) In .NET - C# Corner** https://www.c-sharpcorner.com/article/C-Sharp-heaping-vs-stacking-in-net-part-i/ Stack vs heap memory allocation in C#. 47. **Fundamentals of garbage collection - .NET - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/standard/garbage-collection/fundamentals Understanding .NET garbage collection. 48. **IDisposable - Cleaning up unmanaged resources - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/standard/garbage-collection/unmanaged Implementing IDisposable for resource cleanup. 49. **Object Pooling - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/api/microsoft.extensions.objectpool Object pooling for performance optimization. 50. **Span<T>, Memory<T>, and friends - Performance Improvements** https://learn.microsoft.com/en-us/archive/msdn-magazine/2018/january/csharp-all-about-span-exploring-a-new-net-mainstay Deep dive into high-performance memory types. ### Naming and Code Style 51. **C# Identifier naming rules and conventions - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/coding-style/identifier-names Official naming rules and conventions for C# identifiers. 52. **.NET Runtime Coding Style - GitHub** https://github.com/dotnet/runtime/blob/main/docs/coding-guidelines/coding-style.md .NET Runtime team's coding style guide. ### Best Practices and Design Patterns 53. **C# Coding Conventions - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/coding-style/coding-conventions Official C# coding conventions and best practices. 54. **Design Patterns in C# - Refactoring.Guru** https://refactoring.guru/design-patterns/csharp Comprehensive guide to design patterns with C# examples. 55. **Dependency injection guidelines - .NET - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/core/extensions/dependency-injection-guidelines Best practices for dependency injection in .NET. 56. **Repository Pattern - Martin Fowler** https://martinfowler.com/eaaCatalog/repository.html Repository pattern for data access abstraction. 57. **Gang of Four Design Patterns** https://en.wikipedia.org/wiki/Design_Patterns Classic design patterns applicable to C#. 58. **C# Best Practices - Clean Code Principles** https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/coding-style/ Clean code principles and best practices for C# development. 59. **Options pattern in ASP.NET Core - Microsoft Learn** https://learn.microsoft.com/en-us/aspnet/core/fundamentals/configuration/options Strongly-typed configuration using the options pattern. ### Comprehensive C# Resources 1. **Zero To Mastery - C# Cheat Sheet** https://zerotomastery.io/cheatsheets/csharp-cheat-sheet/ Comprehensive cheat sheet covering C# fundamentals to advanced topics. 2. **QuickRef.ME - C# Quick Reference** https://quickref.me/cs.html Quick reference for C# syntax and common operations. 42. **Entity Framework Core - Microsoft Learn** https://learn.microsoft.com/en-us/ef/core/ ORM framework for .NET with IQueryable support. 43. **Lazy<T> Class - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/api/system.lazy-1 Lazy initialization for deferred object creation. 44. **Lazy Initialization - Microsoft Learn** https://learn.microsoft.com/en-us/dotnet/framework/performance/lazy-initialization Patterns and best practices for lazy initialization. ### Additional Online Resources 25. **Records - C# 9.0 Feature - Medium** https://medium.com/@enrico.buonanno/pattern-matching-and-record-types-in-c-9-794d1d943fb2 Pattern matching and record types in C# 9. 24. **Embracing nullable reference types - .NET Blog** https://devblogs.microsoft.com/dotnet/embracing-nullable-reference-types/ Adopting nullable reference types in existing codebases. 32. **Ref Returns and Ref Locals - C# 7.0** https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/ref#ref-returns Performance optimization with ref returns and locals. ### Community Resources and Tutorials 6. **C# Corner - OOPs Concepts in C#** https://www.c-sharpcorner.com/UploadFile/mkagrahari/introduction-to-object-oriented-programming-concepts-in-C-Sharp/ Introduction to object-oriented programming concepts with examples.

On This Page

On This Page