C# Enums and Named States: Clear Choices, Safe Input

What you will understand

• Declare an enum and compare values using meaningful names.
• Explain underlying integer codes and stable external representations.
• Recognize zero defaults and unnamed enum values.
• Map states to friendly labels without changing state.
• Separate TryParse success from declared membership and workflow acceptance.
• Implement a strict name-only input policy.
• Guard a lifecycle transition independently of enum membership.
• Test valid names, unsupported input and refused state changes.

Give a small set of choices clear names

An enum is a custom value type containing named constants. Use one when a value comes from a small, meaningful set of choices, such as a loan status. LoanStatus.Available reads more clearly than an unexplained number one and is harder to confuse with an unrelated count.

This lesson models one physical book copy with one lifecycle status at a time. Available means it can be borrowed, Borrowed means it is already on loan, and Retired means it is out of circulation. Unknown represents an uninitialized or unsupported result, not a usable starting state for our BookCopy.

Naming states does not create behavior. An enum declaration does not borrow a book, validate a user form or prevent every invalid runtime value. We will build those boundaries explicitly so you can see which rule comes from the language and which rule belongs to our model.

Read the first example as a typed assignment followed by a comparison. status is a variable, LoanStatus is its type and Available is a named constant. No new object expression is needed to hold this small value.

using System;

class Program
{
    static void Main()
    {
        LoanStatus status = LoanStatus.Available;
        Console.WriteLine(status);
        Console.WriteLine(status == LoanStatus.Available);
    }
}

enum LoanStatus
{
    Unknown = 0,
    Available = 1,
    Borrowed = 2,
    Retired = 3
}

Select Run code to compile and execute this program.

Available
True

using System;

class Program
{
    static void Main()
    {
        LoanStatus status = "Borrowed";
        Console.WriteLine(status);
    }
}

enum LoanStatus
{
    Unknown = 0,
    Available = 1,
    Borrowed = 2,
    Retired = 3
}

Select Run code to compile and execute this program.

Compilation fails: string cannot implicitly convert to LoanStatus.

Understand the numbers without making them the main interface

By default, an enum uses int underneath. Without explicit values, its first member is zero and each following member increases by one. Our declaration writes every value explicitly so the connection between a name and its code is visible.

Casting a declared value to int reveals that code. Casting an integer to the enum goes the other way, but does not automatically check whether a declared member has that code. The value type can hold unnamed underlying values too, which is why later validation matters.

If you save numeric enum values in files or a database, or exchange them through an API, their meaning becomes a compatibility contract. Reordering implicit members can accidentally change stored meanings. Choose stable codes deliberately and avoid reusing a removed code for a different state.

The underlying number is not an ordering rule. Do not write status > Available to decide which transitions are allowed. Explicitly name the allowed source and destination states. Numeric representation and business meaning answer different questions.

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine((int)LoanStatus.Unknown);
        Console.WriteLine((int)LoanStatus.Borrowed);
        Console.WriteLine((int)LoanStatus.Retired);
    }
}

enum LoanStatus
{
    Unknown = 0,
    Available = 1,
    Borrowed = 2,
    Retired = 3
}

Select Run code to compile and execute this program.

0
2
3

using System;

class Program
{
    static void Main()
    {
        LoanStatus status = (LoanStatus)99;
        Console.WriteLine(status);
        Console.WriteLine(Enum.IsDefined(status));
    }
}

enum LoanStatus
{
    Unknown = 0,
    Available = 1,
    Borrowed = 2,
    Retired = 3
}

Select Run code to compile and execute this program.

99
False

The default is always zero, even without a zero member

default(LoanStatus), or default in a typed assignment, produces the zero value. We deliberately name that value Unknown. This makes an uninitialized result readable, but does not mean the workflow should accept it as a real loan state.

The DeliveryStage example begins its declared codes at ten. Its default still has code zero, and Enum.IsDefined reports false. Do not assume the first written name is always the default or that every enum value must correspond to a name.

A meaningful zero member is often useful when the domain has an unknown or none concept. If zero genuinely means an active state, document that decision. Either way, still validate values entering a workflow rather than treating default initialization as proof of an accepted user choice.

