C# Object-Oriented Thinking: State, Behavior, and Responsibility

What you will understand

• Describe an object’s responsibility in one clear sentence.
• Distinguish a class definition from one object instance.
• Identify state, behavior and the caller’s coordination role.
• Explain separate instances versus two references to one instance.
• Trace accepted and refused borrowing transitions.
• Keep a state rule behind a private field and public operations.
• Recognize accidental static state in an instance model.
• Test both operation results and resulting state.

Start with a responsibility, not a list of objects

Object-oriented programming groups related state and behavior into objects. State is what an object currently knows or remembers. Behavior is what it can do, including operations that change that state according to a rule. The goal is to make a program easier to reason about, not to turn every noun into a class.

Our example models the borrowing status of one physical library copy. Its state answers whether that copy is borrowed. Its behavior accepts a borrow request only while available and accepts a return only while borrowed. We leave readers, due dates, fines and a database out of this first model so its responsibility stays small.

A short script with one title and one Boolean can be perfectly reasonable. A class becomes useful when several copies need the same rules and each copy needs its own state. Before reading the code, write the sentence: this object represents one copy and controls its borrowing status. That sentence helps decide which data and operations belong together.

using System;

class Program
{
    static void Main()
    {
        string title = "River Maps";
        bool borrowed = false;
        Console.WriteLine($"{title}: {borrowed}");
    }
}

Select Run code to compile and execute this program.

River Maps: False

A class is a definition; an object is one instance

A class defines a custom type. It describes members that its objects can have, such as stored fields and methods. Declaring class BookLoan does not create a borrowed copy by itself. new BookLoan() creates an object using that definition, and a variable of class type holds a reference to the object.

In the first example, Title is a string field and Borrowed is a Boolean field. loan.Title uses dot notation to select the Title member on the object referenced by loan. The initial values are written in the class so the example starts with a visible title and an available copy.

The public fields are a short stepping stone, not the final design. They let a caller write state freely. We will shortly keep the borrowed flag private and expose meaningful operations. Constructors and properties are introduced in later lessons; for now, focus on the difference between defining a type and creating an instance. Each editor contains its own complete program.

using System;

class Program
{
    static void Main()
    {
        BookLoan loan = new BookLoan();
        loan.Title = "River Maps";
        Console.WriteLine($"{loan.Title}: {loan.Borrowed}");
    }
}

class BookLoan
{
    public string Title = "Untitled";
    public bool Borrowed = false;
}

Select Run code to compile and execute this program.

River Maps: False

Separate objects have separate instance state

Two new BookLoan() expressions create two distinct objects. They use the same class definition, but each has its own instance fields. Borrowing one physical copy should not mark a different copy as borrowed. Even two copies with equal titles can still be different objects with different availability.

A variable name is not an object identity. BookLoan same = first creates another reference to the existing object; it does not create a second object. A change through same is therefore visible through first. Think of two labels pointing to one box rather than two boxes holding duplicated contents.

This reference behavior follows the array lesson: copying a reference does not clone the referenced data. The example uses object.ReferenceEquals to check identity directly. A real catalog might also assign stable copy identifiers, but a title or a local variable name is not a substitute for that identifier.

using System;

class Program
{
    static void Main()
    {
        BookLoan first = new BookLoan();
        first.Title = "River Maps";
        BookLoan second = new BookLoan();
        second.Title = "Night Trains";
        first.Borrowed = true;
        Console.WriteLine($"{first.Title}: {first.Borrowed}");
        Console.WriteLine($"{second.Title}: {second.Borrowed}");
    }
}

class BookLoan
{
    public string Title = "Untitled";
    public bool Borrowed = false;
}

Select Run code to compile and execute this program.

River Maps: True
Night Trains: False

using System;

class Program
{
    static void Main()
    {
        BookLoan first = new BookLoan();
        first.Title = "River Maps";
        BookLoan same = first;
        same.Borrowed = true;
        Console.WriteLine(first.Borrowed);
        Console.WriteLine(object.ReferenceEquals(first, same));
    }
}

class BookLoan
{
    public string Title = "Untitled";
    public bool Borrowed = false;
}

Select Run code to compile and execute this program.

True
True

Put a rule beside the state it controls

