C# Programming Cheat Sheet (2025 Edition)

Grab my .NET Ultimate Bundle for 2025 (500+ pages and a course)

Introduction

Support my work

Give a Star! ⭐

Table of contents

Comments

// This is a single-line comment
/* This is a 
 multi-line comment */
/// <summary>
/// XML documentation comment used to generate documentation
/// </summary>
public void DocumentedMethod() { }

/// <summary>
/// Adds two integers and returns the result
/// </summary>
/// <param name="a">First integer</param>
/// <param name="b">Second integer</param>
/// <returns>The sum of the two integers</returns>
/// <exception cref="OverflowException">Thrown when the sum is too large</exception>
public int Add(int a, int b) => a + b;

Strings

// Basic string creation
string greeting = "Hello";
string name = "World";
string message = greeting + " " + name; // "Hello World"
// String interpolation (C# 6.0+)
string interpolated = $"{greeting} {name}!"; // "Hello World!"
// Verbatim strings (preserves formatting and ignores escape sequences except "")
string path = @"C:\Users\UserName\Documents";
string multiline = @"This is a
multi-line string
that preserves formatting";
// Verbatim string interpolation
string verbatimInterpolated = $@"User {name}
Path: {path}";
// Raw string literals (C# 11+) - no escape sequences, preserves formatting
string json = """
{
 "name": "John Doe",
 "age": 30,
 "isActive": true
}
""";
// Raw string interpolation (C# 11+)
string name = "Jane";
string rawInterpolated = $"""
{
 "name": "{{name}}",
 "created": "{{DateTime.Now}}"
}
""";
// Common string methods
string text = "Hello, World!";
bool contains = text.Contains("World"); // true
string upper = text.ToUpper(); // "HELLO, WORLD!"
string lower = text.ToLower(); // "hello, world!"
string replaced = text.Replace("Hello", "Hi"); // "Hi, World!"
string trimmed = " text ".Trim(); // "text"
string[] split = text.Split(','); // ["Hello", " World!"]
int length = text.Length; // 13
// String comparison
bool equals = string.Equals("abc", "ABC", StringComparison.OrdinalIgnoreCase); // true
int comparison = string.Compare("abc", "ABC", StringComparison.Ordinal); // not equal

using System.Text;
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 100; i++)
{
 sb.Append($"Item {i}, ");
}
string result = sb.ToString();

Basic types and literals

// Integer types
byte byteValue = 255; // 8-bit unsigned integer (0 to 255)
sbyte sbyteValue = -128; // 8-bit signed integer (-128 to 127)
short shortValue = -32768; // 16-bit signed integer (-32,768 to 32,767)
ushort ushortValue = 65535; // 16-bit unsigned integer (0 to 65,535)
int intValue = -2147483648; // 32-bit signed integer (-2,147,483,648 to 2,147,483,647)
uint uintValue = 4294967295; // 32-bit unsigned integer (0 to 4,294,967,295)
long longValue = -9223372036854775808; // 64-bit signed integer (-9,223,372,036,854,775,808 to 9,223,372,036,854,775,807)
ulong ulongValue = 18446744073709551615; // 64-bit unsigned integer (0 to 18,446,744,073,709,551,615)
// Integer literals
int decimalLiteral = 42; // Decimal (base 10)
int hexLiteral = 0x2A; // Hexadecimal (base 16)
int binaryLiteral = 0b101010; // Binary (base 2)
int withSeparator = 1_000_000; // Digit separator for readability
// Floating point types
float floatValue = 3.14f; // 32-bit floating-point (7 significant digits precision)
double doubleValue = 3.14159265359; // 64-bit floating-point (15-16 significant digits precision)
decimal decimalValue = 3.14159265359m; // 128-bit high-precision decimal (28-29 significant digits)
// Boolean type
bool trueValue = true;
bool falseValue = false;
// Character type
char charValue = 'A'; // Unicode character
char unicodeChar = '\u0041'; // Unicode escape sequence for 'A'
char escapeChar = '\n'; // Newline escape sequence
// DateTime and TimeSpan
DateTime now = DateTime.Now;
DateTime utcNow = DateTime.UtcNow;
DateOnly today = DateOnly.FromDateTime(DateTime.Today); // Date without time (C# 10+)
TimeOnly noon = new TimeOnly(12, 0, 0); // Time without date (C# 10+)
DateTime specific = new DateTime(2023, 1, 1);
TimeSpan oneHour = TimeSpan.FromHours(1);
TimeSpan duration = TimeSpan.FromMinutes(90);
// Nullable types (can be null)
int? nullableInt = null;
bool? nullableBool = null;
// Default values
int defaultInt = default; // 0
bool defaultBool = default; // false
string defaultString = default; // null
DateTime defaultDateTime = default; // 0001年01月01日 00:00:00
// Numeric type aliases (C# 12+)
using intptr = nint; // Native-sized integer
using uintptr = nuint; // Unsigned native-sized integer
using index = System.Index; // Type alias for Index

var inferredInt = 42; // Compiler infers int
var inferredString = "Hello"; // Compiler infers string
var inferredList = new List<int>(); // Compiler infers List<int>

