NamespacesNamespaces

C#-Programme werden mithilfe von Namespaces organisiert.C# programs are organized using namespaces. Namespaces werden verwendet, sowohl als "intern" Organisation System für ein Programm, und als "extern" Organisation System – eine Möglichkeit zum Darstellen der Programmelemente, die für andere Programme verfügbar gemacht werden.Namespaces are used both as an "internal" organization system for a program, and as an "external" organization system—a way of presenting program elements that are exposed to other programs.

Using-Direktiven (Using-Direktiven) werden bereitgestellt, um die Verwendung von Namespaces zu erleichtern.Using directives (Using directives) are provided to facilitate the use of namespaces.

Kompilierungseinheiten hinwegCompilation units

Ein Compilation_unit die allgemeine Struktur einer Quelldatei definiert.A compilation_unit defines the overall structure of a source file. Eine Kompilierungseinheit besteht aus 0 (null) oder mehreren Using_directives, gefolgt von NULL oder mehr Global_attributes gefolgt von 0 (null) oder mehr Namespace_member_declarations .A compilation unit consists of zero or more using_directives followed by zero or more global_attributes followed by zero or more namespace_member_declarations.

compilation_unit
    : extern_alias_directive* using_directive* global_attributes? namespace_member_declaration*
    ;

Ein C#-Programm besteht aus einen oder mehrere Kompilierungseinheiten hinweg, jeweils in einer separaten Quelldatei enthalten.A C# program consists of one or more compilation units, each contained in a separate source file. Wenn ein C#-Programm kompiliert wird, werden alle von der Kompilierungseinheiten zusammen verarbeitet.When a C# program is compiled, all of the compilation units are processed together. Daher können Kompilierungseinheiten voneinander, möglicherweise in einer kreisförmigen Weise abhängig sind.Thus, compilation units can depend on each other, possibly in a circular fashion.

Die Using_directives eine Kompilierung Einheit beeinflussen die Global_attributes und Namespace_member_declarations Kompilationseinheit, haben jedoch keine Auswirkungen auf andere Kompilierungseinheiten hinweg.The using_directives of a compilation unit affect the global_attributes and namespace_member_declarations of that compilation unit, but have no effect on other compilation units.

Die Global_attributes (Attribute) von einer Kompilierungseinheit ermöglichen die Angabe von Attributen für die Ziel-Assembly und Modul.The global_attributes (Attributes) of a compilation unit permit the specification of attributes for the target assembly and module. Fungieren als physische Container für Typen, Assemblys und Modulen.Assemblies and modules act as physical containers for types. Eine Assembly bestehen aus mehreren physisch separaten Modulen.An assembly may consist of several physically separate modules.

Die Namespace_member_declarations der einzelnen Kompilierungseinheiten eines Programms tragen Member zu einer einzelnen Deklarationsabschnitt den globalen Namespace bezeichnet.The namespace_member_declarations of each compilation unit of a program contribute members to a single declaration space called the global namespace. Zum Beispiel:For example:

Datei A.cs:File A.cs:

class A {}

Datei B.cs:File B.cs:

class B {}

Die zwei Kompilierungseinheiten beitragen, auf die einzelnen globalen Namespace deklarieren zwei Klassen mit den vollqualifizierten Namen in diesem Fall A und B.The two compilation units contribute to the single global namespace, in this case declaring two classes with the fully qualified names A and B. Da die zwei Kompilierungseinheiten zum selben Deklarationsabschnitt beitragen möchten, wäre ein Fehler gewesen, wenn jeweils eine Deklaration eines Elements mit dem gleichen Namen enthalten.Because the two compilation units contribute to the same declaration space, it would have been an error if each contained a declaration of a member with the same name.

NamespacedeklarationenNamespace declarations

Ein Namespace_declaration besteht aus dem Schlüsselwort namespace, gefolgt von einem Namespace-Name und der Text, optional gefolgt von einem Semikolon.A namespace_declaration consists of the keyword namespace, followed by a namespace name and body, optionally followed by a semicolon.

namespace_declaration
    : 'namespace' qualified_identifier namespace_body ';'?
    ;

qualified_identifier
    : identifier ('.' identifier)*
    ;

namespace_body
    : '{' extern_alias_directive* using_directive* namespace_member_declaration* '}'
    ;

Ein Namespace_declaration auftreten als Deklaration auf oberster Ebene in einer Compilation_unit oder als eine Memberdeklaration innerhalb einer anderen Namespace_declaration.A namespace_declaration may occur as a top-level declaration in a compilation_unit or as a member declaration within another namespace_declaration. Wenn eine Namespace_declaration tritt ein, wenn eine Deklaration mit der höchsten Ebene in eine Compilation_unit, aus dem Namespace wird ein Member des globalen Namespaces.When a namespace_declaration occurs as a top-level declaration in a compilation_unit, the namespace becomes a member of the global namespace. Wenn eine Namespace_declaration tritt auf, in einer anderen Namespace_declaration, aus dem innere Namespace wird ein Mitglied der äußere Namespace.When a namespace_declaration occurs within another namespace_declaration, the inner namespace becomes a member of the outer namespace. In beiden Fällen muss der Name eines Namespace innerhalb des enthaltenden Namespaces eindeutig sein.In either case, the name of a namespace must be unique within the containing namespace.

Namespaces sind implizit public und die Deklaration eines Namespace kann keine Zugriffsmodifizierer enthalten.Namespaces are implicitly public and the declaration of a namespace cannot include any access modifiers.