An instance method operates on a particular receiving object. In loan.TryBorrow(), loan identifies that receiver. Inside the method, borrowed refers to that object’s field. Two BookLoan objects can use exactly the same method definition while getting different answers from their own current states.

TryBorrow first checks whether the copy is already borrowed. If it is, the method returns false without a change. Otherwise it sets borrowed to true and returns true. Read that result as request accepted, not as the current state. The separate IsBorrowed method answers the state question.

The word Try is a naming convention that signals an operation may refuse an ordinary request and report success with a Boolean. It is not a special keyword. We use it to make the contract understandable at the call site. Do not use the returned false as an instruction to reset the flag: a refused duplicate borrow must leave the copy borrowed.

using System;

class Program
{
    static void Main()
    {
        BookLoan loan = new BookLoan();
        loan.Title = "River Maps";
        Console.WriteLine($"Accepted: {loan.TryBorrow()}");
        Console.WriteLine($"Borrowed: {loan.IsBorrowed()}");
    }
}

class BookLoan
{
    public string Title = "Untitled";
    private bool borrowed = false;

    public bool TryBorrow()
    {
        if (borrowed)
        {
            return false;
        }
        borrowed = true;
        return true;
    }

    public bool IsBorrowed()
    {
        return borrowed;
    }
}

Select Run code to compile and execute this program.

Accepted: True
Borrowed: True

using System;

class Program
{
    static void Main()
    {
        BookLoan loan = new BookLoan();
        Console.WriteLine($"First request: {loan.TryBorrow()}");
        Console.WriteLine($"Second request: {loan.TryBorrow()}");
        Console.WriteLine($"Still borrowed: {loan.IsBorrowed()}");
    }
}

class BookLoan
{
    public string Title = "Untitled";
    private bool borrowed = false;

    public bool TryBorrow()
    {
        if (borrowed)
        {
            return false;
        }
        borrowed = true;
        return true;
    }

    public bool IsBorrowed()
    {
        return borrowed;
    }
}

Select Run code to compile and execute this program.

First request: True
Second request: False
Still borrowed: True

Protect the transition instead of exposing a flag

Encapsulation means presenting a useful boundary around related data and behavior. Here the caller asks for TryBorrow or TryReturn rather than assigning the availability flag directly. The private borrowed field can be accessed by BookLoan’s implementation, while the public methods are the supported operations used by Main.

The state diagram has two states: available → borrowed through an accepted borrow, and borrowed → available through an accepted return. Borrowing an already borrowed copy or returning an available copy is refused and leaves state unchanged. A good model explains these invalid transitions as clearly as the successful ones.

Private access makes accidental external writes a compiler error, as one intentional example demonstrates. It does not provide user authentication, durable storage or atomic protection between concurrent web requests. Title remains a simple public field in this introduction; the protected rule is specifically the borrowing flag. Later lessons build stronger initialization and property boundaries.

using System;

class Program
{
    static void Main()
    {
        BookLoan loan = new BookLoan();
        Console.WriteLine($"Return before borrowing: {loan.TryReturn()}");
        Console.WriteLine($"Borrow: {loan.TryBorrow()}");
        Console.WriteLine($"Return: {loan.TryReturn()}");
        Console.WriteLine($"Borrowed afterward: {loan.IsBorrowed()}");
    }
}

class BookLoan
{
    public string Title = "Untitled";
    private bool borrowed = false;

    public bool TryBorrow()
    {
        if (borrowed)
        {
            return false;
        }
        borrowed = true;
        return true;
    }

    public bool IsBorrowed()
    {
        return borrowed;
    }

    public bool TryReturn()
    {
        if (!borrowed)
        {
            return false;
        }
        borrowed = false;
        return true;
    }
}

Select Run code to compile and execute this program.

Return before borrowing: False
Borrow: True
Return: True
Borrowed afterward: False

using System;

class Program
{
    static void Main()
    {
        BookLoan loan = new BookLoan();
        loan.borrowed = true;
    }
}

class BookLoan
{
    public string Title = "Untitled";
    private bool borrowed = false;

    public bool TryBorrow()
    {
        if (borrowed)
        {
            return false;
        }
        borrowed = true;
        return true;
    }