// Compile-time constants (must be primitive types or string)
const double Pi = 3.14159;
const string AppName = "MyApp";
// Runtime constants
readonly DateTime StartTime = DateTime.Now;
// Static readonly - initialized only once at runtime
public static readonly HttpClient SharedClient = new HttpClient();
// Init-only setter - can only be set during initialization
public string Id { get; init; } = Guid.NewGuid().ToString();
// Read-only fields/properties with field/property initializers
public required string Name { get; init; }

Statements

Control flow

If-else statements

// Basic if statement
if (condition)
{
 // Code executed if condition is true
}
// If-else
if (temperature > 30)
{
 Console.WriteLine("It's hot outside");
}
else
{
 Console.WriteLine("It's not too hot");
}
// If-else if-else chain
if (temperature > 30)
{
 Console.WriteLine("It's hot outside");
}
else if (temperature > 20)
{
 Console.WriteLine("It's warm outside");
}
else if (temperature > 10)
{
 Console.WriteLine("It's cool outside");
}
else
{
 Console.WriteLine("It's cold outside");
}
// Conditional (ternary) operator - shorthand for simple if-else
string message = age >= 18 ? "Adult" : "Minor";
// Null-coalescing operator (??) - returns the left operand if it's not null, otherwise the right
string name = userName ?? "Anonymous";
// Null-conditional operator (?.) - safely accesses members of potentially null objects
int? length = customer?.Name?.Length;
// Null-coalescing assignment (??=) - C# 8.0+
// Assigns the right operand only if the left operand is null
userName ??= "Anonymous";

Switch statements and expressions

// Traditional switch statement
switch (dayOfWeek)
{
 case DayOfWeek.Monday:
 Console.WriteLine("Start of work week");
 break;
 case DayOfWeek.Friday:
 Console.WriteLine("End of work week");
 break;
 case DayOfWeek.Saturday:
 case DayOfWeek.Sunday:
 Console.WriteLine("Weekend");
 break;
 default:
 Console.WriteLine("Midweek");
 break;
}
// Switch expression (C# 8.0+)
string GetDayType(DayOfWeek day) => day switch
{
 DayOfWeek.Monday => "Start of work week",
 DayOfWeek.Friday => "End of work week",
 DayOfWeek.Saturday or DayOfWeek.Sunday => "Weekend",
 _ => "Midweek" // Default case
};
// Switch expression with pattern matching
string GetShapeDescription(object shape) => shape switch
{
 Circle c when c.Radius > 10 => "Large circle",
 Circle _ => "Circle",
 Rectangle { Width: 0 } => "Line",
 Rectangle { Length: var l, Width: var w } when l == w => "Square",
 Rectangle _ => "Rectangle",
 null => "No shape",
 _ => "Unknown shape"
};

Loops

For loops

// Basic for loop
for (int i = 0; i < 10; i++)
{
 Console.WriteLine($"Iteration {i}");
}
// Multiple loop variables
for (int i = 0, j = 10; i < j; i++, j--)
{
 Console.WriteLine($"i = {i}, j = {j}");
}
// Nested for loops
for (int i = 0; i < 3; i++)
{
 for (int j = 0; j < 3; j++)
 {
 Console.WriteLine($"Position [{i},{j}]");
 }
}
// Breaking out of a loop
for (int i = 0; i < 100; i++)
{
 if (i > 10)
 break; // Exits the loop
 
 Console.WriteLine(i);
}
// Skipping an iteration
for (int i = 0; i < 10; i++)
{
 if (i % 2 == 0)
 continue; // Skips to the next iteration
 
 Console.WriteLine($"Odd number: {i}");
}

Foreach loops

// Basic foreach loop
foreach (string name in names)
{
 Console.WriteLine(name);
}
// Using index with foreach (C# 9.0+)
foreach (string name in names.Select((value, index) => new { value, index }))
{
 Console.WriteLine($"{name.index}: {name.value}");
}
// Iterating through key-value pairs
foreach (KeyValuePair<string, int> pair in dictionary)
{
 Console.WriteLine($"{pair.Key}: {pair.Value}");
}
// Using deconstruction with foreach (C# 7.0+)
foreach (var (key, value) in dictionary)
{
 Console.WriteLine($"{key}: {value}");
}
// Breaking and continuing also work in foreach
foreach (var item in collection)
{
 if (ShouldSkip(item))
 continue;
 
 if (ShouldStop(item))
 break;
 
 Process(item);
}

While and do-while loops

// While loop - may execute zero times
while (condition)
{
 // Loop body
}
// Example: reading until a condition is met
while (!Console.KeyAvailable)
{
 // Process until a key is pressed
 ProcessData();
}
// Do-while loop - always executes at least once
do
{
 // Loop body
} while (condition);
// Example: menu system
string choice;
do
{
 DisplayMenu();
 choice = Console.ReadLine();
 ProcessChoice(choice);
} while (choice != "exit");

Lock statement

// Define a lock object (private to avoid external locking)
private readonly object _lockObject = new object();
// Using the lock statement
public void AddItem(string item)
{
 lock (_lockObject)
 {
 // This code can only be executed by one thread at a time
 _items.Add(item);
 _count++;
 }
}

Using statement