Innerhalb einer Namespace_body, den optionalen Using_directives importieren Sie die Namen der anderen Namespaces, Typen und Member, sodass sie direkt anstelle von über qualifizierte Namen verwiesen werden.Within a namespace_body, the optional using_directives import the names of other namespaces, types and members, allowing them to be referenced directly instead of through qualified names. Der optionale Namespace_member_declarations tragen Member in den Deklarationsbereich des Namespaces.The optional namespace_member_declarations contribute members to the declaration space of the namespace. Beachten Sie, dass alle Using_directives muss vor jeglichen Memberdeklarationen angezeigt werden.Note that all using_directives must appear before any member declarations.

Die Qualified_identifier von einem Namespace_declaration möglicherweise einen einzelnen Bezeichner oder eine Sequenz von Bezeichnern, getrennt durch "." Token.The qualified_identifier of a namespace_declaration may be a single identifier or a sequence of identifiers separated by "." tokens. Die letztgenannte Form lässt es sich um ein Programm, um einem geschachtelten Namespace definieren, ohne die lexikalische Schachtelung mehrere Namespacedeklarationen.The latter form permits a program to define a nested namespace without lexically nesting several namespace declarations. Ein auf ein Objekt angewendeterFor example,

namespace N1.N2
{
    class A {}

    class B {}
}

ist semantisch gleichwertig mitis semantically equivalent to

namespace N1
{
    namespace N2
    {
        class A {}

        class B {}
    }
}

Namespaces haben, und zwei Namespacedeklarationen mit den gleichen vollqualifizierten Namen tragen zum selben Deklarationsabschnitt (Deklarationen).Namespaces are open-ended, and two namespace declarations with the same fully qualified name contribute to the same declaration space (Declarations). Im BeispielIn the example

namespace N1.N2
{
    class A {}
}

namespace N1.N2
{
    class B {}
}

die beiden oben genannten Namespacedeklarationen beitragen zum selben Deklarationsabschnitt, deklarieren zwei Klassen mit den vollqualifizierten Namen in diesem Fall N1.N2.A und N1.N2.B.the two namespace declarations above contribute to the same declaration space, in this case declaring two classes with the fully qualified names N1.N2.A and N1.N2.B. Da die beiden Deklarationen zum selben Deklarationsabschnitt beitragen möchten, wäre gewesen, dass ein Fehler, wenn jeder eine Deklaration eines Elements mit dem gleichen Namen enthalten.Because the two declarations contribute to the same declaration space, it would have been an error if each contained a declaration of a member with the same name.

Extern-AliaseExtern aliases

Ein Extern_alias_directive führt einen Bezeichner, der als Alias für einen Namespace fungiert.An extern_alias_directive introduces an identifier that serves as an alias for a namespace. Die Spezifikation des Aliasnamespace als für den Quellcode des Programms extern ist und gilt auch für geschachtelte Namespaces des Namespace mit einem Alias versehen.The specification of the aliased namespace is external to the source code of the program and applies also to nested namespaces of the aliased namespace.

extern_alias_directive
    : 'extern' 'alias' identifier ';'
    ;

Im Rahmen einer Extern_alias_directive erstreckt sich über die Using_directives, Global_attributes und Namespace_member_declarations des direkt enthaltenden Kompilierung oder Text.The scope of an extern_alias_directive extends over the using_directives, global_attributes and namespace_member_declarations of its immediately containing compilation unit or namespace body.

Innerhalb eines Kompilierung Einheit oder Namespace, der enthält ein Extern_alias_directive, der Bezeichner wurde eingeführt, durch die Extern_alias_directive können verwendet werden, um den Aliasnamespace als zu verweisen.Within a compilation unit or namespace body that contains an extern_alias_directive, the identifier introduced by the extern_alias_directive can be used to reference the aliased namespace. Es ist ein Fehler während der Kompilierung für die Bezeichner das Wort sein global.It is a compile-time error for the identifier to be the word global.

Ein Extern_alias_directive stellt ein alias zur Verfügung, wenn es innerhalb eines bestimmten Kompilierung Einheit oder Namespace, aber es trägt nicht die neuen Member zu den zugrunde liegenden Deklarationsabschnitt.An extern_alias_directive makes an alias available within a particular compilation unit or namespace body, but it does not contribute any new members to the underlying declaration space. Das heißt, eine Extern_alias_directive ist nicht transitiv, sondern nur die Kompilierung Einheit oder Namespacetext in dem er auftritt, beeinflusst.In other words, an extern_alias_directive is not transitive, but, rather, affects only the compilation unit or namespace body in which it occurs.

Das folgende Programm deklariert und verwendet zwei "extern" Aliase X und Y, die jeweils von den Stamm einer Namespacehierarchie unterschiedliche darstellt:The following program declares and uses two extern aliases, X and Y, each of which represent the root of a distinct namespace hierarchy:

extern alias X;
extern alias Y;

class Test
{
    X::N.A a;
    X::N.B b1;
    Y::N.B b2;
    Y::N.C c;
}

Das Programm wird das Vorhandensein der "extern" deklariert Aliase X und Y, aber die tatsächlichen Definitionen der Aliase für die Anwendung extern sind.The program declares the existence of the extern aliases X and Y, but the actual definitions of the aliases are external to the program. Dem identisch benannten N.B Klassen können jetzt als verwiesen werden X.N.B und Y.N.B, oder Verwenden des Namespacealias-Qualifizierers, X::N.B und Y::N.B.The identically named N.B classes can now be referenced as X.N.B and Y.N.B, or, using the namespace alias qualifier, X::N.B and Y::N.B. Ein Fehler tritt auf, wenn ein Programm einen externen Alias deklariert, für den keine externe Definition bereitgestellt wird.An error occurs if a program declares an extern alias for which no external definition is provided.

