C# Programming Language Cheat Sheet

Updated 2026-04-28

Next Topic: C++ Programming Language Cheat Sheet

🧠Study flashcards on this topic242 cards · spaced repetition→

C# is a modern, object-oriented programming language developed by Microsoft as part of its .NET initiative, first released in 2000 and currently at version 14 (2026, .NET 10). It combines type safety and garbage collection with fine-grained control when needed, running on the Common Language Runtime (CLR) which provides cross-platform support. The language has evolved significantly with features like async/await, LINQ, pattern matching, nullable reference types, and now extension members that prioritize developer productivity and code safety. Think of C# as a strongly-typed, garbage-collected language where you rarely manage memory manually but gain full low-level control via unsafe contexts, Span<T>, and stackalloc — understanding this balance between safety and performance is key to mastering the language.

What This Cheat Sheet Covers

This topic spans 28 focused tables and 316 indexed concepts, 242 flashcards. Below is a complete table-by-table outline of this topic, spanning foundational concepts through advanced details.

Table 1: Value Types and Built-in TypesTable 2: Operators and ExpressionsTable 3: Control Flow and LoopsTable 4: Collections and ArraysTable 5: String Manipulation and FormattingTable 6: Object-Oriented Programming (OOP)Table 7: Properties and IndexersTable 8: Methods, Parameters, and SignaturesTable 9: Delegates, Events, and LambdasTable 10: LINQ (Language Integrated Query)Table 11: Async/Await and Task Parallel LibraryTable 12: Exception HandlingTable 13: GenericsTable 14: Nullable Types and Pattern MatchingTable 15: Memory Management and Resource DisposalTable 16: Type Casting and ConversionTable 17: Attributes and ReflectionTable 18: Access Modifiers and Member ModifiersTable 19: Advanced Type FeaturesTable 20: Iterators and yieldTable 21: Multithreading and SynchronizationTable 22: File I/O and StreamsTable 23: Namespaces and Project OrganizationTable 24: Operator Overloading and EqualityTable 25: Expression-Bodied MembersTable 26: C# Version-Specific FeaturesTable 27: Span<T>, Memory<T>, and High-Performance PatternsTable 28: File-Based Apps (C# 14 / .NET 10)

Quick IndexSubscribe to unlock

A jump-to index of every table row in this cheat sheet.

Mind MapSubscribe to unlock

An interactive map of every table and concept in this topic.

Table 1: Value Types and Built-in Types

These are the primitive building blocks you reach for first — the integers, floating-point numbers, characters, and booleans that map to fixed amounts of memory. The trick is picking the right one: int and double cover most cases, but decimal exists for money where rounding errors are unacceptable, and the size-specific types matter when range or precision is on the line.

Type	Example	Description
int	`int x = 42;`	• 32-bit signed integer • range -2,147,483,648 to 2,147,483,647 • most common integer type.
long	`long y = 9_223_372_036_854_775_807L;`	• 64-bit signed integer • use `L` suffix for literals • for values exceeding int range.
double	`double pi = 3.14159;`	• 64-bit floating-point • default for decimal literals • ~15–17 digits precision.
float	`float f = 3.14f;`	• 32-bit floating-point • requires `f` suffix • ~6–9 digits precision.
decimal	`decimal price = 19.99m;`	• 128-bit high-precision • requires `m` suffix • 28–29 digits precision • ideal for financial calculations.
bool	`bool isValid = true;`	• Boolean type; only `true` or `false` • no implicit conversion from integers.
char	`char c = 'A';`	• Single 16-bit Unicode character • use single quotes • supports escape sequences like `'\n'`.
string	`string name = "Alice";`	• Immutable sequence of Unicode characters • reference type despite behaving like a value type.
byte	`byte b = 255;`	• 8-bit unsigned integer, range 0–255 • commonly used for binary data and byte arrays.
short	`short s = 32_000;`	• 16-bit signed integer, range -32,768 to 32,767 • less common; prefer `int` for general use.
uint / ulong	`uint u = 4_000_000_000u;` `ulong ul = 100uL;`	• Unsigned 32-bit and 64-bit integers • never negative • use `u` / `uL` suffixes.
nint / nuint	`nint p = 42;`	• Platform-native integer size (32-bit on 32-bit process, 64-bit on 64-bit process) • aliases for `IntPtr` / `UIntPtr` • C# 9 feature.
var	`var list = new List<int>();`	• Implicitly-typed local variable • type inferred at compile time • not dynamic typing.
dynamic	`dynamic d = 5;` `d = "text";`	• Type resolved at runtime • bypasses compile-time type checking • use sparingly.