// Traditional using statement
using (StreamReader reader = new StreamReader("file.txt"))
{
 string content = reader.ReadToEnd();
 // reader is automatically disposed here, even if an exception occurs
}
// Using declaration (C# 8.0+)
using StreamWriter writer = new StreamWriter("output.txt");
writer.WriteLine("Hello, World!");
// writer is disposed at the end of the scope
// Multiple resources in one using statement
using (var connection = new SqlConnection(connectionString))
using (var command = new SqlCommand(queryString, connection))
{
 connection.Open();
 using (var reader = command.ExecuteReader())
 {
 // Process data
 }
}
// Using declaration with multiple resources (C# 8.0+)
using var fileStream = new FileStream("data.bin", FileMode.Create);
using var binaryWriter = new BinaryWriter(fileStream);
binaryWriter.Write(42);
// Both binaryWriter and fileStream are disposed at end of scope

Unsafe code

// Must enable unsafe code in project settings or compiler options
// <AllowUnsafeBlocks>true</AllowUnsafeBlocks> in .csproj
// Unsafe method
public unsafe void ProcessBuffer(byte[] buffer)
{
 fixed (byte* ptr = buffer)
 {
 // Direct memory manipulation
 for (int i = 0; i < buffer.Length; i++)
 {
 *(ptr + i) = (byte)(*(ptr + i) * 2);
 }
 }
}
// Unsafe context with pointer operations
unsafe
{
 int value = 10;
 int* pointer = &value;
 
 Console.WriteLine($"Value: {*pointer}");
 
 // Increment the value through the pointer
 *pointer = 20;
 Console.WriteLine($"Updated value: {value}");
}
// sizeof operator (only allowed in unsafe context)
unsafe
{
 Console.WriteLine($"Size of int: {sizeof(int)} bytes");
 Console.WriteLine($"Size of double: {sizeof(double)} bytes");
}

Yield statement

// Simple iterator method
public IEnumerable<int> GetNumbers(int count)
{
 for (int i = 0; i < count; i++)
 {
 yield return i;
 }
}
// Iterator method with conditional logic
public IEnumerable<int> GetEvenNumbers(int max)
{
 for (int i = 0; i <= max; i++)
 {
 if (i % 2 == 0)
 {
 yield return i;
 }
 }
}
// Yield break to exit early
public IEnumerable<int> GetNumbersUntil(int max, int stopAt)
{
 for (int i = 0; i <= max; i++)
 {
 if (i == stopAt)
 {
 yield break; // Exit the iterator
 }
 
 yield return i;
 }
}
// Using yield to implement filtering
public IEnumerable<T> Where<T>(IEnumerable<T> source, Func<T, bool> predicate)
{
 foreach (var item in source)
 {
 if (predicate(item))
 {
 yield return item;
 }
 }
}

Benefits of yield:

Methods and functions

Basic method syntax

// Instance method
public int Add(int a, int b)
{
 return a + b;
}
// Static method
public static double CalculateArea(double radius)
{
 return Math.PI * radius * radius;
}
// Void method (no return value)
public void PrintMessage(string message)
{
 Console.WriteLine(message);
}