using-DirektivenUsing directives

Using-Direktiven vereinfachen die Nutzung von Namespaces und Typen, die in anderen Namespaces definiert.Using directives facilitate the use of namespaces and types defined in other namespaces. Mithilfe von Direktiven Auswirkungen auf die namensauflösung von Namespace_or_type_names (Namespace und Typnamen) und Simple_names (einfache Namen ), aber im Gegensatz zu Deklarationen, die using-Direktiven tragen nicht die neuen Elemente in der zugrunde liegenden Deklaration Leerzeichen der Kompilierungseinheiten oder Namespaces, die in dem sie verwendet werden.Using directives impact the name resolution process of namespace_or_type_names (Namespace and type names) and simple_names (Simple names), but unlike declarations, using directives do not contribute new members to the underlying declaration spaces of the compilation units or namespaces within which they are used.

using_directive
    : using_alias_directive
    | using_namespace_directive
    | using_static_directive
    ;

Ein Using_alias_directive (mithilfe von Direktiven für Namespacealiase) führt einen Alias für einen Namespace oder Typ.A using_alias_directive (Using alias directives) introduces an alias for a namespace or type.

Ein Using_namespace_directive (Using namespacedirektiven) Typmember von einem Namespace importiert.A using_namespace_directive (Using namespace directives) imports the type members of a namespace.

Ein Using_static_directive (Using static-Direktiven) importiert die geschachtelten Typen und statische Member eines Typs.A using_static_directive (Using static directives) imports the nested types and static members of a type.

Im Rahmen einer Using_directive erstreckt sich über die Namespace_member_declarations des direkt enthaltenden Kompilierung oder Text.The scope of a using_directive extends over the namespace_member_declarations of its immediately containing compilation unit or namespace body. Im Rahmen einer Using_directive beinhalten insbesondere nicht die gleichgeordnete Using_directives.The scope of a using_directive specifically does not include its peer using_directives. Daher peer Using_directives haben keinen Einfluss auf einander und spielt die Reihenfolge, in der sie geschrieben werden.Thus, peer using_directives do not affect each other, and the order in which they are written is insignificant.

Using-Alias-DirektivenUsing alias directives

Ein Using_alias_directive führt einen Bezeichner, der als Alias für einen Namespace oder Typ, in dem unmittelbar einschließenden Kompilierung Einheit oder Namespacetext dient.A using_alias_directive introduces an identifier that serves as an alias for a namespace or type within the immediately enclosing compilation unit or namespace body.

using_alias_directive
    : 'using' identifier '=' namespace_or_type_name ';'
    ;

Innerhalb der Memberdeklarationen in einer Kompilierung Einheit oder Namespacetext, die enthält eine Using_alias_directive, der Bezeichner wurde eingeführt, durch die Using_alias_directive kann verwendet werden, zu verweisen der angegebenen Namespace oder Typ.Within member declarations in a compilation unit or namespace body that contains a using_alias_directive, the identifier introduced by the using_alias_directive can be used to reference the given namespace or type. Zum Beispiel:For example:

namespace N1.N2
{
    class A {}
}

namespace N3
{
    using A = N1.N2.A;

    class B: A {}
}

Oben in den Memberdeklarationen in der N3 Namespace A ist ein Alias für N1.N2.A, und daher N3.B von Klasse abgeleitet ist N1.N2.A.Above, within member declarations in the N3 namespace, A is an alias for N1.N2.A, and thus class N3.B derives from class N1.N2.A. Die gleiche Wirkung erhalten Sie durch Erstellen eines Alias R für N1.N2 verweisen Sie einfach auf R.A:The same effect can be obtained by creating an alias R for N1.N2 and then referencing R.A:

namespace N3
{
    using R = N1.N2;

    class B: R.A {}
}

Die Bezeichner von einem Using_alias_directive muss innerhalb des Deklarationsabschnitts der Kompilierungseinheit oder Namespace, der sofort enthält eindeutig sein der Using_alias_directive .The identifier of a using_alias_directive must be unique within the declaration space of the compilation unit or namespace that immediately contains the using_alias_directive. Zum Beispiel:For example:

namespace N3
{
    class A {}
}

namespace N3
{
    using A = N1.N2.A;        // Error, A already exists
}

Oben N3 enthält bereits einen Member A, daher wird ein Fehler während der Kompilierung für eine Using_alias_directive dieses Bezeichners zu verwenden.Above, N3 already contains a member A, so it is a compile-time error for a using_alias_directive to use that identifier. Entsprechend ist es ein Fehler während der Kompilierung für zwei oder mehr Using_alias_directives in der gleichen Kompilierung Einheit oder Namespacetext Aliase mit demselben Namen zu deklarieren.Likewise, it is a compile-time error for two or more using_alias_directives in the same compilation unit or namespace body to declare aliases by the same name.

Ein Using_alias_directive stellt ein alias zur Verfügung, wenn es innerhalb eines bestimmten Kompilierung Einheit oder Namespace, aber es trägt nicht die neuen Member zu den zugrunde liegenden Deklarationsabschnitt.A using_alias_directive makes an alias available within a particular compilation unit or namespace body, but it does not contribute any new members to the underlying declaration space. Das heißt, eine Using_alias_directive ist nicht transitiv, sondern beeinflusst nur die Kompilierung Einheit oder Namespacetext in dem er auftritt.In other words, a using_alias_directive is not transitive but rather affects only the compilation unit or namespace body in which it occurs. Im BeispielIn the example

