Methods that operate on state in C Sharp (C#) - Step-by-Step Execution

Concept Flow - Methods that operate on state

Create Object with Initial State

↓

Call Method on Object

↓

Method Accesses and Changes State

↓

State Updated

↓

Use Updated State

↓

End

This flow shows how a method is called on an object, accesses its internal state, changes it, and then the updated state is used.

Execution Sample

C Sharp (C#)

class Counter {
  private int count = 0;
  public void Increment() {
    count = count + 1;
  }
  public int GetCount() {
    return count;
  }
}

This code defines a Counter class with a count variable and methods to increase and get the count.

Execution Table

Step	Action	count Before	count After	Output
1	Create Counter object	N/A	0	N/A
2	Call Increment()	0	1	N/A
3	Call Increment()	1	2	N/A
4	Call GetCount()	2	2	2
5	End	2	2	N/A

💡 No more method calls; program ends with count = 2

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
count	N/A	0	1	2	2	2

Key Moments - 2 Insights

Why does the count variable change after calling Increment()?

Because Increment() method accesses the object's internal count variable and adds 1 to it, as shown in execution_table steps 2 and 3.

Does GetCount() change the count variable?

No, GetCount() only returns the current value of count without modifying it, as seen in step 4 where count before and after remain 2.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of count after the first Increment() call?

A 0

B 1

C 2

D N/A

💡 Hint

Check the 'count After' column at Step 2 in the execution_table.

At which step does the count variable stop changing?

A Step 4

B Step 3

C Step 2

D Step 5

💡 Hint

Look at the 'count Before' and 'count After' columns in steps 3 and 4.

If we call Increment() one more time after step 4, what would be the new count?

A 2

B 4

C 3

D 1

💡 Hint

Each Increment() adds 1 to count; after 2 increments count is 2, so one more makes it 3.

Concept Snapshot

Methods that operate on state:
- Methods can read and change an object's internal variables.
- Calling a method like Increment() updates the state.
- Methods like GetCount() can return state without changing it.
- State changes persist between method calls.
- Use methods to safely manage and update object data.

Full Transcript

This example shows a Counter class with a private variable count starting at 0. When we create a Counter object, count is 0. Calling Increment() adds 1 to count each time. Calling GetCount() returns the current count without changing it. The execution table traces each step: creation sets count to 0, first Increment changes count to 1, second Increment changes count to 2, then GetCount returns 2. The variable tracker shows count's value after each step. Key moments clarify that Increment changes state while GetCount does not. The quiz asks about count values at different steps and what happens if we call Increment again. This teaches how methods operate on and change an object's internal state in C#.