    public bool IsBorrowed()
    {
        return borrowed;
    }
}

Select Run code to compile and execute this program.

Compilation fails: BookLoan.borrowed is inaccessible due to its protection level.

Let the model enforce rules and the caller present results

Main coordinates the small program: it creates objects, sends requests and prints a report. BookLoan manages its own borrowing rule and answers a state query. Keeping Console.WriteLine outside the class lets the same operation be used by a different presentation without rewriting its rule.

A report can inspect an array of BookLoan references and print each object’s current status. The array groups the objects; it does not turn their fields into shared state. Formatting the report should not borrow or return anything as a hidden side effect.

You do not need inheritance or a framework to start thinking in objects. Abstraction here means exposing the useful question and operations while keeping the flag’s representation behind the boundary. Inheritance and polymorphism are later tools for suitable relationships, not requirements for every class. A pure arithmetic helper can also remain a static method when it has no instance state to manage.

using System;

class Program
{
    static void Main()
    {
        BookLoan first = new BookLoan();
        first.Title = "River Maps";
        BookLoan second = new BookLoan();
        second.Title = "Night Trains";
        first.TryBorrow();
        BookLoan[] loans = { first, second };
        foreach (BookLoan loan in loans)
        {
            string state = loan.IsBorrowed() ? "borrowed" : "available";
            Console.WriteLine($"{loan.Title}: {state}");
        }
    }
}

class BookLoan
{
    public string Title = "Untitled";
    private bool borrowed = false;

    public bool TryBorrow()
    {
        if (borrowed)
        {
            return false;
        }
        borrowed = true;
        return true;
    }

    public bool IsBorrowed()
    {
        return borrowed;
    }
}

Select Run code to compile and execute this program.

River Maps: borrowed
Night Trains: available

Test the object’s story, including refused actions

Write the expected story before running code: a new copy is available; the first borrow succeeds; a repeated borrow fails; the return succeeds; a repeated return fails. Check both the operation’s Boolean result and the state afterward. A correct message alone cannot prove that the underlying state changed properly.

Then create two independent objects and borrow only one. If both become borrowed, inspect whether a field was accidentally declared static or whether both variables refer to the same object. Those are different causes: shared type state and shared object identity. The repair below deliberately demonstrates the static-field mistake.

This model is intentionally small and temporary. It has no saved reader account, inventory database, due date, network request or thread coordination. Restarting an editor run creates fresh objects. A useful next design question is what extra responsibility you would introduce and where it belongs, rather than adding unrelated fields to BookLoan without a rule.

Guided repair: keep each copy independent

Two distinct new BookLoan objects both report borrowed after borrowing only the first. Find why per-copy state became shared, then fix it without changing static Main or exposing the flag publicly.

using System;

class Program
{
    static void Main()
    {
        BookLoan first = new BookLoan();
        BookLoan second = new BookLoan();
        first.TryBorrow();
        Console.WriteLine($"First: {first.IsBorrowed()}");
        Console.WriteLine($"Second: {second.IsBorrowed()}");
    }
}

class BookLoan
{
    public string Title = "Untitled";
    private static bool borrowed = false;

    public bool TryBorrow()
    {
        if (borrowed)
        {
            return false;
        }
        borrowed = true;
        return true;
    }

    public bool IsBorrowed()
    {
        return borrowed;
    }
}

Select Run code to compile and execute this program.

First: True
Second: True

Repair checkpoints

1. Confirm first and second are created by separate new expressions.
2. Find private static bool borrowed in the model.
3. Remove static from the borrowed field so it belongs to each instance.
4. Preserve public TryBorrow and IsBorrowed instance methods.
5. Verify First: True and Second: False after borrowing first only.

using System;

class Program
{
    static void Main()
    {
        BookLoan first = new BookLoan();
        BookLoan second = new BookLoan();
        first.TryBorrow();
        Console.WriteLine($"First: {first.IsBorrowed()}");
        Console.WriteLine($"Second: {second.IsBorrowed()}");
    }
}

class BookLoan
{
    public string Title = "Untitled";
    private bool borrowed = false;

    public bool TryBorrow()
    {
        if (borrowed)
        {
            return false;
        }
        borrowed = true;
        return true;
    }