namespace N3
{
    using R = N1.N2;
}

namespace N3
{
    class B: R.A {}            // Error, R unknown
}

im Rahmen der Using_alias_directive eingeführt R erstreckt sich auch nur auf Deklarationen im Hauptteil Namespace, in dem es enthalten ist, damit R in die zweite Namespacedeklaration nicht bekannt ist.the scope of the using_alias_directive that introduces R only extends to member declarations in the namespace body in which it is contained, so R is unknown in the second namespace declaration. Platzieren Sie jedoch die Using_alias_directive in der enthaltenden Kompilierung führt Komponententests den Alias in den beiden Namespacedeklarationen verfügbar sind:However, placing the using_alias_directive in the containing compilation unit causes the alias to become available within both namespace declarations:

using R = N1.N2;

namespace N3
{
    class B: R.A {}
}

namespace N3
{
    class C: R.A {}
}

Genau wie reguläre Elemente Namen eingeführt, durch Using_alias_directives durch ähnlich benannten Elemente in geschachtelte Bereiche ausgeblendet sind.Just like regular members, names introduced by using_alias_directives are hidden by similarly named members in nested scopes. Im BeispielIn the example

using R = N1.N2;

namespace N3
{
    class R {}

    class B: R.A {}        // Error, R has no member A
}

der Verweis auf R.A in der Deklaration der B verursacht einen Kompilierungsfehler, da R bezieht sich auf N3.R, nicht N1.N2.the reference to R.A in the declaration of B causes a compile-time error because R refers to N3.R, not N1.N2.

Die Reihenfolge, in der Using_alias_directives werden geschrieben, verfügt über keine Bedeutung und Auflösung von der Namespace_or_type_name verwiesen wird, indem eine Using_alias_directiveist nicht betroffen von dem Using_alias_directive selbst oder von anderen Using_directives im direkt enthaltenden Kompilierung oder Text.The order in which using_alias_directives are written has no significance, and resolution of the namespace_or_type_name referenced by a using_alias_directive is not affected by the using_alias_directive itself or by other using_directives in the immediately containing compilation unit or namespace body. Das heißt, die Namespace_or_type_name von einer Using_alias_directive wird aufgelöst, als hätte der direkt enthaltende Kompilierung Einheit oder Namespacetext keine Using_directives.In other words, the namespace_or_type_name of a using_alias_directive is resolved as if the immediately containing compilation unit or namespace body had no using_directives. Ein Using_alias_directive jedoch möglicherweise betroffen Extern_alias_directives im direkt enthaltenden Kompilierung oder Text.A using_alias_directive may however be affected by extern_alias_directives in the immediately containing compilation unit or namespace body. Im BeispielIn the example

namespace N1.N2 {}

namespace N3
{
    extern alias E;

    using R1 = E.N;        // OK

    using R2 = N1;         // OK

    using R3 = N1.N2;      // OK

    using R4 = R2.N2;      // Error, R2 unknown
}

die letzte Using_alias_directive führt ein Fehler während der Kompilierung, da es nicht, vom ersten betroffen ist Using_alias_directive.the last using_alias_directive results in a compile-time error because it is not affected by the first using_alias_directive. Die erste Using_alias_directive führt nicht zu einem Fehler seit den Rahmen der externe Alias E enthält die Using_alias_directive.The first using_alias_directive does not result in an error since the scope of the extern alias E includes the using_alias_directive.

Ein Using_alias_directive erstellen einen Alias für jeden Namespace oder Typ, einschließlich des Namespace, in dem er angezeigt wird, und jeden Namespace oder Typ, die in diesem Namespace geschachtelt sind.A using_alias_directive can create an alias for any namespace or type, including the namespace within which it appears and any namespace or type nested within that namespace.

Zugreifen auf einen Namespace oder Typ über einen Alias führt genau dieselbe Ergebnisse wie beim Zugriff auf diesen Namespace oder Typ durch den deklarierten Namen.Accessing a namespace or type through an alias yields exactly the same result as accessing that namespace or type through its declared name. Angenommen,For example, given

namespace N1.N2
{
    class A {}
}

namespace N3
{
    using R1 = N1;
    using R2 = N1.N2;

    class B
    {
        N1.N2.A a;            // refers to N1.N2.A
        R1.N2.A b;            // refers to N1.N2.A
        R2.A c;               // refers to N1.N2.A
    }
}

die Namen N1.N2.A, R1.N2.A, und R2.A sind äquivalent und alle beziehen sich auf die Klasse ist, dessen vollqualifizierter Name N1.N2.A.the names N1.N2.A, R1.N2.A, and R2.A are equivalent and all refer to the class whose fully qualified name is N1.N2.A.

Aliase können Name ein geschlossener konstruierter Typ, sondern kann nicht der Name einer ungebundenen generischen Typdeklaration ohne Angabe von Typargumenten.Using aliases can name a closed constructed type, but cannot name an unbound generic type declaration without supplying type arguments. Zum Beispiel:For example:

namespace N1
{
    class A<T>
    {
        class B {}
    }
}

namespace N2
{
    using W = N1.A;          // Error, cannot name unbound generic type

    using X = N1.A.B;        // Error, cannot name unbound generic type