Expression-bodied members (C# 6.0+)

// Expression-bodied method (one-line methods)
public int Multiply(int a, int b) => a * b;
// Expression-bodied property
public string FullName => $"{FirstName} {LastName}";

Method parameters

// Optional parameters
public void Greet(string name, string greeting = "Hello")
{
 Console.WriteLine($"{greeting}, {name}!");
}
// Named arguments
Greet(greeting: "Hi", name: "Alice");
// Ref parameters (pass by reference)
public void Swap(ref int a, ref int b)
{
 int temp = a;
 a = b;
 b = temp;
}
// Usage: Swap(ref x, ref y);
// Out parameters (for returning multiple values)
public bool TryParse(string input, out int result)
{
 return int.TryParse(input, out result);
}
// Usage: bool success = TryParse("123", out int number);
// In parameters (read-only reference - C# 7.2+)
public double CalculateDistance(in Point p1, in Point p2)
{
 // p1 and p2 cannot be modified
 return Math.Sqrt(Math.Pow(p2.X - p1.X, 2) + Math.Pow(p2.Y - p1.Y, 2));
}
// Params array (variable number of arguments)
public int Sum(params int[] numbers)
{
 int total = 0;
 foreach (int number in numbers)
 {
 total += number;
 }
 return total;
}
// Usage: Sum(1, 2, 3, 4, 5);

Local functions (C# 7.0+)

public int Factorial(int n)
{
 // Local function defined inside another method
 int CalculateFactorial(int number)
 {
 if (number <= 1) return 1;
 return number * CalculateFactorial(number - 1);
 }
 
 return CalculateFactorial(n);
}

Extension methods

// Must be defined in a non-nested, non-generic static class
public static class StringExtensions
{
 // Extension method for string type
 public static bool IsNullOrEmpty(this string value)
 {
 return string.IsNullOrEmpty(value);
 }
 
 // Extension method with parameters
 public static string Truncate(this string value, int maxLength)
 {
 if (string.IsNullOrEmpty(value)) return value;
 return value.Length <= maxLength ? value : value.Substring(0, maxLength);
 }
}
// Usage
string text = "Hello, World!";
bool isEmpty = text.IsNullOrEmpty(); // false
string truncated = text.Truncate(5); // "Hello"

Lambda expressions

// Func delegate (takes parameters, returns a value)
Func<int, int, int> add = (a, b) => a + b;
int sum = add(2, 3); // 5
// Action delegate (takes parameters, returns void)
Action<string> print = message => Console.WriteLine(message);
print("Hello!"); // Prints "Hello!"
// Predicate delegate (takes parameters, returns bool)
Predicate<int> isEven = number => number % 2 == 0;
bool result = isEven(4); // true
// Multi-line lambda
Func<int, int> factorial = n =>
{
 int result = 1;
 for (int i = 1; i <= n; i++)
 {
 result *= i;
 }
 return result;
};

Default parameters in lambdas (C# 12)

Func<int, int, int> add = (x, y = 10) => x + y;
int result = add(5); // 15

Method overloading

// Method overloading (same name, different parameters)
public void Display(int value)
{
 Console.WriteLine($"Integer: {value}");
}
public void Display(string value)
{
 Console.WriteLine($"String: {value}");
}
public void Display(int value, string format)
{
 Console.WriteLine($"Formatted: {value.ToString(format)}");
}

Delegates and events

public delegate int Operation(int x, int y);
public int Add(int a, int b) => a + b;
public int Multiply(int a, int b) => a * b;
// Usage
Operation op = Add;
int result = op(3, 4); // 7
op += Multiply; // Multicast delegate

public class Button
{
 public event EventHandler Clicked;
 protected virtual void OnClicked() =>
 Clicked?.Invoke(this, EventArgs.Empty);
}
// Usage
var button = new Button();
button.Clicked += (sender, args) => Console.WriteLine("Clicked!");

Data types

Classes

// Basic class definition
public class Person
{
 // Fields
 private string name;
 private int age;
 
 // Properties
 public string Name 
 { 
 get { return name; }
 set { name = value; } 
 }
 
 // Auto-implemented property
 public int Age { get; set; }
 
 // Read-only property
 public bool IsAdult => Age >= 18;
 
 // Constructors
 public Person()
 {
 // Default constructor
 }
 
 public Person(string name, int age)
 {
 Name = name;
 Age = age;
 }
 
 // Methods
 public void Introduce()
 {
 Console.WriteLine($"Hello, my name is {Name} and I'm {Age} years old.");
 }
 
 public string GetDescription() => $"{Name}, {Age} years old";
 
 // Static members
 public static int MinimumAge { get; } = 0;
 
 public static bool IsValidAge(int age)
 {
 return age >= MinimumAge;
 }
}
// Usage
Person person = new Person();
person.Name = "Alice";
person.Age = 30;
person.Introduce();
Person bob = new Person("Bob", 25);
string description = bob.GetDescription();
bool isAdult = bob.IsAdult;
bool isValid = Person.IsValidAge(20);

Structs

// Basic struct definition
public struct Point
{
 // Fields
 public double X { get; set; }
 public double Y { get; set; }
 
 // Constructor
 public Point(double x, double y)
 {
 X = x;
 Y = y;
 }
 
 // Methods
 public double DistanceFromOrigin()
 {
 return Math.Sqrt(X * X + Y * Y);
 }
 
 // Override ToString method
 public override string ToString() => $"({X}, {Y})";
}
// Usage
Point point = new Point(3, 4);
double distance = point.DistanceFromOrigin(); // 5

Records (C# 9.0+)

// Positional record (concise syntax)
public record Person(string FirstName, string LastName, int Age);
// Usage
var person1 = new Person("John", "Doe", 30);
var person2 = new Person("John", "Doe", 30);
// Records have value-based equality
bool areEqual = person1 == person2; // true
// Non-destructive mutation with 'with' expression
var person3 = person1 with { Age = 31 };
// Records can also be defined with standard syntax for more flexibility
public record Employee
{
 public string FirstName { get; init; }
 public string LastName { get; init; }
 public int Id { get; init; }
 
 // Additional members can be defined
 public string FullName => $"{FirstName} {LastName}";
}

Record structs (C# 10.0+)

// Record struct
public record struct Point(double X, double Y);
// Mutable record struct
public record struct MutablePoint
{
 public double X { get; set; }
 public double Y { get; set; }
 
 public double Distance => Math.Sqrt(X * X + Y * Y);
}

Interfaces

// Interface definition
public interface IShape
{
 double Area { get; }
 double Perimeter { get; }
 void Draw();
 string GetDescription() => $"Shape with area {Area} and perimeter {Perimeter}"; // Default implementation (C# 8.0+)
}
// Implementing an interface
public class Circle : IShape
{
 public double Radius { get; }
 
 public Circle(double radius)
 {
 Radius = radius;
 }
 
 public double Area => Math.PI * Radius * Radius;
 public double Perimeter => 2 * Math.PI * Radius;
 
 public void Draw()
 {
 Console.WriteLine("Drawing a circle");
 }
 
 // Override default implementation
 public string GetDescription() => $"Circle with radius {Radius}";
}

public interface ILogger
{
 void Log(string message);
 
 // Default implementation
 void LogError(string message) => Log($"ERROR: {message}");
 void LogWarning(string message) => Log($"WARNING: {message}");
 
 // Static method in interface
 static string FormatMessage(string level, string message) => $"[{level}] {message}";
}
// Implement only required methods
public class MinimalLogger : ILogger
{
 public void Log(string message)
 {
 Console.WriteLine(message);
 }
 
 // Other methods use default implementations
}

Enums

// Basic enum
public enum DayOfWeek
{
 Sunday, // 0
 Monday, // 1
 Tuesday, // 2
 Wednesday, // 3
 Thursday, // 4
 Friday, // 5
 Saturday // 6
}
// Enum with explicit values
public enum HttpStatusCode
{
 OK = 200,
 Created = 201,
 BadRequest = 400,
 Unauthorized = 401,
 NotFound = 404,
 InternalServerError = 500
}
// Enum with flags attribute (for bitwise operations)
[Flags]
public enum Permissions
{
 None = 0,
 Read = 1,
 Write = 2,
 Execute = 4,
 All = Read | Write | Execute
}
// Usage
DayOfWeek today = DayOfWeek.Monday;
HttpStatusCode status = HttpStatusCode.OK;
// Convert between enum and integer
int dayValue = (int)today;
DayOfWeek convertedDay = (DayOfWeek)3; // Wednesday
// Parsing from string
DayOfWeek parsed = Enum.Parse<DayOfWeek>("Friday");
bool success = Enum.TryParse("Sunday", out DayOfWeek result);
// Using flags
Permissions userPermissions = Permissions.Read | Permissions.Write;
bool canRead = userPermissions.HasFlag(Permissions.Read); // true
bool canExecute = userPermissions.HasFlag(Permissions.Execute); // false

Tuples

// Creating tuples (C# 7.0+)
(int, string) pair = (1, "one");
var person = (Name: "Alice", Age: 30);
// Accessing tuple elements
int id = pair.Item1;
string value = pair.Item2;
string name = person.Name;
int age = person.Age;
// Tuple deconstruction
var (newId, newValue) = pair;
var (newName, newAge) = person;
// Using tuples as method return values
(int Min, int Max) FindMinMax(int[] numbers)
{
 return (numbers.Min(), numbers.Max());
}
var result = FindMinMax(new[] { 1, 2, 3, 4, 5 });
Console.WriteLine($"Min: {result.Min}, Max: {result.Max}");
// Tuple as method parameter
void ProcessData((string Name, int Age) person)
{
 Console.WriteLine($"Processing data for {person.Name}, {person.Age}");
}

Nullable types

// Nullable value types
int? nullableInt = null;
double? nullableDouble = 3.14;
// Checking for null
if (nullableInt.HasValue)
{
 int value = nullableInt.Value;
}
// Null-coalescing operator
int result = nullableInt ?? 0; // If nullableInt is null, use 0
// Nullable reference types (C# 8.0+)
// Enable with: #nullable enable
string? nullableString = null;
string nonNullableString = "Hello"; // Cannot be null
// Null-conditional operator
int? length = nullableString?.Length; // null if nullableString is null
// Null-coalescing assignment (C# 8.0+)
nullableString ??= "Default";

Generics

public class Repository<T>
{
 private readonly List<T> _items = new();
 public void Add(T item) => _items.Add(item);
 public T Get(int index) => _items[index];
}
// Usage
var intRepo = new Repository<int>();
intRepo.Add(42);
int number = intRepo.Get(0);

public T Echo<T>(T input) => input;
// Usage
string message = Echo("Hello");
int number = Echo(123);

public class EmployeeRepository<T> where T : Employee, new()
{
 public T Create() => new T();
}

Classes

Constructors and initialization

public class Person
{
 public string Name { get; set; }
 public int Age { get; set; }
 
 // Default constructor
 public Person()
 {
 Name = "Unknown";
 Age = 0;
 }
 
 // Parameterized constructor
 public Person(string name, int age)
 {
 Name = name;
 Age = age;
 }
 
 // Static constructor (called once before type is used)
 static Person()
 {
 Console.WriteLine("Person type initialized");
 }
}
// Constructor chaining
public class Employee : Person
{
 public string Department { get; set; }
 
 // Call the base class constructor
 public Employee(string name, int age, string department) 
 : base(name, age)
 {
 Department = department;
 }
 
 // Chain to another constructor in the same class
 public Employee(string name, int age)
 : this(name, age, "General")
 {
 }
}

Primary constructors (C# 12+)

// Class with primary constructor
public class Person(string name, int age)
{
 // Properties initialized by primary constructor parameters
 public string Name { get; } = name;
 public int Age { get; } = age;
 
 // Can use constructor parameters directly in methods
 public string Introduce() => $"My name is {name} and I'm {age} years old";
 
 // Can still have additional constructors
 public Person(string name) : this(name, 0)
 {
 Console.WriteLine("Created a person with default age");
 }
}
// Inheritance with primary constructors
public class Employee(string name, int age, string department) : Person(name, age)
{
 public string Department { get; } = department;
 
 // Using base constructor parameters
 public override string Introduce() => $"{base.Introduce()} working in {department}";
}
// Usage
var alice = new Person("Alice", 30);
var bob = new Employee("Bob", 25, "Engineering");

Inheritance

// Base class
public class Animal
{
 public string Name { get; set; }
 
 public Animal(string name)
 {
 Name = name;
 }
 
 public virtual void MakeSound()
 {
 Console.WriteLine("Some generic animal sound");
 }
 
 // Non-overridable method
 public void Sleep()
 {
 Console.WriteLine($"{Name} is sleeping");
 }
}
// Derived class
public class Dog : Animal
{
 public string Breed { get; set; }
 
 public Dog(string name, string breed) : base(name)
 {
 Breed = breed;
 }
 
 // Override base class method
 public override void MakeSound()
 {
 Console.WriteLine("Woof!");
 }
 
 // New method
 public void Fetch()
 {
 Console.WriteLine($"{Name} is fetching the ball");
 }
}

Abstract classes

// Abstract class
public abstract class Shape
{
 // Abstract property (must be implemented)
 public abstract double Area { get; }
 
 // Abstract method (must be implemented)
 public abstract double Perimeter();
 
 // Concrete method
 public void PrintInfo()
 {
 Console.WriteLine($"Area: {Area}, Perimeter: {Perimeter()}");
 }
}
// Concrete implementation
public class Rectangle : Shape
{
 public double Width { get; set; }
 public double Height { get; set; }
 
 public Rectangle(double width, double height)
 {
 Width = width;
 Height = height;
 }
 
 public override double Area => Width * Height;
 
 public override double Perimeter() => 2 * (Width + Height);
}

Sealed classes and members

// Sealed class (cannot be inherited)
public sealed class Utility
{
 public static void DoSomething() { }
}
public class Base
{
 // Virtual method that can be overridden
 public virtual void Method1() { }
 
 // Virtual method that can be overridden
 public virtual void Method2() { }
}
public class Derived : Base
{
 public override void Method1() { }
 
 // Sealed method (can't be overridden further in inheritance chain)
 public sealed override void Method2() { }
}
public class Further : Derived
{
 public override void Method1() { } // OK
 // public override void Method2() { } // Error: cannot override sealed method
}

Polymorphism

// Base class reference can refer to derived class objects
Animal myPet = new Dog("Fido", "Beagle");
myPet.MakeSound(); // Outputs "Woof!"
// Array of base class can hold derived objects
Animal[] animals = new Animal[]
{
 new Dog("Fido", "Beagle"),
 new Cat("Whiskers"),
 new Rabbit("Hopper")
};
// Polymorphic behavior
foreach (Animal animal in animals)
{
 Console.WriteLine($"{animal.Name} says:");
 animal.MakeSound(); // Each animal makes its own sound
}
// Type checking and casting
if (animals[0] is Dog dog)
{
 dog.Fetch(); // Access Dog-specific method
}
// Explicit casting
Dog anotherDog = (Dog)animals[0];

Collections

Collection Expressions (C# 12+)

// Creating collections with the new collection expressions syntax
int[] numbers = [1, 2, 3, 4, 5]; // Array
List<string> names = ["Alice", "Bob", "Charlie"]; // List
HashSet<char> letters = ['a', 'b', 'c']; // HashSet
Dictionary<string, int> ages = [ // Dictionary
 "Alice" => 30,
 "Bob" => 25,
 "Charlie" => 35
];
// Spread operator - combining collections
int[] moreNumbers = [0, .. numbers, 6]; // [0, 1, 2, 3, 4, 5, 6]
string[] firstThree = [.. names[0..3]]; // ["Alice", "Bob", "Charlie"]
// Pattern matching with collection expressions
bool IsValidPoint(int[] point) => point is [var x, var y] && x >= 0 && y >= 0;

Arrays

// Declaration and initialization
int[] numbers = new int[5]; // Array of 5 integers with default values (0)
int[] initialized = new int[] { 1, 2, 3, 4, 5 }; // Initialized array
int[] shorthand = { 1, 2, 3, 4, 5 }; // Shorthand initialization
string[] names = { "Alice", "Bob", "Charlie" };
// Accessing elements
int firstNumber = numbers[0]; // First element (zero-based indexing)
numbers[0] = 10; // Assign value to first element
// Multi-dimensional arrays
int[,] matrix = new int[3, 3]; // 3x3 2D array
matrix[0, 0] = 1; // Assign to specific position
int[,] initialized2D = { // Initialize 2D array
 { 1, 2, 3 },
 { 4, 5, 6 },
 { 7, 8, 9 }
};
// Jagged arrays (arrays of arrays)
int[][] jagged = new int[3][];
jagged[0] = new int[] { 1, 2, 3 };
jagged[1] = new int[] { 4, 5 };
jagged[2] = new int[] { 6, 7, 8, 9 };
// Array properties and methods
int length = numbers.Length; // Number of elements
Array.Sort(numbers); // Sort array in-place
Array.Reverse(numbers); // Reverse array in-place
int index = Array.IndexOf(names, "Bob"); // Find index of element
bool exists = Array.Exists(numbers, n => n > 10); // Check if condition exists

Lists

using System.Collections.Generic;
// Create a list
List<string> names = new List<string>(); // Empty list
List<int> numbers = new List<int> { 1, 2, 3 }; // Initialized list
// Add elements 
names.Add("Alice"); // Add single element
names.AddRange(new[] { "Bob", "Charlie" }); // Add multiple elements
// Access elements
string first = names[0]; // Access by index
names[0] = "Alicia"; // Modify by index
// Remove elements
names.Remove("Bob"); // Remove specific element
names.RemoveAt(0); // Remove element at index
names.RemoveAll(x => x.StartsWith("C")); // Remove all that match condition
names.Clear(); // Remove all elements
// Search and query
bool contains = numbers.Contains(2); // Check if contains value
int index = numbers.IndexOf(3); // Find index of element
List<int> filtered = numbers.FindAll(n => n > 1); // Find all matching elements
int found = numbers.Find(n => n > 2); // Find first matching element
// Other operations
int count = numbers.Count; // Number of elements
numbers.Sort(); // Sort list in-place
numbers.Reverse(); // Reverse list in-place
numbers.ForEach(n => Console.WriteLine(n)); // Perform action on each element

Dictionary

using System.Collections.Generic;
// Create a dictionary
Dictionary<string, int> ages = new Dictionary<string, int>();
Dictionary<string, string> capitals = new Dictionary<string, string>
{
 { "USA", "Washington D.C." },
 { "UK", "London" },
 ["France"] = "Paris" // Alternative initialization syntax
};
// Add entries
ages.Add("Alice", 30);
ages["Bob"] = 25; // Add or update using indexer
// Access values
int aliceAge = ages["Alice"]; // Access by key (throws if not found)
bool success = ages.TryGetValue("Charlie", out int charlieAge); // Safe access
// Check existence
bool containsKey = ages.ContainsKey("Alice");
bool containsValue = ages.ContainsValue(25);
// Remove entries
bool removed = ages.Remove("Bob");
// Iterate through dictionary
foreach (KeyValuePair<string, int> pair in ages)
{
 Console.WriteLine($"{pair.Key}: {pair.Value}");
}
// Or using deconstruction (C# 7.0+)
foreach (var (name, age) in ages)
{
 Console.WriteLine($"{name}: {age}");
}

HashSet

using System.Collections.Generic;
// Create a HashSet
HashSet<int> uniqueNumbers = new HashSet<int>();
HashSet<string> fruits = new HashSet<string> { "Apple", "Banana", "Orange" };
// Add elements
uniqueNumbers.Add(1); // Returns true if added
uniqueNumbers.Add(1); // Returns false (already exists)
uniqueNumbers.UnionWith(new[] { 2, 3, 4 }); // Add multiple elements
// Check membership
bool contains = fruits.Contains("Apple"); // Fast lookup
// Remove elements
bool removed = fruits.Remove("Banana");
// Set operations
HashSet<int> setA = new HashSet<int> { 1, 2, 3 };
HashSet<int> setB = new HashSet<int> { 3, 4, 5 };
setA.UnionWith(setB); // Union: { 1, 2, 3, 4, 5 }
setA.IntersectWith(setB); // Intersection: { 3 }
setA.ExceptWith(setB); // Difference: { 1, 2 }
setA.SymmetricExceptWith(setB); // Symmetric difference: { 1, 2, 4, 5 }
bool isSubset = setA.IsSubsetOf(setB);
bool isSuperset = setA.IsSupersetOf(setB);

Queue and Stack

using System.Collections.Generic;
// Queue (First In, First Out)
Queue<string> queue = new Queue<string>();
queue.Enqueue("First"); // Add to end
queue.Enqueue("Second");
queue.Enqueue("Third");
string next = queue.Peek(); // View next item without removing
string dequeued = queue.Dequeue(); // Remove and return next item
int count = queue.Count; // Number of items
bool contains = queue.Contains("Second");
// Stack (Last In, First Out)
Stack<int> stack = new Stack<int>();
stack.Push(1); // Add to top
stack.Push(2);
stack.Push(3);
int top = stack.Peek(); // View top item without removing
int popped = stack.Pop(); // Remove and return top item
int stackCount = stack.Count; // Number of items
bool stackContains = stack.Contains(2);

LINQ (Language Integrated Query)

using System.Linq;
List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
// Filtering
var evens = numbers.Where(n => n % 2 == 0); // [2, 4, 6, 8, 10]
var greaterThanFive = numbers.Where(n => n > 5); // [6, 7, 8, 9, 10]
// Transformation
var doubled = numbers.Select(n => n * 2); // [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
var numberObjects = numbers.Select(n => new { Value = n, IsEven = n % 2 == 0 });
// Ordering
var ascending = numbers.OrderBy(n => n); // [1, 2, 3, ...]
var descending = numbers.OrderByDescending(n => n); // [10, 9, 8, ...]
var complex = numbers.OrderBy(n => n % 3).ThenByDescending(n => n); // Multiple criteria
// Aggregation
int sum = numbers.Sum(); // 55
int min = numbers.Min(); // 1
int max = numbers.Max(); // 10
double average = numbers.Average(); // 5.5
int product = numbers.Aggregate((a, b) => a * b); // 3628800 (factorial of 10)
// Quantifiers
bool allEven = numbers.All(n => n % 2 == 0); // false
bool anyEven = numbers.Any(n => n % 2 == 0); // true
bool containsSeven = numbers.Contains(7); // true
// Partitioning
var firstThree = numbers.Take(3); // [1, 2, 3]
var skipFirstThree = numbers.Skip(3); // [4, 5, 6, 7, 8, 9, 10]
var takeLast = numbers.TakeLast(2); // [9, 10]
var skipLast = numbers.SkipLast(2); // [1, 2, 3, 4, 5, 6, 7, 8]
// Element operations
int first = numbers.First(); // 1
int firstEven = numbers.First(n => n % 2 == 0); // 2
int lastOdd = numbers.Last(n => n % 2 != 0); // 9
int single = numbers.Where(n => n == 5).Single(); // 5
// Grouping
var groups = numbers.GroupBy(n => n % 3); // Groups by remainder when divided by 3
foreach (var group in groups)
{
 Console.WriteLine($"Remainder {group.Key}: {string.Join(", ", group)}");
}
// Query syntax (alternative to method syntax)
var queryResult = from n in numbers
 where n > 5
 orderby n descending
 select n * 2;

Pattern matching

Type patterns

// Type pattern - check if object is of a specific type
object value = "Hello";
if (value is string text)
{
 // 'text' is the value cast to string, available in this scope
 Console.WriteLine(text.ToUpper());
}
// Switch expression with type patterns (C# 8.0+)
string GetDisplayName(object item) => item switch
{
 Person p => $"Person: {p.Name}",
 DateTime d => $"Date: {d.ToShortDateString()}",
 int i => $"Number: {i}",
 string s => $"Text: {s}",
 null => "Null value",
 _ => "Unknown type" // Default case
};

Property patterns

// Property pattern to match object properties
if (person is { Name: "Alice", Age: >= 30 })
{
 Console.WriteLine("Found Alice who is 30 or older");
}
// Switch expression with property patterns
string GetAgeCategory(Person person) => person switch
{
 { Age: < 13 } => "Child",
 { Age: < 20 } => "Teenager",
 { Age: < 65 } => "Adult",
 _ => "Senior"
};
// Nested property patterns
if (order is { Customer: { Name: "Alice" } })
{
 Console.WriteLine("This is Alice's order");
}

Tuple patterns

// Tuple pattern
(int x, int y) = (5, 10);
string GetQuadrant(int x, int y) => (x, y) switch
{
 (> 0, > 0) => "First quadrant",
 (< 0, > 0) => "Second quadrant",
 (< 0, < 0) => "Third quadrant",
 (> 0, < 0) => "Fourth quadrant",
 (0, 0) => "Origin",
 (_, 0) => "X-axis",
 (0, _) => "Y-axis"
};

Logical patterns

// 'and', 'or', and 'not' patterns (C# 9.0+)
if (person is { Age: > 20 and < 30, Name: "Alice" or "Bob" })
{
 Console.WriteLine("Person is between 20-30 and named Alice or Bob");
}
// In switch expression
string CheckValue(int value) => value switch
{
 > 0 and < 10 => "Single digit positive",
 >= 10 and < 100 => "Double digit positive",
 < 0 and not -1 => "Negative, but not -1",
 0 or -1 => "Zero or negative one",
 _ => "Other"
};

List patterns (C# 11.0+)

// List pattern in C# 11
var numbers = new[] { 1, 2, 3, 4 };
bool IsFirstTwoPositive(int[] numbers) => numbers is [> 0, > 0, ..];
string DescribeArray(int[] arr) => arr switch
{
 [] => "Empty array",
 [var single] => $"Single item: {single}",
 [var first, var second] => $"Two items: {first}, {second}",
 [var first, .. var middle, var last] => $"Multiple items, starts with {first}, ends with {last}",
 _ => "Unknown pattern"
};

Discard pattern

// Discard pattern (underscore) to ignore values
string GetSign(int number) => number switch
{
 < 0 => "Negative",
 > 0 => "Positive",
 _ => "Zero"
};
// Multiple discards
(string, int) person = ("Alice", 30);
var (name, _) = person; // Discard the age

Exceptions

Try-catch-finally

try
{
 // Code that might throw an exception
 int result = 10 / 0; // Will throw DivideByZeroException
 File.ReadAllText("nonexistent.txt"); // Will throw FileNotFoundException
}
catch (DivideByZeroException ex)
{
 // Handle specific exception
 Console.WriteLine($"Math error: {ex.Message}");
 // Log the exception details for developers
 Logger.LogError(ex, "Division by zero occurred");
 // Provide user-friendly message
 ShowUserErrorMessage("A calculation error occurred. Please try different input values.");
}
catch (FileNotFoundException ex) when (ex.FileName.Contains("nonexistent"))
{
 // Exception filter (C# 6.0+) allows conditionals to catch blocks
 Console.WriteLine($"File not found: {ex.FileName}");
}
catch (IOException ex)
{
 // Handle another specific exception
 Console.WriteLine($"IO error: {ex.Message}");
}
catch (Exception ex)
{
 // Catch all other exceptions
 Console.WriteLine($"Unexpected error: {ex.Message}");
 throw; // Re-throw the exception to preserve stack trace
}
finally
{
 // Code that always executes, whether an exception occurred or not
 Console.WriteLine("This always runs");
 // Common cleanup operations:
 // - Close file handles
 // - Release database connections
 // - Dispose of unmanaged resources
 // - Return pooled objects
}

When to use different Exception approaches

Throwing Exceptions

// Throw exceptions
void ProcessData(string data)
{
 if (data == null)
 {
 throw new ArgumentNullException(nameof(data), "Data cannot be null.");
 }
 
 if (data.Length == 0)
 {
 throw new ArgumentException("Data cannot be empty.", nameof(data));
 }
 
 if (!IsValidFormat(data))
 {
 throw new FormatException($"Data '{data}' is not in the required format.");
 }
 
 // Process valid data...
}
// Rethrowing exceptions
try
{
 ProcessData(null);
}
catch (Exception ex)
{
 // Log the exception
 Console.WriteLine($"Error: {ex.Message}");
 
 // Preserve stack trace when rethrowing
 throw;
 
 // This would reset the stack trace (usually undesirable):
 // throw ex;
}