Data Types

You already met a handful of types in the Variables lesson. Now we'll go deeper: the full family of numeric types, how text and booleans are stored, the all-important difference between value types and reference types , and how to pick the right type every single time. Choosing well here prevents whole categories of bugs later.

Learn Data Types in our free C# course — a beginner-friendly interactive lesson with worked examples, a practice exercise and a quick recall.

Part of the free C# course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

What You'll Learn

💡 Real-World Analogy

Think of data types as shipping boxes of different sizes . A tiny jewellery box ( byte ) is cheap but only fits something small (0–255). A standard parcel box ( int ) fits almost anything you'll ship day to day. A freight crate ( long ) is for the rare huge item. You could ship a ring in a freight crate, but it wastes space — and you can't cram a fridge into a jewellery box. Picking the right-sized box for the job is exactly what choosing a type is.

1. The Numeric Types

C# splits numbers into integers (no decimal point) and real numbers (with a decimal point). Within each group there are several sizes, trading memory for range or precision. You'll use int for nearly all whole numbers, double for general decimals, and decimal for money. Run the example and watch how the suffixes change the type.

📊 Numeric Type Cheat Sheet

Type

Size

Range / Precision

Use for

byte

1 byte

0 to 255

Raw bytes, colour channels

short

2 bytes

±32,767

Memory-tight small numbers

int

4 bytes

±2.1 billion

The default whole number

long

8 bytes

±9.2 quintillion

IDs, file sizes, ticks

float

~7 digits

Graphics, games (speed)

double

~15 digits

Science, averages

decimal

16 bytes

~28 digits, exact

Money & finance

2. Text (char, string) and bool

A char holds exactly one character in 'single quotes' ; a string holds any amount of text in "double quotes" . A bool is the simplest type of all — it is only ever true or false . One neat detail: a char is really just a number under the hood (its Unicode code point), which is why it can implicitly become an int .

Your turn. For each variable below, replace the ___ with the correct type keyword. The comments tell you the answer if you get stuck — but try first.

3. Value Types vs Reference Types

This is the single most important idea in the lesson. Value types (all the numbers, bool , char , and struct s) store their data directly — copying one makes an independent copy. Reference types ( string , arrays, and every class ) store a reference that points to the real data elsewhere, so copying the variable just copies the pointer, and both variables can see the same object. Misunderstanding this causes "why did my other variable change?!" bugs.

🔎 Deep Dive: defaults, limits, and overflow

Every type has a default value used when a field isn't assigned: 0 for numbers, false for bool , and null for reference types. You can read it with default(int) . Each numeric type also exposes its limits via int.MinValue and int.MaxValue .

Push a value past int.MaxValue and it silently overflows (wraps to a negative number) by default. Wrap arithmetic in a checked { ... } block to make overflow throw an exception instead of failing silently.

🧩 Reorder Challenge

These five lines were shuffled. Put them in the order that compiles and prints Total: £40.00 . Think about what must exist before it can be used.

Why: a variable must be declared before it is read. total depends on both qty and unitPrice , so those two must come first. The WriteLine uses total , so it must come last. Note int * decimal safely promotes to decimal , which is why the multiplication is allowed.

🧠 Quick Recall

65 — a char implicitly converts to its Unicode code point, and 'A' is 65.

5 20 — int is a value type, so y got an independent copy. Changing y never touches x .

False then 0 — the default for bool is false and for int is 0 .

Pro Tips

• 💡 Default to int for whole numbers and double for decimals unless you have a specific reason to change.
• 💡 Always decimal for money. Never store currency in double — binary rounding will lose pennies.
• 💡 Use underscores in big literals: 1_000_000 is far easier to read than 1000000 .
• 💡 Remember: string is immutable. Methods like Trim() return a new string; they never change the original.

Common Errors (and the fix)

• "CS0266: Cannot implicitly convert 'long' to 'int'": the value is too big for int . Use long , or cast if you're certain it fits.
• Assigning 19.99 to a decimal: a bare decimal literal is a double . You must write 19.99m .
• Surprised by overflow: byte b = 256; won't even compile, but byte b = (byte)256; wraps to 0 . Pick a bigger type.
• Mutating a shared array by accident: two variables pointing to one array means a change through one is visible through the other — clone with (int[])arr.Clone() if you need a separate copy.

Frequently Asked Questions

Mini-Challenge: Product Line

Model a product using the right type for every field. The outline is in the comments — declare the variables, compute inStock from stockCount , and print the two-line summary.

🎉 Lesson Complete

• ✅ Integers come in sizes: byte , short , int , long — default to int
• ✅ Real numbers: float , double (general) and decimal (money, exact)
• ✅ char is one character; string is text; bool is true/false
• ✅ Value types copy data; reference types copy a pointer to shared data
• ✅ Every type has a default , and numeric types expose MinValue / MaxValue
• ✅ Next lesson: Type Casting — convert between types and understand boxing/unboxing

Practice quiz

Continue this course

• Previous: Variables
• Next: Type Casting (& Boxing/Unboxing)