    using Y = N1.A<int>;     // Ok, can name closed constructed type

    using Z<T> = N1.A<T>;    // Error, using alias cannot have type parameters
}

Using namespacedirektivenUsing namespace directives

Ein Using_namespace_directive importiert Typen in einem Namespace enthalten sind, in dem unmittelbar einschließenden Kompilierung Einheit oder Namespacetext, aktivieren den Bezeichner für jeden Typ ohne Qualifikation verwendet werden.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 ';'
    ;

In den Memberdeklarationen in einer Kompilierung Einheit oder Namespacetext, die enthält eine Using_namespace_directive, die im angegebenen Namespace enthaltenen Typen direkt verwiesen werden können.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. Zum Beispiel:For example:

namespace N1.N2
{
    class A {}
}

namespace N3
{
    using N1.N2;

    class B: A {}
}

Oben in den Memberdeklarationen in der N3 -Namespace, den Membern des N1.N2 direkt verfügbar sind, und daher Klasse N3.B von Klasse abgeleitet ist N1.N2.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.

Ein Using_namespace_directive im angegebenen Namespace enthaltenen Typen importiert, insbesondere, importiert jedoch nicht geschachtelten Namespaces.A using_namespace_directive imports the types contained in the given namespace, but specifically does not import nested namespaces. Im BeispielIn the example

namespace N1.N2
{
    class A {}
}

namespace N3
{
    using N1;

    class B: N2.A {}        // Error, N2 unknown
}

die Using_namespace_directive importiert die Typen, die in enthaltenen N1, aber nicht die Namespaces in geschachtelten N1.the using_namespace_directive imports the types contained in N1, but not the namespaces nested in N1. Daher den Verweis auf N2.A in der Deklaration der B führt zu einem Fehler während der Kompilierung, da keine Member mit dem Namen N2 befinden sich im Gültigkeitsbereich.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.

Im Gegensatz zu einem Using_alias_directive, Using_namespace_directive kann, deren Bezeichner sind bereits in der einschließenden Kompilierung Einheit oder Namespacetext definierten, Typen zu importieren.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. Namen aktiviert ist, importiert, indem eine Using_namespace_directive durch ähnlich benannten Elemente in der einschließenden Kompilierung Einheit oder Namespacetext ausgeblendet sind.In effect, names imported by a using_namespace_directive are hidden by similarly named members in the enclosing compilation unit or namespace body. Zum Beispiel:For example:

namespace N1.N2
{
    class A {}

    class B {}
}

namespace N3
{
    using N1.N2;

    class A {}
}

Hier sind die Memberdeklarationen in der N3 Namespace A bezieht sich auf N3.A statt N1.N2.A.Here, within member declarations in the N3 namespace, A refers to N3.A rather than N1.N2.A.

Wenn mehr als ein Namespace oder Typ importiert werden können, indem Using_namespace_directives oder Using_static_directives in der gleichen Kompilierung Einheit oder Namespacetext enthalten Typen, mit dem gleichen Namen, Verweise auf Dieser Name als eine Type_name gelten als nicht eindeutig.When more than one namespace or type imported by using_namespace_directives or using_static_directives in the same compilation unit or namespace body contain types by the same name, references to that name as a type_name are considered ambiguous. Im BeispielIn the example

namespace N1
{
    class A {}
}

namespace N2
{
    class A {}
}

namespace N3
{
    using N1;

    using N2;

    class B: A {}                // Error, A is ambiguous
}

beide N1 und N2 -Member enthalten A, und da N3 importiert, verweisen auf A in N3 ist ein Fehler während der Kompilierung.both N1 and N2 contain a member A, and because N3 imports both, referencing A in N3 is a compile-time error. In diesem Fall der Konflikt kann aufgelöst werden, entweder über die Qualifikation von Verweisen auf A, oder durch die Einführung einer Using_alias_directive , die einen bestimmten wählt A.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. Zum Beispiel:For example:

namespace N3
{
    using N1;

    using N2;

    using A = N1.A;

    class B: A {}                // A means N1.A
}

Darüber hinaus bei mehr als ein Namespace oder Typ importiert Using_namespace_directives oder Using_static_directives in der gleichen Kompilierung oder Text enthalten, Typen oder Member von der gleichnamige verweist auf diesen Namen als einen Simple_name gelten als nicht eindeutig.Furthermore, when more than one namespace or type imported by using_namespace_directives or using_static_directives in the same compilation unit or namespace body contain types or members by the same name, references to that name as a simple_name are considered ambiguous. Im BeispielIn the example

namespace N1
{
    class A {}
}

class C
{
    public static int A;
}

namespace N2
{
    using N1;
    using static C;

    class B
    {
        void M() 
        { 
            A a = new A();   // Ok, A is unambiguous as a type-name
            A.Equals(2);     // Error, A is ambiguous as a simple-name
        }
    }
}

N1 enthält einen Typmember A, und C enthält ein statisches Feld A, und da N2 importiert, verweisen auf A als eine Simple_name mehrdeutig und durch einen während der Kompilierung Fehler.N1 contains a type member A, and C contains a static field A, and because N2 imports both, referencing A as a simple_name is ambiguous and a compile-time error.

Wie eine Using_alias_directive, Using_namespace_directive trägt sich nicht auf alle neuen Member zu der zugrunde liegenden Deklarationsabschnitt der Kompilierungseinheit oder Namespaces, sondern beeinflusst nur den Kompilierung Einheit oder Namespacetext in dem er angezeigt wird.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.