Our reader initializes its out result to Unknown on refusal, and callers inspect the Boolean before using it. This prevents a failed parse from silently creating an available book. The model also checks its constructor input as a second boundary.

using System;

class Program
{
    static void Main()
    {
        LoanStatus status = default;
        Console.WriteLine(status);
        Console.WriteLine(Enum.IsDefined(status));
    }
}

enum LoanStatus
{
    Unknown = 0,
    Available = 1,
    Borrowed = 2,
    Retired = 3
}

Select Run code to compile and execute this program.

Unknown
True

using System;

class Program
{
    static void Main()
    {
        DeliveryStage stage = default;
        Console.WriteLine((int)stage);
        Console.WriteLine(Enum.IsDefined(stage));
    }
}

enum DeliveryStage
{
    Packed = 10,
    Shipped = 20
}

Select Run code to compile and execute this program.

0
False

Use named comparisons and deliberate display mapping

Compare an enum with its named constants, as in status == LoanStatus.Available. A switch can map technical state names to friendly wording. This keeps display text separate from the names used in the program.

The reporting switch has a fallback because Unknown and unnamed values are possible. It returns Unsupported status for those values instead of pretending they are a valid active state. A production boundary might reject the value earlier, but display code should not accidentally crash or mislabel it.

A friendly label is not a transition rule. Currently on loan tells the reader what the state means, while TryBorrow decides whether an operation may change it. Separating reporting from mutation keeps repeated reads from changing the model.

An ordinary loan lifecycle is one choice at a time. Do not combine Available and Borrowed using bitwise operators. Flags enums are a different design for independent options that may coexist; they require deliberate power-of-two values and different validation policies, so this lesson keeps the lifecycle non-flags.

using System;

class Program
{
    static void Main()
    {
        LoanStatus[] statuses = { LoanStatus.Available, LoanStatus.Borrowed, LoanStatus.Retired, (LoanStatus)99 };
        foreach (LoanStatus status in statuses)
        {
            string label = status switch
            {
                LoanStatus.Available => "Ready to borrow",
                LoanStatus.Borrowed => "Currently on loan",
                LoanStatus.Retired => "Removed from circulation",
                _ => "Unsupported status"
            };
            Console.WriteLine(label);
        }
    }
}

enum LoanStatus
{
    Unknown = 0,
    Available = 1,
    Borrowed = 2,
    Retired = 3
}

Select Run code to compile and execute this program.

Ready to borrow
Currently on loan
Removed from circulation
Unsupported status

Conversion success is only the first check

External input arrives as text or a number, not as an automatically trusted state. Enum.TryParse<LoanStatus> attempts to convert text and reports conversion success through a Boolean. The angle brackets specify which enum type is being parsed; you do not need to write a generic class to use this library method.

With ignoreCase: true, borrowed can match Borrowed. But TryParse also accepts numeric strings, so 99 can convert successfully even though no member has that value. After conversion, Enum.IsDefined checks whether the value is one of the declared constants.

Membership is still not the whole workflow. Unknown is declared but is not accepted by our BookCopy constructor. A numeric-capable boundary therefore checks conversion, defined membership and its additional allowed-state policy. Always check the Boolean before treating the out result as accepted input.

TryParse can also interpret comma-separated enum names. That syntax can combine underlying values, even for an enum not marked Flags. For a name-only user field, conversion plus IsDefined may therefore be too permissive. Define the text format you actually accept rather than assuming the parsing helper implements the entire field policy.

using System;

class Program
{
    static void Main()
    {
        string[] inputs = { "borrowed", "99", "not-a-status" };
        foreach (string input in inputs)
        {
            bool parsed = Enum.TryParse<LoanStatus>(input, ignoreCase: true, out LoanStatus status);
            bool defined = parsed && Enum.IsDefined(status);
            Console.WriteLine($"{input}: parsed={parsed}, defined={defined}");
        }
    }
}

enum LoanStatus
{
    Unknown = 0,
    Available = 1,
    Borrowed = 2,
    Retired = 3
}

