What is the difference between an enum, a struct and a class?

Question

Accepted Answer

These are three distinct kinds of types in C#: **enum** (a named set of constant values), **struct** (a value type for small data), and **class** (a reference type for objects). Choosing correctly depends on the data and behavior you're modeling.

## enum — a named set of constants

```csharp
public enum Status { Active, Inactive, Pending }   // named constants (Active=0, ...)

Status s = Status.Active;
if (s == Status.Active) { }                         // type-safe constants

public enum Permissions { Read = 1, Write = 2, Execute = 4 }   // [Flags] for bit flags
```

An **enum** defines a fixed set of named values — type-safe constants for things like states, roles, or options (replacing magic numbers/strings). It's a value type backed by an integer.

## struct — a value type for small data

```csharp
public struct Point          // VALUE type — copied by value, no heap allocation
{
    public int X { get; }
    public int Y { get; }
    public Point(int x, int y) { X = x; Y = y; }
}
Point p1 = new(1, 2);
Point p2 = p1;               // COPIES the whole struct (independent)
```

A **struct** is a value type — stored inline (often on the stack), copied by value, no heap allocation. Best for **small, immutable, data-like** values (coordinates, money, a date) where value semantics and avoiding heap allocation help performance.

## class — a reference type for objects

```csharp
public class User            // REFERENCE type — on the heap, copied by reference
{
    public string Name { get; set; }
    public void DoWork() { }   // rich behavior
}
User u1 = new() { Name = "Ann" };
User u2 = u1;                // both reference the SAME object
```

A **class** is a reference type — on the heap, copied by reference (shared), supports inheritance and rich behavior. The default choice for most objects with identity, behavior, and mutable state.

## When to use which

```text
enum   → a fixed set of named constants (states, roles, options)
struct → small, immutable data values; value semantics; avoid heap allocation
         (keep small — large structs are costly to copy)
class  → most objects: identity, behavior, inheritance, mutable/larger state (the default)
```

## Why it matters

Choosing the right kind of type — enum, struct, or class — is a fundamental C# design decision affecting correctness, semantics, and performance, so understanding the differences is important. **Enums** provide type-safe named constants (for states, roles, options), far better than error-prone magic numbers or strings — a common, valuable modeling tool.

The **struct vs class** distinction is especially significant because it determines **value vs reference semantics**: structs are value types (copied by value, stored inline, no heap allocation) suited to small immutable data values where value semantics and reduced allocation help performance, while classes are reference types (shared by reference, heap-allocated, supporting inheritance and rich behavior) — the default for most objects with identity and behavior.

Choosing wrong has real consequences: a large struct is costly to copy, and using a struct where reference semantics are expected (or vice versa) causes subtle bugs.

Understanding when to use each — enum for fixed constant sets, struct for small data-like values (kept small), class for most objects (the default) — and the value-vs-reference implications is important knowledge for modeling data correctly and performantly in C#.

Since this choice appears whenever you define a type, and since the value/reference distinction underlies so much C# behavior, knowing the differences and appropriate use of enums, structs, and classes is core, frequently-relevant knowledge and a common interview topic reflecting understanding of C#'s type system.