Die Namespace_name verwiesen wird, indem eine Using_namespace_directive wird aufgelöst, auf die gleiche Weise wie die Namespace_or_type_name verwiesen wird, indem eine Using_alias_directive.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. Daher Using_namespace_directives in der gleichen Kompilierung Einheit oder Namespacetext wirken sich gegenseitig nicht und können in beliebiger Reihenfolge geschrieben werden.Thus, using_namespace_directives in the same compilation unit or namespace body do not affect each other and can be written in any order.

Using static-DirektivenUsing static directives

Ein Using_static_directive importiert die geschachtelten Typen und statische Member direkt in einer Typdeklaration unmittelbar einschließenden Kompilierung-Einheit oder Namespace-Text enthalten, die Aktivieren des Bezeichners der jedes Element und einem Typ sein ohne Qualifizierung verwendet.A using_static_directive imports the nested types and static members contained directly in a type declaration into the immediately enclosing compilation unit or namespace body, enabling the identifier of each member and type to be used without qualification.

using_static_directive
    : 'using' 'static' type_name ';'
    ;

In den Memberdeklarationen in einer Kompilierung Einheit oder Namespacetext, die enthält eine Using_static_directive, die zugegriffen werden kann geschachtelte Typen und statische Member (mit Ausnahme von Erweiterungsmethoden) direkt in der Deklaration enthalten die angegebene Typ kann direkt verwiesen werden.Within member declarations in a compilation unit or namespace body that contains a using_static_directive, the accessible nested types and static members (except extension methods) contained directly in the declaration of the given type can be referenced directly. Zum Beispiel:For example:

namespace N1
{
    class A 
    {
        public class B{}
        public static B M(){ return new B(); }
    }
}

namespace N2
{
    using static N1.A;
    class C
    {
        void N() { B b = M(); }
    }
}

Oben in Memberdeklarationen in der N2 -Namespace, der statische Member und geschachtelte Typen von N1.A direkt verfügbar sind, und daher die Methode N kann sowohl auf die B und M Mitglied N1.A.Above, within member declarations in the N2 namespace, the static members and nested types of N1.A are directly available, and thus the method N is able to reference both the B and M members of N1.A.

Ein Using_static_directive insbesondere Erweiterungsmethoden direkt als statische Methoden werden nicht importiert, aber stellt sie für den Aufruf der Erweiterungsmethode zur Verfügung (Erweiterung Methodenaufrufe).A using_static_directive specifically does not import extension methods directly as static methods, but makes them available for extension method invocation (Extension method invocations). Im BeispielIn the example

namespace N1 
{
    static class A 
    {
        public static void M(this string s){}
    }
}

namespace N2
{
    using static N1.A;

    class B
    {
        void N() 
        {
            M("A");      // Error, M unknown
            "B".M();     // Ok, M known as extension method
            N1.A.M("C"); // Ok, fully qualified
        }
    }
}

die Using_static_directive importiert die Erweiterungsmethode M in enthaltenen N1.A, sondern nur als eine Erweiterungsmethode.the using_static_directive imports the extension method M contained in N1.A, but only as an extension method. Daher der erste Verweis auf M im Text der B.N führt zu einem Fehler während der Kompilierung, da keine Member mit dem Namen M befinden sich im Gültigkeitsbereich.Thus, the first reference to M in the body of B.N results in a compile-time error because no members named M are in scope.

Ein Using_static_directive importiert nur Elemente und Typen, die direkt in den angegebenen Typ deklariert keine Elemente und Typen, die in Basisklassen deklariert.A using_static_directive only imports members and types declared directly in the given type, not members and types declared in base classes.

TODO: BeispielTODO: Example

Mehrdeutigkeiten zwischen mehreren Using_namespace_directives und Using_static_directives finden Sie im Using namespacedirektiven.Ambiguities between multiple using_namespace_directives and using_static_directives are discussed in Using namespace directives.

Namespace-ElementeNamespace members

Ein Namespace_member_declaration ist entweder ein Namespace_declaration (Namespace-Deklarationen) oder ein Type_declaration () Typdeklarationen).A namespace_member_declaration is either a namespace_declaration (Namespace declarations) or a type_declaration (Type declarations).

namespace_member_declaration
    : namespace_declaration
    | type_declaration
    ;

Eine Kompilierungseinheit oder einen Namespacetext darf Namespace_member_declarations und derartige Deklarationen tragen neue Mitglieder zu der zugrunde liegenden Deklarationsabschnitt des enthaltenden Kompilierung Einheit oder Namespace-Texts.A compilation unit or a namespace body can contain namespace_member_declarations, and such declarations contribute new members to the underlying declaration space of the containing compilation unit or namespace body.

Deklarationen von TypenType declarations

Ein Type_declaration ist eine Class_declaration (Klasse Deklarationen), ein Struct_declaration (Struktur Deklarationen), wird eine Interface_declaration (Schnittstellendeklarationen), wird eine Enum_declaration (Enumeration Deklarationen), oder ein Delegate_declaration (delegieren Deklarationen).A type_declaration is a class_declaration (Class declarations), a struct_declaration (Struct declarations), an interface_declaration (Interface declarations), an enum_declaration (Enum declarations), or a delegate_declaration (Delegate declarations).

type_declaration
    : class_declaration
    | struct_declaration
    | interface_declaration
    | enum_declaration
    | delegate_declaration
    ;