Select Run code to compile and execute this program.

borrowed: parsed=True, defined=True
99: parsed=True, defined=False
not-a-status: parsed=False, defined=False

Make a name-only boundary explicit

Our final input field accepts exactly Available, Borrowed or Retired after trimming outside spaces, ignoring case. It rejects numeric strings, comma-separated names, Unknown, empty input and arbitrary words. This is a deliberate product rule, not a universal restriction on every enum parser.

TryReadStatus uses an explicit allowlist of those names. It assigns the corresponding enum only when one accepted word matches. Otherwise it returns false and leaves status as Unknown. The reader does not create a BookCopy, so refusal has no hidden state-changing side effect.

StringComparison.OrdinalIgnoreCase gives these technical input tokens a consistent case-insensitive comparison rather than depending on a user culture. Display labels can still be translated separately. If a public API promises stable numeric codes instead, write and test that different boundary explicitly.

Notice why the repair and lab use different acceptance policies. The guided repair fixes a numeric-capable parser that should reject unsupported codes. The lab implements a stricter name-only reader. Both separate conversion from application policy, but they should not claim to accept the same input language.

using System;

class Program
{
    static void Main()
    {
        string[] inputs = { " borrowed ", "2", "Unknown", "Available, Borrowed", "Retired" };
        foreach (string input in inputs)
        {
            bool accepted = TryReadStatus(input, out LoanStatus status);
            Console.WriteLine($"{input.Trim()}: {accepted}, {status}");
        }
    }

    static bool TryReadStatus(string? input, out LoanStatus status)
    {
        status = LoanStatus.Unknown;
        if (string.IsNullOrWhiteSpace(input))
        {
            return false;
        }
        string text = input.Trim();
        if (text.Equals("Available", StringComparison.OrdinalIgnoreCase))
        {
            status = LoanStatus.Available;
            return true;
        }
        if (text.Equals("Borrowed", StringComparison.OrdinalIgnoreCase))
        {
            status = LoanStatus.Borrowed;
            return true;
        }
        if (text.Equals("Retired", StringComparison.OrdinalIgnoreCase))
        {
            status = LoanStatus.Retired;
            return true;
        }
        return false;
    }
}

enum LoanStatus
{
    Unknown = 0,
    Available = 1,
    Borrowed = 2,
    Retired = 3
}

Select Run code to compile and execute this program.

borrowed: True, Borrowed
2: False, Unknown
Unknown: False, Unknown
Available, Borrowed: False, Unknown
Retired: True, Retired

A declared status does not automatically allow an action

BookCopy accepts only defined non-Unknown initial states. Available, Borrowed and Retired may each describe an existing copy, but only Available permits a new borrow operation. A defined destination name does not mean every source may move to it.

TryBorrow checks current Status before writing it. An accepted request moves Available to Borrowed and returns true. A second request returns false and leaves Borrowed unchanged. A retired copy likewise refuses borrowing without changing its status.

The public getter and private setter prevent a caller from directly assigning arbitrary state through the supported interface. The constructor and methods must still preserve their own rules. An enum alone cannot enforce this lifecycle because code can manufacture unnamed values with casts.

The example keeps only the borrow transition so the responsibility stays easy to inspect. A complete library workflow might add returns, retirement policies and persistence. Those would require explicit transitions and validation rather than simply adding more enum names.

using System;

class Program
{
    static void Main()
    {
        BookCopy copy = new BookCopy(LoanStatus.Available);
        Console.WriteLine(copy.TryBorrow());
        Console.WriteLine(copy.Status);
        Console.WriteLine(copy.TryBorrow());
        Console.WriteLine(copy.Status);
    }
}

enum LoanStatus
{
    Unknown = 0,
    Available = 1,
    Borrowed = 2,
    Retired = 3
}

class BookCopy
{
    public LoanStatus Status { get; private set; }

    public BookCopy(LoanStatus status)
    {
        if (!Enum.IsDefined(status) || status == LoanStatus.Unknown)
        {
            throw new ArgumentOutOfRangeException(nameof(status));
        }
        Status = status;
    }