Table 2: Operators and Expressions

Operators are how you combine values into expressions — arithmetic, comparison, and logic alongside C#'s null-handling shortcuts that cut down on defensive code. The ??, ?., and ??= family in particular let you write null-safe logic in a single line instead of nested if checks.

Operator	Example	Description
arithmetic operators	`int sum = a + b;` `int mod = x % 3;`	• Standard `+` `-` `` `/` `%` • integer division truncates* toward zero.

The rest of this section is part of the full cheat sheet

Table 3: Control Flow and Loops

Control flow decides which code runs and how often — branching with if/switch and looping with for, foreach, while, and do-while. Note the modern switch expression here, which returns a value through pattern matching rather than just directing execution like the older statement form.

Statement	Example	Description
if-else	`if (x > 0)` `Console.Write("Pos");` `else` `Console.Write("Neg");`	• Conditional branching • braces optional for single statement but recommended.

The rest of this section is part of the full cheat sheet

Table 4: Collections and Arrays

Choosing the right collection is mostly about access patterns — List<T> for ordered growth, Dictionary and HashSet for fast key lookups, Queue and Stack for FIFO/LIFO ordering. The immutable and frozen variants at the bottom trade flexibility for thread safety and read performance, which matters once a collection is built once and read many times.

Collection	Example	Description
array	`int[] nums = new int[5];` `int[] arr = {1, 2, 3};`	• Fixed-size, zero-indexed • type-safe and fast • length known at initialization.

The rest of this section is part of the full cheat sheet

Table 1: Value Types and Built-in Types

Type	Example	Description
int	`int x = 42;`	• 32-bit signed integer • range -2,147,483,648 to 2,147,483,647 • most common integer type.
long	`long y = 9_223_372_036_854_775_807L;`	• 64-bit signed integer • use `L` suffix for literals • for values exceeding int range.
double	`double pi = 3.14159;`	• 64-bit floating-point • default for decimal literals • ~15–17 digits precision.
float	`float f = 3.14f;`	• 32-bit floating-point • requires `f` suffix • ~6–9 digits precision.
decimal	`decimal price = 19.99m;`	• 128-bit high-precision • requires `m` suffix • 28–29 digits precision • ideal for financial calculations.
bool	`bool isValid = true;`	• Boolean type; only `true` or `false` • no implicit conversion from integers.
char	`char c = 'A';`	• Single 16-bit Unicode character • use single quotes • supports escape sequences like `'\n'`.
string	`string name = "Alice";`	• Immutable sequence of Unicode characters • reference type despite behaving like a value type.
byte	`byte b = 255;`	• 8-bit unsigned integer, range 0–255 • commonly used for binary data and byte arrays.
short	`short s = 32_000;`	• 16-bit signed integer, range -32,768 to 32,767 • less common; prefer `int` for general use.
uint / ulong	`uint u = 4_000_000_000u;` `ulong ul = 100uL;`	• Unsigned 32-bit and 64-bit integers • never negative • use `u` / `uL` suffixes.
nint / nuint	`nint p = 42;`	• Platform-native integer size (32-bit on 32-bit process, 64-bit on 64-bit process) • aliases for `IntPtr` / `UIntPtr` • C# 9 feature.
var	`var list = new List<int>();`	• Implicitly-typed local variable • type inferred at compile time • not dynamic typing.
dynamic	`dynamic d = 5;` `d = "text";`	• Type resolved at runtime • bypasses compile-time type checking • use sparingly.

Table 2: Operators and Expressions

Operator	Example	Description
arithmetic operators	`int sum = a + b;` `int mod = x % 3;`	• Standard `+` `-` `` `/` `%` • integer division truncates* toward zero.

Table 3: Control Flow and Loops

Statement	Example	Description
if-else	`if (x > 0)` `Console.Write("Pos");` `else` `Console.Write("Neg");`	• Conditional branching • braces optional for single statement but recommended.

Table 4: Collections and Arrays

Collection	Example	Description
array	`int[] nums = new int[5];` `int[] arr = {1, 2, 3};`	• Fixed-size, zero-indexed • type-safe and fast • length known at initialization.