Ein Type_declaration kann auftreten, als eine Deklaration mit der höchsten Ebene in einer Kompilierungseinheit oder die Deklaration eines Elements in einem Namespace, Klasse oder Struktur.A type_declaration can occur as a top-level declaration in a compilation unit or as a member declaration within a namespace, class, or struct.

Wenn eine Typdeklaration für einen Typ T tritt ein, wenn eine Deklaration mit der höchsten Ebene in einer Kompilierungseinheit, der vollqualifizierte Namen des neu deklarierten Typs ist einfach T.When a type declaration for a type T occurs as a top-level declaration in a compilation unit, the fully qualified name of the newly declared type is simply T. Wenn eine Typdeklaration für einen Typ T tritt auf, in einem Namespace, Klasse oder Struktur, die den vollqualifizierten Namen des neu deklarierten Typs ist N.T, wobei N der vollqualifizierte Namen der enthaltenden Namespace, Klasse oder Struktur ist.When a type declaration for a type T occurs within a namespace, class, or struct, the fully qualified name of the newly declared type is N.T, where N is the fully qualified name of the containing namespace, class, or struct.

Ein Typ deklariert wird, innerhalb einer Klasse oder Struktur wird als geschachtelter Typ bezeichnet (geschachtelte Typen).A type declared within a class or struct is called a nested type (Nested types).

Die Zugriffs-Modifizierer und der Standardzugriff für eine Typdeklaration abhängig sind, auf dem Kontext, in dem die Deklaration erfolgt (deklariert Barrierefreiheit):The permitted access modifiers and the default access for a type declaration depend on the context in which the declaration takes place (Declared accessibility):

  • Typen in Namespaces oder einer Kompilierungseinheiten deklariert haben public oder internal Zugriff.Types declared in compilation units or namespaces can have public or internal access. Der Standardwert ist internal Zugriff.The default is internal access.
  • Typen, die in Klassen deklariert haben public, protected internal, protected, internal, oder private Zugriff.Types declared in classes can have public, protected internal, protected, internal, or private access. Der Standardwert ist private Zugriff.The default is private access.
  • In Strukturen deklarierte Typen haben public, internal, oder private Zugriff.Types declared in structs can have public, internal, or private access. Der Standardwert ist private Zugriff.The default is private access.

Namespace-Alias-QualifiziererNamespace alias qualifiers

Die Namespacealias-Qualifizierer :: ermöglicht es, sicherzustellen, dass Suchvorgänge nach Typ durch die Einführung der neuen Typen und Member sind nicht betroffen sind.The namespace alias qualifier :: makes it possible to guarantee that type name lookups are unaffected by the introduction of new types and members. Der Namespacealias-Qualifizierer wird zwischen zwei Bezeichnern, die als die linken und rechten Bezeichner bezeichnet immer angezeigt.The namespace alias qualifier always appears between two identifiers referred to as the left-hand and right-hand identifiers. Im Gegensatz zu regulären . Qualifizierer, der linke Bezeichner, der die :: Qualifizierer gesucht oben nur als eine Extern oder using-Alias.Unlike the regular . qualifier, the left-hand identifier of the :: qualifier is looked up only as an extern or using alias.

Ein Qualified_alias_member ist wie folgt definiert:A qualified_alias_member is defined as follows:

qualified_alias_member
    : identifier '::' identifier type_argument_list?
    ;

Ein Qualified_alias_member kann verwendet werden, als eine Namespace_or_type_name (Namespace und Typnamen) oder als der linke Operand in einem Member_access (Memberzugriff).A qualified_alias_member can be used as a namespace_or_type_name (Namespace and type names) or as the left operand in a member_access (Member access).

Ein Qualified_alias_member verfügt über einen von zwei Formen:A qualified_alias_member has one of two forms:

  • N::I<A1, ..., Ak>, wobei N und I Bezeichner darstellen und <A1, ..., Ak> ist eine Liste der Typargumente.N::I<A1, ..., Ak>, where N and I represent identifiers, and <A1, ..., Ak> is a type argument list. (K ist immer mindestens eine.)(K is always at least one.)
  • N::I, wobei N und I Bezeichner darstellen.N::I, where N and I represent identifiers. (In diesem Fall K gilt als 0 (null) sein.)(In this case, K is considered to be zero.)