    public bool TryBorrow()
    {
        if (Status != LoanStatus.Available)
        {
            return false;
        }
        Status = LoanStatus.Borrowed;
        return true;
    }
}

Select Run code to compile and execute this program.

True
Borrowed
False
Borrowed

Test representation, input policy and transitions separately

Check three different layers. First, confirm the named codes and zero behavior. Second, test the boundary that accepts external input. Third, verify allowed and refused state changes. A passing name comparison alone cannot prove all three layers.

For the name-only reader, test every allowed word, mixed case, outside spaces, numbers such as 2 and 99, comma-separated names, Unknown, null and blank input. Successful results must return the right enum; refused results must not create a copy or silently choose Available.

For the model, test Available borrowing successfully, Borrowed and Retired refusing, and a second borrow leaving the state unchanged. Reject Unknown and cast values such as (LoanStatus)99 during construction. The expected operation result and the final state are both part of the check.

Every editor is a standalone local program using source values you can edit. The final lab stores state only in memory; it does not save a library record or reserve stock across users. The next lesson introduces text-file persistence, where external values still need this kind of deliberate validation.

Guided repair: validate beyond parsing

The numeric-capable parser accepts 99 because it equates TryParse success with valid status. Reject undefined codes and Unknown, and do not apply a refused result.

using System;

class Program
{
    static void Main()
    {
        bool accepted = Enum.TryParse<LoanStatus>("99", out LoanStatus status);
        Console.WriteLine($"Accepted: {accepted}");
        Console.WriteLine($"Status: {status}");
    }
}

enum LoanStatus
{
    Unknown = 0,
    Available = 1,
    Borrowed = 2,
    Retired = 3
}

Select Run code to compile and execute this program.

Accepted: True
Status: 99

Repair checkpoints

1. Keep conversion as the first check.
2. Require Enum.IsDefined(status) after successful parsing.
3. Also reject LoanStatus.Unknown under this workflow.
4. Only use the parsed status inside the accepted branch.
5. Keep this numeric-capable policy distinct from the stricter name-only lab.

using System;

class Program
{
    static void Main()
    {
        bool parsed = Enum.TryParse<LoanStatus>("99", ignoreCase: true, out LoanStatus status);
        bool accepted = parsed && Enum.IsDefined(status) && status != LoanStatus.Unknown;
        Console.WriteLine($"Accepted: {accepted}");
        if (accepted)
        {
            Console.WriteLine($"Status: {status}");
        }
        else
        {
            Console.WriteLine("No status applied");
        }
    }
}

enum LoanStatus
{
    Unknown = 0,
    Available = 1,
    Borrowed = 2,
    Retired = 3
}

Select Run code to compile and execute this program.

Accepted: False
No status applied

Independent lab: a name-only reader and a guarded loan

Complete a name-only status reader, then create and borrow a copy only after input is accepted. Keep parsing policy and lifecycle enforcement in their separate functions.

Acceptance checklist

• Accept only Available, Borrowed and Retired names, case-insensitively after trimming.
• Reject numeric strings, combined names, Unknown, blank and null input.
• Leave the out value Unknown on refusal and return false.
• Create BookCopy only in the accepted branch.
• Preserve constructor rejection of undefined and Unknown values.
• Preserve TryBorrow accepting only Available and moving it to Borrowed.
• For the reference input, print Start: Available, Borrow accepted: True and After: Borrowed.

using System;

class Program
{
    static void Main()
    {
        string input = " available ";
        if (TryReadStatus(input, out LoanStatus status))
        {
            BookCopy copy = new BookCopy(status);
            Console.WriteLine($"Start: {copy.Status}");
            Console.WriteLine($"Borrow accepted: {copy.TryBorrow()}");
            Console.WriteLine($"After: {copy.Status}");
        }
        else
        {
            Console.WriteLine("Unsupported status; no copy created");
        }
    }

    static bool TryReadStatus(string? input, out LoanStatus status)
    {
        // TODO: accept only Available, Borrowed or Retired names, case-insensitively.
        status = LoanStatus.Unknown;
        return false;
    }
}

