Share via

Namespace Statement 

  • Article

Declares the name of a namespace and causes the source code following the declaration to be compiled within that namespace.

Namespace { name | name.name }
    [ componenttypes ]
End Namespace

Parts

  • name
    Required. A unique name that identifies the namespace. Must be a valid Visual Basic identifier. For more information, see Declared Element Names.
  • componenttypes
    Optional. Elements that make up the namespace. These include (but are not limited to) enumerations, structures, interfaces, classes, modules, delegates, and other namespaces.
  • End Namespace
    Terminates a Namespace block.

Remarks

Namespaces are used as an organizational system. They provide a way of classifying and presenting programming elements that are exposed to other programs and applications. Note that a namespace is not a type in the sense that a class or structure is — you cannot declare a programming element to have the data type of a namespace.

You can use a Namespace statement only at the file or namespace level. This means the declaration context for a namespace must be a source file or another namespace, and cannot be a class, structure, module, interface, or procedure. For more information, see Declaration Contexts and Default Access Levels.

Namespaces are treated as if they had a Public access level. A namespace can be accessed from code anywhere within the same project, from other projects that reference the project, and from any assembly built from the project.

Rules

  • Attributes. You cannot apply attributes to a namespace. An attribute contributes information to the assembly's metadata, which is not meaningful for source classifiers such as namespaces.

  • Modifiers. You cannot apply any access or procedure modifiers, or any other modifiers, to a namespace. Because it is not a type, these modifiers are not meaningful.

  • Nesting. You can declare one namespace within another. There is no strict limit to the levels of nesting you can declare, but keep in mind that when other code accesses the elements declared in the innermost namespace, it must use a qualification string containing all the namespace names in the nesting hierarchy.

Behavior

  • Access Level. Programming elements declared at namespace level, meaning within a namespace but not inside any other element, can have Public or Friend access. If not specified, the access level of such an element defaults to Friend. Elements you can declare at namespace level include classes, structures, modules, interfaces, enumerations, and delegates. For more information, see Declaration Contexts and Default Access Levels.

  • Compilation. All programming elements declared following a Namespace statement belong to that namespace. Visual Basic continues to compile elements into the last declared namespace until it encounters either an End Namespace statement or another Namespace statement.

  • Adding to a Namespace. If a namespace is already defined, even outside your project, you can add programming elements to it. To do this, you use a Namespace statement to direct Visual Basic to compile the following elements into that namespace.

    The following example defines the skeleton of a new generic list class and adds it to the System.Collections.Generic namespace.

    Namespace System.Collections.Generic
    Class specialSortedList(Of T)
        Inherits List(Of T)
        ' Insert code to define the special generic list class.
    End Class
End Namespace

  • Root Namespace. All namespace names in your project are based on a root namespace. Visual Studio assigns your project name as the default root namespace for all code in your project. For example, if your project is named Payroll, its programming elements belong to namespace Payroll. If you declare Namespace funding, the full name of that namespace is Payroll.funding.

    If you wish to specify an existing namespace in a Namespace statement, such as in the generic list class example, you can set your root namespace to a null value. You do this by choosing Project Properties from the Project menu and then clearing the Root namespace entry so that the box is empty. If you did not do this in the generic list class example, the Visual Basic compiler would take System.Collections.Generic as a new namespace within project Payroll, with the full name of Payroll.System.Collections.Generic.

    Alternatively, you can use the Global keyword to refer to elements of namespaces defined outside your project. Doing so allows you to retain your project name as the root namespace. This reduces the chance of unintentionally merging your programming elements with those of existing namespaces.

Troubleshooting

  • Undefined Types. The root namespace can lead to unexpected concatenations of namespace names. If you make reference to namespaces defined outside your project, the Visual Basic compiler can construe them as nested namespaces within your root namespace. In such a case, the compiler does not recognize any types that have been already defined in the external namespaces. To avoid this, either set your root namespace to a null value as described in "Root Namespace", or use the Global keyword to access elements of external namespaces.

Example

The following example declares two namespaces, one nested within the other.

Namespace n1
    Namespace n2
        Class a
            ' Insert class definition.
        End Class
    End Namespace
End Namespace

The following example declares multiple nested namespaces on a single line, and it is equivalent to the previous example.

Namespace n1.n2
    Class a
        ' Insert class definition.
    End Class
End Namespace

The following example accesses the class defined in the previous examples.

Dim instance As New n1.n2.a

See Also

Reference

Imports Statement
Global

Concepts

Declared Element Names
Namespaces in Visual Basic