Static members vs instance members in C Sharp (C#) - Visual Side-by-Side Comparison

Concept Flow - Static members vs instance members

Start

↓

Create Class

↓

Define Static Member

↓

Define Instance Member

↓

Create Object Instance

↓

Access Instance Member via Object

↓

Access Static Member via Class

↓

Use Members

↓

End

This flow shows how static members belong to the class itself and instance members belong to each object created from the class.

Execution Sample

C Sharp (C#)

class Car {
  public static int wheels = 4;
  public string color;

  public Car(string c) {
    color = c;
  }
}

Car car1 = new Car("red");
Console.WriteLine(Car.wheels);
Console.WriteLine(car1.color);

This code defines a class with a static member and an instance member, creates an object, and accesses both members.

Execution Table

Step	Action	Evaluation	Result
1	Define class Car with static wheels=4 and instance color	Class ready	Static wheels=4, no instances yet
2	Create car1 = new Car("red")	Constructor sets color	car1.color = "red"
3	Access Car.wheels	Static member accessed via class	Output: 4
4	Access car1.color	Instance member accessed via object	Output: red
5	End of execution	All members accessed	Program ends

💡 Program ends after accessing static and instance members

Variable Tracker

Variable	Start	After Step 2	Final
Car.wheels	4	4	4
car1.color	undefined	red	red

Key Moments - 2 Insights

Why do we access 'wheels' using the class name but 'color' using the object name?

Because 'wheels' is static and belongs to the class itself, so we use the class name (see step 3). 'color' is an instance member, so it belongs to each object and we access it via the object (see step 4).

Can we access instance members without creating an object?

No, instance members need an object to exist. Without creating 'car1', 'color' has no value (see step 2).

Visual Quiz - 3 Questions

Look at the execution table, what is the value of Car.wheels at step 3?

A red

B undefined

C 4

D 0

💡 Hint

Check the 'Result' column at step 3 in the execution_table.

At which step is the instance member 'color' assigned a value?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Action' and 'Result' columns for when car1.color is set.

If we try to access 'color' using the class name like Car.color, what would happen?

A It will cause a compile-time error

B It will output the color value

C It will output null

D It will output 4

💡 Hint

Instance members require an object; see key_moments about access rules.

Concept Snapshot

Static members belong to the class and are shared by all instances.
Instance members belong to each object separately.
Access static members via ClassName.member.
Access instance members via object.member.
Static members exist even if no objects are created.
Instance members require an object to exist.

Full Transcript

This example shows a class Car with a static member wheels and an instance member color. The static member wheels is shared by all cars and accessed using the class name. The instance member color is unique to each car object and accessed through the object. We create car1 with color 'red'. Accessing Car.wheels gives 4, and car1.color gives 'red'. Static members do not need an object, but instance members do. Trying to access instance members without an object causes errors.

Practice

1. Which statement correctly describes a static member in C#?

easy

A. It belongs to the class and is shared by all instances.

B. It belongs to each object and stores unique data.

C. It can only be accessed through an object instance.

D. It is created every time a new object is instantiated.

Solution

1. Step 1: Understand static member concept

   Static members belong to the class itself, not to any individual object.

2. Step 2: Compare with instance members

   Instance members belong to objects and hold unique data per object, unlike static members.

3. Final Answer:

   It belongs to the class and is shared by all instances. -> Option A

4. Quick Check:

   Static member = shared by class [OK]

Hint: Static = shared by class, instance = unique per object [OK]

Common Mistakes:

• Confusing static with instance members
• Thinking static members are unique per object
• Believing static members require object to access

2. Which of the following is the correct way to declare a static field in a C# class?

easy

A. public static int count;

B. public int static count;

C. public int count;

D. int static public count;

Solution

1. Step 1: Recall C# static field syntax

   The correct order is access modifier, then 'static', then type and name.

2. Step 2: Check each option

   public static int count; matches the correct syntax: 'public static int count;'. Others have wrong order or missing keywords.

3. Final Answer:

   public static int count; -> Option A

4. Quick Check:

   Access modifier + static + type + name [OK]

Hint: Use 'public static' before type for static fields [OK]

Common Mistakes:

• Placing 'static' after the type
• Omitting 'static' keyword
• Incorrect order of keywords

3. What will be the output of the following C# code?

class Counter {
    public static int count = 0;
    public Counter() {
        count++;
    }
}

class Program {
    static void Main() {
        Counter c1 = new Counter();
        Counter c2 = new Counter();
        Console.WriteLine(Counter.count);
    }
}

medium

A. 0

B. 2

C. 1

D. Compilation error

Solution

1. Step 1: Understand static field behavior

   The static field 'count' is shared by all instances and starts at 0.

2. Step 2: Trace constructor calls

   Each new Counter() increments 'count' by 1. Two objects created, so count becomes 2.

3. Final Answer:

   2 -> Option B

4. Quick Check:

   Static count increments twice = 2 [OK]

Hint: Static fields keep shared state across all objects [OK]

Common Mistakes:

• Thinking count resets per object
• Confusing instance and static fields
• Expecting compilation error due to static access

4. Identify the error in this C# code snippet:

class Example {
    public static int value = 10;
    public int GetValue() {
        return value;
    }
}

medium

A. Cannot access static field 'value' inside instance method.

B. Method GetValue must be static to access static field 'value'.

C. Static field 'value' must be private.

D. No error; code compiles and runs correctly.

Solution

1. Step 1: Check static field access rules

   Instance methods can access static fields directly without error.

2. Step 2: Verify code correctness

   Method GetValue returns static field 'value' correctly; no syntax or access errors.

3. Final Answer:

   No error; code compiles and runs correctly. -> Option D

4. Quick Check:

   Instance method can access static field [OK]

Hint: Instance methods can access static fields directly [OK]

Common Mistakes:

• Thinking instance methods cannot access static fields
• Believing GetValue must be static
• Assuming static fields must be private

5. You want to count how many objects of a class are created, but also keep a unique ID for each object starting from 1. Which approach correctly uses static and instance members?

hard

A. Use only instance fields for both counter and ID.

B. Use an instance counter incremented in constructor; assign its value to a static ID field.

C. Use a static counter incremented in constructor; assign its value to an instance ID field.

D. Use static fields for both counter and ID without instance fields.

Solution

1. Step 1: Understand counting objects with static field

   A static counter shared by all objects can track total created objects.

2. Step 2: Assign unique ID per object using instance field

   Each object gets its own instance ID assigned from the static counter value.

3. Final Answer:

   Use a static counter incremented in constructor; assign its value to an instance ID field. -> Option C

4. Quick Check:

   Static counter + instance ID = unique IDs [OK]

Hint: Static counts total; instance stores unique ID per object [OK]

Common Mistakes:

• Using instance counter for total count
• Assigning static ID per object (not unique)
• Not incrementing counter in constructor