enum LoanStatus
{
    Unknown = 0,
    Available = 1,
    Borrowed = 2,
    Retired = 3
}

class BookCopy
{
    public LoanStatus Status { get; private set; }

    public BookCopy(LoanStatus status)
    {
        if (!Enum.IsDefined(status) || status == LoanStatus.Unknown)
        {
            throw new ArgumentOutOfRangeException(nameof(status));
        }
        Status = status;
    }

    public bool TryBorrow()
    {
        if (Status != LoanStatus.Available)
        {
            return false;
        }
        Status = LoanStatus.Borrowed;
        return true;
    }
}

Select Run code to compile and execute this program.

Unsupported status; no copy created

using System;

class Program
{
    static void Main()
    {
        string input = " available ";
        if (TryReadStatus(input, out LoanStatus status))
        {
            BookCopy copy = new BookCopy(status);
            Console.WriteLine($"Start: {copy.Status}");
            Console.WriteLine($"Borrow accepted: {copy.TryBorrow()}");
            Console.WriteLine($"After: {copy.Status}");
        }
        else
        {
            Console.WriteLine("Unsupported status; no copy created");
        }
    }

    static bool TryReadStatus(string? input, out LoanStatus status)
    {
        status = LoanStatus.Unknown;
        if (string.IsNullOrWhiteSpace(input))
        {
            return false;
        }
        string text = input.Trim();
        if (text.Equals("Available", StringComparison.OrdinalIgnoreCase))
        {
            status = LoanStatus.Available;
            return true;
        }
        if (text.Equals("Borrowed", StringComparison.OrdinalIgnoreCase))
        {
            status = LoanStatus.Borrowed;
            return true;
        }
        if (text.Equals("Retired", StringComparison.OrdinalIgnoreCase))
        {
            status = LoanStatus.Retired;
            return true;
        }
        return false;
    }
}

enum LoanStatus
{
    Unknown = 0,
    Available = 1,
    Borrowed = 2,
    Retired = 3
}

class BookCopy
{
    public LoanStatus Status { get; private set; }

    public BookCopy(LoanStatus status)
    {
        if (!Enum.IsDefined(status) || status == LoanStatus.Unknown)
        {
            throw new ArgumentOutOfRangeException(nameof(status));
        }
        Status = status;
    }

    public bool TryBorrow()
    {
        if (Status != LoanStatus.Available)
        {
            return false;
        }
        Status = LoanStatus.Borrowed;
        return true;
    }
}

Select Run code to compile and execute this program.

Start: Available
Borrow accepted: True
After: Borrowed

Changed-input checks

• Mixed-case available with outside spaces is accepted and can be borrowed.
• Borrowed and Retired names are accepted input but their copies refuse borrowing.
• 2, 99 and Available, Borrowed are refused by the name-only reader.
• Unknown, an empty string, whitespace and null are refused.
• A second borrow is refused and leaves Borrowed unchanged.
• Constructor input Unknown or (LoanStatus)99 is rejected for status.

Recap: representation, input policy and behavior

Identify the code, its declared name, the accepted input format and the transitions the model permits.

enum LoanStatus

Declare a custom value type with named constants.

LoanStatus.Available

Use a meaningful named value rather than a magic number.

(int)status

Inspect the underlying numeric code.

(LoanStatus)99

Convert representation without proving declared membership.

default

Produce zero, whether or not that code has a name.

Enum.TryParse

Attempt name or numeric conversion; success is not full validation.

Enum.IsDefined

Check declared membership, not every workflow or textual-input rule.

guarded transition

Apply an action only from an allowed current state.

Frequently asked questions

Next step and references

Enums clarify a small set of choices, but casts and parsing can still produce unsupported values. Validate input policy explicitly, then let the model enforce allowed state changes.

Next is C# Read and Write Text Files. You will persist small text data deliberately, distinguish replacing from appending and handle paths and missing files.

Official references

Original SovranCode explanations, examples and exercises. Technical details were checked against these references.

• Microsoft Learn: Enumeration types and numeric representation
• Microsoft Learn: Enum.TryParse conversion behavior

Last updated: 27 October 2026.