ECMA-334 C# Language Specification

16.3.2: Using namespace directives

A using-namespace-directive imports the types contained in a namespace into the immediately enclosing compilation unit or namespace body, enabling the identifier of each type to be used without qualification.

using-namespace-directive
using namespace-name ;

Within member declarations in a compilation unit or namespace body that contains a using-namespace-directive, the types contained in the given namespace can be referenced directly. [Example: For example: 
namespace N1.N2  
{  
   class A {}  
}  
namespace N3  
{  
   using N1.N2;  
   class B: A {}  
}

Above, within member declarations in the N3 namespace, the type members of N1.N2 are directly available, and thus class N3.B derives from class N1.N2.A. end example]

A using-namespace-directive imports the types contained in the given namespace, but specifically does not import nested namespaces. [Example: In the example 
namespace N1.N2  
{  
   class A {}  
}  
namespace N3  
{  
   using N1;  
   class B: N2.A {}    // Error, N2 unknown  
}
the using-namespace-directive imports the types contained in N1, but not the namespaces nested in N1. Thus, the reference to N2.A in the declaration of B results in a compile-time error because no members named N2 are in scope. end example]

Unlike a using-alias-directive, a using-namespace-directive may import types whose identifiers are already defined within the enclosing compilation unit or namespace body. In effect, names imported by a using-namespace-directive are hidden by similarly named members in the enclosing compilation unit or namespace body. [Example: For example: 
namespace N1.N2  
{  
   class A {}  
   class B {}  
}  
namespace N3  
{  
   using N1.N2;  
   class A {}  
}

Here, within member declarations in the N3 namespace, A refers to N3.A rather than N1.N2.A. end example]

When more than one namespace imported by using-namespace-directives in the same compilation unit or namespace body contain types by the same name, references to that name are considered ambiguous.

[Example: In the example 
namespace N1  
{  
   class A {}  
}  
namespace N2  
{  
   class A {}  
}  
namespace N3  
{  
   using N1;  
   using N2;  
   class B: A {}     // Error, A is ambiguous  
}
both N1 and N2 contain a member A, and because N3 imports both, referencing A in N3 is a compile-time error. end example] In this situation, the conflict can be resolved either through qualification of references to A, or by introducing a using-alias-directive that picks a particular A. [Example: For example: 
namespace N3  
{  
   using N1;  
   using N2;  
   using A = N1.A;  
   class B: A {}     // A means N1.A  
}
end example]

Like a using-alias-directive, a using-namespace-directive does not contribute any new members to the underlying declaration space of the compilation unit or namespace, but, rather, affects only the compilation unit or namespace body in which it appears.

The namespace-name referenced by a using-namespace-directive is resolved in the same way as the namespace-or-type-name referenced by a using-alias-directive. Thus, using-namespace-directives in the same compilation unit or namespace body do not affect each other and can be written in any order.