C# Top-level statements and its Characteristics

Top-level statements, introduced in C# 9.0, are a C# feature that lets you write executable program code directly in a source file (e.g. Program file) without explicitly creating a class and Main() method.

Definition: Top-level statements are executable statements written directly at the source-file level (outside any namespace or type declaration), which the compiler places into an automatically generated program entry method.

Because of Top-level statements features, instead of writing:

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Hello, World!");
    }
}

You can write:

Console.WriteLine("Hello, World!");

The compiler automatically generates the equivalent Program class and Main() method.

Conceptually, the compiler treats it like:

internal class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Hello, World!");
    }
}

Characteristics of Top-level statements

1. Only one file in your application can use top-level statements.
2. The top-level statements cannot be enclosed in a namespace.
3. When using top-level statements, the program cannot have a declared entry point i.e. Main() method. Other methods are allows except Main.
4. Top-level statements still access a string array of args.
5. The methods defined in the top-level statements file are local methods.
6. Any types declared before the end of the top-level statements will result in a compilation error.
7. Blocks are allowed to group executable statements in the top-level statements file.

Example. Type defined before top-level statements is invalid.

class Employee
{

// ERROR. Top-level statements must precede namespace and type declarations.
}
Console.WriteLine("Start");

Example. Type defined after top-level statements is valid.

Console.WriteLine("Start");
class Employee
{
}

Example. Type defined before the end of top-level statement will throw error.

Console.WriteLine("Start");

class Employee

{

// ERROR. Top-level statements must precede namespace and type declarations.

}

Console.WriteLine("End");

Example. Blocks are allowed in top level statement file.

//It is Valid to enclose top level statements inside block.

{

    int x = 10; // local variable

    Console.WriteLine($"First block variable x: {x}");

    Console.WriteLine("Valid to enclose top level statements inside block.");

}

{

    int x = 12; // local variable

    Console.WriteLine($"Second block variable x: {x}");

    Console.WriteLine("This is another block of top level statements.");

}

Example. Read command line arguments.

string[] arguments = Environment.GetCommandLineArgs();

Console.WriteLine($"Argument 1: {arguments[0]}");

Console.WriteLine($"Argument 2: {arguments[1]}");

Console.WriteLine($"Argument 3: {arguments[0]}");

Note. The zero index argument returns the assembly path. On running the application in command line mode using command: dotnet run ajeet 22 we get the following output:

PS C:\Users\ajeet\Documents\appx\tempf\Practicals> dotnet run ajeet 22

Argument 1: C:\Users\ajeet\Documents\appx\tempf\Practicals\bin\Debug\net8.0\Practicals.dll

Argument 2: ajeet

Argument 3: 22

Question: Why Error Message: "Top-level statements must precede namespace and type declarations" for following code in Program file? What is solution?

public record Person(string FirstName, string LastName);

Person person1 = new Person("Ajeet","Kumar");

Answer:

This error occurs because in C#, top-level statements must appear before any type declarations (class, struct, record, interface, enum, etc.).

The code:

public record Person(string FirstName, string LastName);

Person person1 = new Person("Ajeet","Kumar");

has a type declaration (record Person) first, then a top-level statement (Person person1 = ...), which is not allowed.

Solution is:

Person person1 = new Person("Ajeet", "Kumar");

Console.WriteLine(person1);

// type declaration must be after top-level statements

public record Person(string FirstName, string LastName);

C# Difference between Non-local methods Vs Local methods

Non-local methods (regular methods)

A non-local method is a method declared directly inside a type such as a class, struct, record, or interface.

Example:

class Calculator
{
    public static int Add(int x, int y)   // non-local method
    {
        return x + y;
    }
}

Characteristics:

• Member of a type (class, struct, etc.)
• Accessible according to access modifiers (public, private, etc.)
• Exists independently of another method
• Can be called from other methods

---

Local methods (local functions)

A local method (officially called local function in C#) is declared inside another method.

Example:

class Calculator
{
    static void Main()
    {
        int Add(int x, int y)   // local function
        {
            return x + y;
        }
 
        Console.WriteLine(Add(10, 20));
    }
}

Characteristics:

• Declared inside another method
• Scope limited to enclosing method
• Cannot have access modifiers (public, private, etc.)
• Can access local variables of outer method.
• Local methods can be called by its immediate outer method.

Another Example:

static void Main()
{
    int bonus = 10;
 
    int AddBonus(int x)
    {
        return x + bonus; // captures local variable
    }
 
    Console.WriteLine(AddBonus(20)); // 30
}

Inside Top-level statements, all methods are local methods.

Example: The following code is in Program file which is a top level statements file.

Console.WriteLine("Print is a local method in top level statements file.");
void Print()
{
    Console.WriteLine("Local");
}

👉The compiler transforms top-level code into something similar to:

internal class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Hello");
 
        void Print()
        {
            Console.WriteLine("Local");
        }
    }
}

So methods declared in top-level statements become local functions inside the compiler-generated Main() method. 

---

How Local methods are called?

void Outermost()
{
    Console.WriteLine("Hello Outermost");
    Outer();
    void Outer()
    {
        Console.WriteLine("Hello Outer");
        Print();
        void Print()
        {
            Console.WriteLine("Hello Local");
        }
        Print();
    }
}

Outermost();

Summary

Feature	Non-local method	Local method
Declared inside	Class/Struct	Another method
Is type member?	Yes	No
Access modifiers allowed	Yes	No
Scope	Whole type	Enclosing method only
Can access outer locals	No	Yes
Example	class A { void RegularM(){} }	void OuterM(){   void InnerM(){} }

In short:

Non-local methods are members of a class/struct, whereas local methods are declared inside another method and are not type members. Local methods are always implicitly private to its containing outer method.