Diese Notation, die Bedeutung des einen Qualified_alias_member wird wie folgt bestimmt:Using this notation, the meaning of a qualified_alias_member is determined as follows:

  • Wenn N ist der Bezeichner global, und klicken Sie dann der globale Namespace gesucht wird I:If N is the identifier global, then the global namespace is searched for I:

    • Wenn der globale Namespace ein Namespace, der mit dem Namen enthält I und K ist 0 (null), und klicken Sie dann die Qualified_alias_member bezieht sich auf diesen Namespace.If the global namespace contains a namespace named I and K is zero, then the qualified_alias_member refers to that namespace.
    • Wenn der globale Namespace einen nicht generischen Typ mit dem Namen enthält, andernfalls I und K ist 0 (null), und klicken Sie dann die Qualified_alias_member bezieht sich auf diesen Typ.Otherwise, if the global namespace contains a non-generic type named I and K is zero, then the qualified_alias_member refers to that type.
    • Wenn der globale Namespace einen Typ, der mit dem Namen enthält, andernfalls I , bei dem K  Typparameter, und klicken Sie dann die Qualified_alias_member bezieht sich auf diesen Typ mit den Argumenten angegebenen Typs erstellt.Otherwise, if the global namespace contains a type named I that has K type parameters, then the qualified_alias_member refers to that type constructed with the given type arguments.
    • Andernfalls die Qualified_alias_member ist nicht definiert und ein Fehler während der Kompilierung auftritt.Otherwise, the qualified_alias_member is undefined and a compile-time error occurs.
  • Dabei ist, andernfalls die Namespacedeklaration (Namespace-Deklarationen) sofort mit der Qualified_alias_member (sofern vorhanden), ausgehend mit jeder einschließenden Namespacedeklaration (falls vorhanden), und endet mit der Kompilierungseinheit, enthält die Qualified_alias_member, die folgenden Schritte werden ausgewertet, bis eine Entität befindet:Otherwise, starting with the namespace declaration (Namespace declarations) immediately containing the qualified_alias_member (if any), continuing with each enclosing namespace declaration (if any), and ending with the compilation unit containing the qualified_alias_member, the following steps are evaluated until an entity is located:

    • Wenn die Namespace-Deklaration oder Kompilierung Einheit enthält eine Using_alias_directive zuordnet, die N mit einem Typ, die Qualified_alias_member ist nicht definiert und Kompilierzeit Fehler tritt auf.If the namespace declaration or compilation unit contains a using_alias_directive that associates N with a type, then the qualified_alias_member is undefined and a compile-time error occurs.
    • Andernfalls, wenn die Namespace-Deklaration oder Kompilierung Einheit enthält eine Extern_alias_directive oder Using_alias_directive zuordnet, die N mit einem Namespace, dann:Otherwise, if the namespace declaration or compilation unit contains an extern_alias_directive or using_alias_directive that associates N with a namespace, then:
      • Wenn der Namespace zugeordnete N enthält einen Namespace mit dem Namen I und K NULL ist, wird die Qualified_alias_member bezieht sich auf diesen Namespace.If the namespace associated with N contains a namespace named I and K is zero, then the qualified_alias_member refers to that namespace.
      • Andernfalls, wenn der Namespace zugeordnete N enthält einen nicht generischen Typ mit dem Namen I und K ist 0 (null), und klicken Sie dann die Qualified_alias_member bezieht sich auf diesen Typ.Otherwise, if the namespace associated with N contains a non-generic type named I and K is zero, then the qualified_alias_member refers to that type.
      • Andernfalls, wenn der Namespace zugeordnete N enthält einen Typ mit dem Namen I , bei dem K  Typparameter, und klicken Sie dann die Qualified_alias_member bezeichnet, dass der Typ mit erstellt die angegebenen Typargumente.Otherwise, if the namespace associated with N contains a type named I that has K type parameters, then the qualified_alias_member refers to that type constructed with the given type arguments.
      • Andernfalls die Qualified_alias_member ist nicht definiert und ein Fehler während der Kompilierung auftritt.Otherwise, the qualified_alias_member is undefined and a compile-time error occurs.
  • Andernfalls die Qualified_alias_member ist nicht definiert und ein Fehler während der Kompilierung auftritt.Otherwise, the qualified_alias_member is undefined and a compile-time error occurs.

Beachten Sie, dass bewirkt, einen Fehler während der Kompilierung mit der Namespacealias-Qualifizierer, die einen Alias, der auf einen Typ verweist dass.Note that using the namespace alias qualifier with an alias that references a type causes a compile-time error. Beachten Sie, dass bei den Bezeichner N ist global, und klicken Sie dann in den globalen Namespace Suche durchgeführt wird, auch wenn es ein alias zuordnen mit global mit einem Typ oder Namespace.Also note that if the identifier N is global, then lookup is performed in the global namespace, even if there is a using alias associating global with a type or namespace.

Die Eindeutigkeit von AliasenUniqueness of aliases

Jeder Kompilierung Komponenten- und Namespace-Text enthält, einen separaten Deklarationsabschnitt für "extern" Aliase und using-Aliase.Each compilation unit and namespace body has a separate declaration space for extern aliases and using aliases. Daher zwar der Namen des einen externen Alias oder using-Alias innerhalb der Satz von "extern" Aliase eindeutig sein muss und using-Aliase in der direkt enthaltenden Kompilierung Einheit oder Namespacetext deklariert, ein Alias ist zulässig, haben den gleichen Namen wie eines Typs oder Namespaces solange ich t wird verwendet, nur mit der :: Qualifizierer.Thus, while the name of an extern alias or using alias must be unique within the set of extern aliases and using aliases declared in the immediately containing compilation unit or namespace body, an alias is permitted to have the same name as a type or namespace as long as it is used only with the :: qualifier.

Im BeispielIn the example

namespace N
{
    public class A {}

    public class B {}
}

namespace N
{
    using A = System.IO;

    class X
    {
        A.Stream s1;            // Error, A is ambiguous

        A::Stream s2;           // Ok
    }
}

der Name A hat zwei mögliche Bedeutungen in der zweiten Namespace-Text, da sowohl die Klasse A und der Alias A befinden sich im Gültigkeitsbereich.the name A has two possible meanings in the second namespace body because both the class A and the using alias A are in scope. Aus diesem Grund verwenden A im qualifizierten Namen A.Stream ist mehrdeutig und verursacht einen Fehler während der Kompilierung auftreten.For this reason, use of A in the qualified name A.Stream is ambiguous and causes a compile-time error to occur. Allerdings verwenden der A mit der :: Qualifizierer ist kein Fehler, da A wird nur als ein Namespacealias nachgeschlagen.However, use of A with the :: qualifier is not an error because A is looked up only as a namespace alias.