Understanding Variable Scope in C#: Class, Method, and Block Levels

Understanding Variable Scope in C#

This guide explains how variable scope works in C#, covering class‑level, method‑level, and block‑level scopes with clear, practical examples.

Variable scope determines where a variable can be accessed within your code. In C#, you encounter three primary scopes.

• Class Level Scope
• Method Level Scope
• Block Level Scope

Class‑Level Variable Scope

When a variable is declared inside a class but outside any method or constructor, it is a field and can be accessed by all members of that class. This is known as class‑level scope.

using System;
namespace VariableScope
{
    class Program
    {
        // Class-level field
        string str = "Class Level";

        public void Display()
        {
            Console.WriteLine(str);
        }

        static void Main(string[] args)
        {
            Program ps = new Program();
            ps.Display();
            Console.ReadLine();
        }
    }
}

Output

Class Level

In this example, str is a field, so it is available throughout the Program class, including the Display method.

Important note: Instance fields are not accessible from static methods unless an instance is used. For example:

static void Display2()
{
    // This will cause a compile‑time error
    Console.WriteLine(str);
}

Method‑Level Variable Scope

Variables declared inside a method are local to that method. They cannot be referenced outside the method that defines them, which is called method‑level scope.

using System;
namespace VariableScope
{
    class Program
    {
        public void Method1()
        {
            // Local variable
            string str = "method level";
        }

        public void Method2()
        {
            // Trying to access str here will cause an error
            Console.WriteLine(str);
        }

        static void Main(string[] args)
        {
            Program ps = new Program();
            ps.Method2();
            Console.ReadLine();
        }
    }
}

Attempting to use str in Method2 results in the compiler error:

Error CS0103: The name 'str' does not exist in the current context

Conversely, a local variable can be used within the same method:

using System;
namespace VariableScope
{
    class Program
    {
        public void Display()
        {
            string str = "inside method";
            Console.WriteLine(str);
        }

        static void Main(string[] args)
        {
            Program ps = new Program();
            ps.Display();
            Console.ReadLine();
        }
    }
}

Output

inside method

Block‑Level Variable Scope in C#

Variables declared within a block—such as loops, if statements, or other nested scopes—are only accessible inside that block. This is known as block‑level scope.

using System;
namespace VariableScope
{
    class Program
    {
        public void Display()
        {
            for (int i = 0; i <= 3; i++)
            {
                // i is confined to this for‑loop
            }
            // Console.WriteLine(i); // ❌ compile‑time error
        }

        static void Main(string[] args)
        {
            Program ps = new Program();
            ps.Display();
            Console.ReadLine();
        }
    }
}

Here, the loop counter i cannot be referenced after the loop, because its scope ends with the block.