Namespace Declaration

A namespace declaration defines a named declarative region used to establish a hierarchical scope for types. It acts as a logical container that prevents naming collisions by appending a unique prefix to the fully qualified names of the types (classes, interfaces, structs, enums, and delegates) defined within it.

Block-Scoped Namespace Declaration

The traditional method of declaring a namespace uses the namespace keyword followed by a valid C# identifier and a set of curly braces { }. All types declared within the braces belong to that namespace.

namespace Company.Product.Module
{
    class Component
    {
        // Fully qualified name: Company.Product.Module.Component
    }
}

File-Scoped Namespace Declaration (C# 10+)

File-scoped namespace declarations eliminate indentation by applying the namespace to all types within the file. It is declared using the namespace keyword, the identifier, and a terminating semicolon ;.

namespace Company.Product.Module;

class Component
{
    // Fully qualified name: Company.Product.Module.Component
}

interface IService
{
    // Fully qualified name: Company.Product.Module.IService
}

Rules for File-Scoped Namespaces:

• A file can contain only one file-scoped namespace declaration.
• The declaration must precede any type declarations in the file.
• It cannot be combined with block-scoped namespace declarations in the same file.

Nested Namespace Declarations

Namespaces can be nested to create a deeper hierarchy. This can be achieved either through nested blocks or, more commonly, using dot notation.

Using Dot Notation (Preferred):

namespace Root.Parent.Child
{
    class Node { }
}

Using Nested Blocks:

namespace Root
{
    namespace Parent
    {
        namespace Child
        {
            class Node { }
        }
    }
}

Technical Characteristics and Constraints

• Implicit Access: Namespaces are implicitly public. You cannot apply access modifiers (such as public, private, or internal) to a namespace declaration.
• Compiler Merging: Namespace declarations are open-ended. If you declare the same namespace in multiple files, or multiple times within the same file, the C# compiler merges the members into a single namespace during compilation.
• Global Namespace: Any type declared outside of a specific namespace declaration belongs to the implicit “global” namespace. You can explicitly reference the global namespace using the global:: alias qualifier (e.g., global::System.String).
• Valid Identifiers: Namespace names must adhere to standard C# identifier rules (e.g., cannot start with a number, cannot be a reserved keyword unless prefixed with @).

Master C# with Deep Grasping Methodology!

Learn More