    public bool IsBorrowed()
    {
        return borrowed;
    }
}

Select Run code to compile and execute this program.

First: True
Second: False

Independent lab: complete the borrowing story

Complete the return behavior for a library copy. Keep borrowing and returning rules inside BookLoan, then use Main to verify the full state-transition story.

Acceptance checklist

• Keep borrowed private and non-static, initially false.
• Keep TryBorrow as the guarded available-to-borrowed transition.
• Implement public bool TryReturn(): return false without a state change if already available.
• Otherwise set borrowed to false and return true.
• Keep IsBorrowed as a state query with no mutation.
• Print the reference sequence: borrow True, duplicate borrow False, return True, duplicate return False, final borrowed False.
• Keep output in Main and preserve independence between separate objects.

using System;

class Program
{
    static void Main()
    {
        BookLoan loan = new BookLoan();
        Console.WriteLine($"Borrow: {loan.TryBorrow()}");
        Console.WriteLine($"Duplicate borrow: {loan.TryBorrow()}");
        Console.WriteLine($"Return: {loan.TryReturn()}");
        Console.WriteLine($"Duplicate return: {loan.TryReturn()}");
        Console.WriteLine($"Borrowed: {loan.IsBorrowed()}");
    }
}

class BookLoan
{
    public string Title = "Untitled";
    private bool borrowed = false;

    public bool TryBorrow()
    {
        if (borrowed)
        {
            return false;
        }
        borrowed = true;
        return true;
    }

    public bool IsBorrowed()
    {
        return borrowed;
    }

    public bool TryReturn()
    {
        // TODO: refuse an available copy; otherwise restore availability.
        return false;
    }
}

Select Run code to compile and execute this program.

Borrow: True
Duplicate borrow: False
Return: False
Duplicate return: False
Borrowed: True

using System;

class Program
{
    static void Main()
    {
        BookLoan loan = new BookLoan();
        Console.WriteLine($"Borrow: {loan.TryBorrow()}");
        Console.WriteLine($"Duplicate borrow: {loan.TryBorrow()}");
        Console.WriteLine($"Return: {loan.TryReturn()}");
        Console.WriteLine($"Duplicate return: {loan.TryReturn()}");
        Console.WriteLine($"Borrowed: {loan.IsBorrowed()}");
    }
}

class BookLoan
{
    public string Title = "Untitled";
    private bool borrowed = false;

    public bool TryBorrow()
    {
        if (borrowed)
        {
            return false;
        }
        borrowed = true;
        return true;
    }

    public bool IsBorrowed()
    {
        return borrowed;
    }

    public bool TryReturn()
    {
        if (!borrowed)
        {
            return false;
        }
        borrowed = false;
        return true;
    }
}

Select Run code to compile and execute this program.

Borrow: True
Duplicate borrow: False
Return: True
Duplicate return: False
Borrowed: False

Changed-input checks

• TryReturn on a fresh object returns False and leaves IsBorrowed False.
• Borrow then return produces True, True and final state False.
• Borrow twice produces True, False and final state True.
• After a successful return, borrowing again succeeds.
• Borrowing the first of two separate objects leaves the second available.
• A second reference to the same object sees the same borrowed state.

Recap: state, behavior and boundaries

Describe what one object represents, the state it owns and the operations that preserve its rules. Distinguish operation success from current state.

class

Defines a custom type and its members.

object / instance

One concrete instance created from a class definition.

reference

A value that identifies an object; assignment does not clone that object.

state

Information remembered by an object, such as its borrowed flag.

behavior

An operation or query associated with that object.

responsibility

The small purpose and rules the model is meant to own.

encapsulation

Expose meaningful operations and control access to the data they maintain.

static versus instance

Type-level state is shared; instance fields belong to individual objects.

Frequently asked questions

Next step and references

An object connects state with meaningful behavior. Give it a focused responsibility, distinguish separate instances from shared references, and verify both accepted and refused operations.

Next is C# Classes and Objects. You will practice class declarations, instance creation and member access in more detail, then trace independent objects and shared references.

Official references

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

• Microsoft Learn: Object-oriented techniques
• Microsoft Learn: Classes and reference semantics

Last updated: 27 October 2026.