Data Types

Value Types vs Reference Types

C#'s types fall into two fundamental categories, and understanding this distinction deeply will save you from a whole class of confusing bugs later. Value types (like int, double, bool, and structs) store their actual data directly wherever the variable lives, and are copied by value — copying one creates a completely independent duplicate. Reference types (like string, arrays, and classes) store only a reference (essentially a memory address) to data that actually lives elsewhere on the heap, and are copied by reference — copying one just copies the address, so both variables point at the exact same underlying data.

// Value type — copying creates an independent copy
int a = 10;
int b = a; // b is a separate copy
b = 20;
Console.WriteLine(a); // 10 — unaffected by changing b

// Reference type — copying shares the same object
int[] arr1 = { 1, 2, 3 };
int[] arr2 = arr1; // arr2 points to the SAME array
arr2[0] = 99;
Console.WriteLine(arr1[0]); // 99 — arr1 sees the change too, since they're the same array!

Stack vs Heap: A Closer Look

The stack is a small, extremely fast region of memory that stores value types and manages method call frames — it grows and shrinks automatically as methods are called and return, in strict last-in-first-out order. The heap is a much larger pool of memory where reference type data actually lives, managed by the garbage collector, which periodically reclaims memory for objects nothing references anymore.

Full Integer Type Range

C# offers several integer sizes, each trading off memory usage against the range of values it can hold — useful to know when working with anything memory-sensitive, or interfacing with external data formats that specify an exact byte width.

int population = 8_000_000_000;   // digit separators (_) improve readability — 8 billion
long fileSizeInBytes = 5_000_000_000L; // 'L' suffix marks this as a long literal
byte redChannel = 255;             // a single color channel, 0-255

Floating-Point Types

double d = 0.1 + 0.2;
Console.WriteLine(d); // 0.30000000000000004 — NOT exactly 0.3!

decimal dec = 0.1m + 0.2m;
Console.WriteLine(dec); // 0.3 — exact, as expected

bool and char

bool holds exactly two values, true or false, and is what every conditional statement (covered in an upcoming lesson) ultimately evaluates. char holds a single Unicode character — not just basic English letters, but characters from virtually any writing system in the world.

bool isLoggedIn = true;
char grade = 'A';
char currencySymbol = '€';
char emoji = '🙂'; // Note: some emoji actually need two chars (a "surrogate pair") — covered as an edge case below

string

Despite being a reference type, `string` in C# behaves as immutable — once created, its value never changes for the entire lifetime of that string object. Any operation that appears to "modify" a string (like concatenation) actually creates and returns an entirely new string, leaving the original untouched.

string greeting = "Hello";
string name = "World";
string message = $"{greeting}, {name}!";
Console.WriteLine(message);

string original = "cat";
string upper = original.ToUpper();
Console.WriteLine(original); // "cat" — unchanged!
Console.WriteLine(upper);    // "CAT" — a brand new string

String Interning

.NET automatically "interns" string literals — identical literal strings across your entire program are stored only once in memory and share the same reference, purely as a memory optimization, since strings are so common and often repeated.

string a = "hello";
string b = "hello";
Console.WriteLine(object.ReferenceEquals(a, b)); // True — both literals point to the SAME interned string

Checking a Value's Type

The GetType() method (available on every value, since all C# types ultimately derive from object) reports a variable's exact runtime type — useful for debugging or logging.

int x = 42;
Console.WriteLine(x.GetType()); // System.Int32 — "int" is just a shorter alias for this
Console.WriteLine(x.GetType().Name); // Int32

Common Beginner Mistakes

FAQs

Key Takeaways

Summary

Understanding value versus reference semantics deeply — not just memorizing which types are which — will pay off throughout the rest of this course, especially once you reach classes, objects, and collections. Next, you'll learn how to convert between these different types safely.