名前空間Namespaces

C# プログラムの名前空間を使用して構成します。C# programs are organized using namespaces. 名前空間は、"external"組織のシステムおよびプログラムは、「内部」組織システムとして使用されます-その他のプログラムに公開されているプログラム要素を表すため。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 ディレクティブ (ディレクティブを使用して) 名前空間の使用を容易に提供されます。Using directives (Using directives) are provided to facilitate the use of namespaces.

コンパイル単位Compilation units

A compilation_unitソース ファイルの全体的な構造を定義します。A compilation_unit defines the overall structure of a source file. 0 個以上のコンパイル単位で構成されますusing_directives が 0 個以上続くglobal_attributes 0 個以上続く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*
    ;

C# プログラムは 1 つまたは複数のコンパイル単位で、別のソース ファイルに含まれている各。A C# program consists of one or more compilation units, each contained in a separate source file. C# プログラムがコンパイルされると、すべてのコンパイル単位が一度に処理されます。When a C# program is compiled, all of the compilation units are processed together. そのため、コンパイル単位は互いに依存して、可能性があります、循環形式で。Thus, compilation units can depend on each other, possibly in a circular fashion.

Using_directiveコンパイル ユニットに影響の s、 global_attributesnamespace_member_declaration、そのコンパイル ユニットの s があるない影響その他のコンパイル ユニット。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.

Global_attributes (属性) コンパイル単位のターゲット アセンブリとモジュール属性の指定を許可します。The global_attributes (Attributes) of a compilation unit permit the specification of attributes for the target assembly and module. アセンブリとモジュールは、型の物理的なコンテナーとして機能します。Assemblies and modules act as physical containers for types. いくつかの物理的に独立したモジュールのアセンブリがあります。An assembly may consist of several physically separate modules.

Namespace_member_declarationプログラムのコンパイル単位ごとの s がグローバル名前空間と呼ばれる 1 つの宣言領域にメンバーを投稿します。The namespace_member_declarations of each compilation unit of a program contribute members to a single declaration space called the global namespace. 例:For example:

ファイルA.cs:File A.cs:

class A {}

ファイルB.cs:File B.cs:

class B {}

この場合、完全修飾名を持つ 2 つのクラスを宣言する 1 つのグローバル名前空間を 2 つのコンパイル単位が投稿ABします。The two compilation units contribute to the single global namespace, in this case declaring two classes with the fully qualified names A and B. 同じ宣言領域に 2 つのコンパイル単位がドキュメントに投稿されているとエラーと同じ名前のメンバーの宣言をそれぞれに含まれる場合。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.

名前空間の宣言Namespace declarations

A namespace_declarationキーワードから成るnamespace、名前空間の名前と本文で後に、必要に応じて後にセミコロンが。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* '}'
    ;

A namespace_declarationで最上位レベルの宣言と発生する可能性があります、 compilation_unitまたは別のメンバーの宣言として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. ときに、 namespace_declarationで最上位レベルの宣言と発生する、 compilation_unit、名前空間はグローバル名前空間のメンバーになります。When a namespace_declaration occurs as a top-level declaration in a compilation_unit, the namespace becomes a member of the global namespace. ときに、 namespace_declaration別内で発生namespace_declaration、内部の名前空間が外側の名前空間のメンバーになります。When a namespace_declaration occurs within another namespace_declaration, the inner namespace becomes a member of the outer namespace. どちらの場合、名前空間の名前が含まれる名前空間内で一意であります。In either case, the name of a namespace must be unique within the containing namespace.

名前空間は、暗黙的にpublicと名前空間の宣言は、アクセス修飾子を含めることはできません。Namespaces are implicitly public and the declaration of a namespace cannot include any access modifiers.

内で、 namespace_body、省略可能なusing_directives が他の名前空間、型を修飾名ではなく直接参照できるように、メンバーの名前をインポートします。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. 省略可能なnamespace_member_declarations が、名前空間の宣言領域にメンバーを投稿します。The optional namespace_member_declarations contribute members to the declaration space of the namespace. なおすべてusing_directives は、メンバー宣言の前に表示する必要があります。Note that all using_directives must appear before any member declarations.

Qualified_identifiernamespace_declaration 、単一の識別子またはシーケンスで区切られた識別子の場合があります"."トークンです。The qualified_identifier of a namespace_declaration may be a single identifier or a sequence of identifiers separated by "." tokens. 後者の形式は、構文的に複数の名前空間宣言を入れ子せず、入れ子になった名前空間を定義するプログラムを許可します。The latter form permits a program to define a nested namespace without lexically nesting several namespace declarations. 例えば以下のようにします。For example,

namespace N1.N2
{
    class A {}

    class B {}
}

同じ意味にはis semantically equivalent to

namespace N1
{
    namespace N2
    {
        class A {}

        class B {}
    }
}

名前空間は拡張可能なと同じ完全修飾名で 2 つの名前空間宣言が同じ宣言領域に投稿 (宣言)。Namespaces are open-ended, and two namespace declarations with the same fully qualified name contribute to the same declaration space (Declarations). In the example

namespace N1.N2
{
    class A {}
}

namespace N1.N2
{
    class B {}
}

ここで完全修飾の名前を持つ 2 つのクラスを宣言する、同じ宣言領域に 2 つの名前空間宣言が貢献N1.N2.AN1.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. 2 つの宣言は、同じ宣言領域に追加、ためにされていた場合は、各エラーには、同じ名前のメンバーの宣言が含まれています。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 エイリアスExtern aliases

Extern_alias_directive名前空間のエイリアスとして機能する識別子が導入されています。An extern_alias_directive introduces an identifier that serves as an alias for a namespace. エイリアスの名前空間の仕様では、プログラムのソース コードの外部にあるし、別名の名前空間の入れ子になった名前空間にも適用されます。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 ';'
    ;

スコープ、 extern_alias_directiveにわたる、 using_directives、 global_attributesnamespace_member_declarations がすぐに親のコンパイル単位または名前空間本文。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.

含むコンパイル単位または名前空間本体内で、 extern_alias_directiveで導入された識別子、 extern_alias_directiveエイリアスの名前空間を参照するために使用できます。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. コンパイル時エラーには、識別子という単語をglobalします。It is a compile-time error for the identifier to be the word global.

Extern_alias_directiveエイリアス使用可能な特定のコンパイル単位または名前空間本体の内部は、基になる宣言領域に新しいメンバーは含まれませんが、します。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. つまり、 extern_alias_directive 、推移的ではありませんが、コンパイル単位または名前空間本文のみが発生するのではなく、影響を与えます。In other words, an extern_alias_directive is not transitive, but, rather, affects only the compilation unit or namespace body in which it occurs.

次のプログラムを宣言し、2 つの extern エイリアスを使用してXY、それぞれの個別の名前空間階層のルートを表します。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;
}

プログラムは、extern の存在のエイリアスを宣言しますXYがエイリアスの実際の定義は、外部プログラムにします。The program declares the existence of the extern aliases X and Y, but the actual definitions of the aliases are external to the program. 同じ名前を持つN.Bクラスとして参照できますX.N.BY.N.B、または、名前空間エイリアス修飾子を使ってX::N.BY::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. エラーは、プログラムは、外部定義が提供 extern エイリアスを宣言する場合に発生しません。An error occurs if a program declares an extern alias for which no external definition is provided.

using ディレクティブUsing directives

Using ディレクティブ名前空間および他の名前空間で定義された型の使用を容易にします。Using directives facilitate the use of namespaces and types defined in other namespaces. ディレクティブへの影響の名前解決プロセスを使用してnamespace_or_type_names (Namespace と型の名前) とsimple_names (簡易名)、ディレクティブを使用して、宣言とは異なり、新しいメンバーのコンパイル単位または使用される名前空間の基になる宣言スペースには影響しません。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
    ;

A using_alias_directive (Using エイリアス ディレクティブ) 名前空間または型のエイリアスが導入されています。A using_alias_directive (Using alias directives) introduces an alias for a namespace or type.

A using_namespace_directive (名前空間ディレクティブを使用して) 名前空間の型のメンバーをインポートします。A using_namespace_directive (Using namespace directives) imports the type members of a namespace.

A using_static_directive (Using static ディレクティブ)、入れ子にされた型と型の静的メンバーをインポートします。A using_static_directive (Using static directives) imports the nested types and static members of a type.

スコープをusing_directiveにわたる、 namespace_member_declarations がすぐに親のコンパイル単位または名前空間本文。The scope of a using_directive extends over the namespace_member_declarations of its immediately containing compilation unit or namespace body. スコープをusing_directive具体的には、ピアは含まれませんusing_directive秒。The scope of a using_directive specifically does not include its peer using_directives. したがって、ピアusing_directives が、互いに影響しませんし、記述されている順序が重要ではありません。Thus, peer using_directives do not affect each other, and the order in which they are written is insignificant.

Using エイリアス ディレクティブUsing alias directives

A using_alias_directive名前空間またはすぐ外側のコンパイル単位または名前空間の本文内の型のエイリアスとして機能する識別子が導入されています。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 ';'
    ;

メンバー宣言が含まれるコンパイル単位または名前空間本文内で、 using_alias_directiveで導入された識別子、 using_alias_directive使用できる参照を特定名前空間または型。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. 例えば:For example:

namespace N1.N2
{
    class A {}
}

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

    class B: A {}
}

上記のメンバー宣言内で、N3名前空間、Aの別名ですN1.N2.A、クラスN3.Bクラスから派生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. 別名を作成して、同じ効果を取得できるRN1.N2し、参照する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 {}
}

識別子using_alias_directiveコンパイル単位またはすぐに含む名前空間の宣言領域内で一意である必要があります、 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. 例:For example:

namespace N3
{
    class A {}
}

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

上記N3メンバーが既に含まれていますAので、コンパイル時エラーには、 using_alias_directiveその識別子を使用します。Above, N3 already contains a member A, so it is a compile-time error for a using_alias_directive to use that identifier. 同様に、2 つ以上のコンパイル時エラーがusing_alias_directive同じコンパイル単位または名前空間に同じ名前のエイリアスを宣言する本体で s。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.

A using_alias_directiveエイリアス使用可能な特定のコンパイル単位または名前空間本体の内部は、基になる宣言領域に新しいメンバーは含まれませんが、します。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. つまり、 using_alias_directiveは推移的ではありませんが、コンパイル単位または名前空間本文のみが発生するのではなく影響を与えます。In other words, a using_alias_directive is not transitive but rather affects only the compilation unit or namespace body in which it occurs. In the example

namespace N3
{
    using R = N1.N2;
}

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

スコープ、 using_alias_directive導入するRのみが含まれる名前空間のメンバー宣言に対する拡張ようにRが 2 つ目の名前空間宣言で不明です。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. ただし、配置、 using_alias_directive含むコンパイル単位が両方の名前空間宣言内で使用可能になるエイリアス。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 {}
}

通常のメンバーと同様で導入された名前using_alias_directives は入れ子になったスコープの同じ名前のメンバーによって非表示にします。Just like regular members, names introduced by using_alias_directives are hidden by similarly named members in nested scopes. In the example

using R = N1.N2;

namespace N3
{
    class R {}

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

参照をR.Aの宣言でBので、コンパイル時エラーが発生Rを指すN3.Rではなく、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.

順序using_alias_directive有意性、およびの解像度を持たない s が書き込まれる、 namespace_or_type_nameによって参照される、 using_alias_directiveは影響されません、 using_alias_directive自体またはその他using_directiveコンパイル単位または名前空間の本体は、コンテナーで s。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. つまり、 namespace_or_type_nameusing_alias_directiveがコンパイル単位または名前空間の本体は、すぐに親があるないかのように解決されるusing_directive秒。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. A using_alias_directiveしかし、影響を受けるextern_alias_directiveコンパイル単位または名前空間の本体は、コンテナー内。A using_alias_directive may however be affected by extern_alias_directives in the immediately containing compilation unit or namespace body. In 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
}

最後のusing_alias_directive最初に影響を受けないため、コンパイル時エラー結果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. 最初のusing_alias_directive extern エイリアスのスコープから、エラーが発生しないEが含まれています、 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.

A using_alias_directive任意の名前空間またはが表示される名前空間を含む、型の別名を作成し、任意の名前空間または型は、その名前空間内に入れ子にします。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.

名前空間または型にエイリアスを使ってアクセスするには、その宣言された名前をその名前空間または型へのアクセスとまったく同じ結果が得られます。Accessing a namespace or type through an alias yields exactly the same result as accessing that namespace or type through its declared name. たとえば、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
    }
}

名前N1.N2.AR1.N2.A、およびR2.Aの完全修飾名がクラスを同等とすべて参照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.

別名を使用して構築されたクローズ型の名前をことができますが、型引数を指定せずに、バインドされていないジェネリック型の宣言の名前をことはできません。Using aliases can name a closed constructed type, but cannot name an unbound generic type declaration without supplying type arguments. 例えば: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 namespace directives

A using_namespace_directive修飾なしで使用するには、各型の識別子を有効にするとすぐにそれを囲むコンパイル単位または名前空間の本体に含まれている名前空間型をインポートします。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 ';'
    ;

メンバー宣言が含まれるコンパイル単位または名前空間本文内で、 using_namespace_directive、指定した名前空間に含まれる型を直接参照できます。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. 例:For example:

namespace N1.N2
{
    class A {}
}

namespace N3
{
    using N1.N2;

    class B: A {}
}

上記のメンバー宣言内で、N3名前空間、型のメンバーのN1.N2直接利用して、クラスN3.Bクラスから派生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.

A using_namespace_directive指定した名前空間に含まれる型をインポートしますが、具体的には入れ子になった名前空間をインポートしません。A using_namespace_directive imports the types contained in the given namespace, but specifically does not import nested namespaces. In the example

namespace N1.N2
{
    class A {}
}

namespace N3
{
    using N1;

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

using_namespace_directiveに含まれている型をインポートN1で入れ子になった名前空間ではありませんが、N1します。the using_namespace_directive imports the types contained in N1, but not the namespaces nested in N1. 参照をそのため、N2.Aの宣言でBメンバーが指定されていないため、コンパイル時エラー結果N2スコープ内にあります。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.

異なり、 using_alias_directiveusing_namespace_directiveの識別子が外側のコンパイル単位または名前空間の本文内で既に定義されている型をインポートすることがあります。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. によって名前が実際には、インポート、 using_namespace_directive外側のコンパイル単位または名前空間の本体で似た名前のメンバーでは表示されません。In effect, names imported by a using_namespace_directive are hidden by similarly named members in the enclosing compilation unit or namespace body. 例:For example:

namespace N1.N2
{
    class A {}

    class B {}
}

namespace N3
{
    using N1.N2;

    class A {}
}

ここでは、メンバー宣言内で、N3名前空間、Aを指すN3.AなくN1.N2.Aします。Here, within member declarations in the N3 namespace, A refers to N3.A rather than N1.N2.A.

によって、1 つ以上の名前空間または型がインポートするときにusing_namespace_directives またはusing_static_directive同じコンパイル単位または名前空間の本体では、同じ名前でへの参照型を含めることがその名前として、 type_nameあいまいと見なされます。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. In the example

namespace N1
{
    class A {}
}

namespace N2
{
    class A {}
}

namespace N3
{
    using N1;

    using N2;

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

両方N1N2、メンバーを含んでA、ためN3を参照する、両方をインポートAN3はコンパイル時エラーです。both N1 and N2 contain a member A, and because N3 imports both, referencing A in N3 is a compile-time error. このような状況で、競合はへの参照の修飾を使用するか解決できるA、または導入することで、 using_alias_directive特定を取得する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. 例:For example:

namespace N3
{
    using N1;

    using N2;

    using A = N1.A;

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

さらに、インポートすると 1 つ以上の名前空間または型でusing_namespace_directives またはusing_static_directive同じコンパイル単位または名前空間の本体では、型またはメンバーを含めることが、同じ名前の参照としてその名前に、 simple_nameあいまいと見なされます。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. In 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 型のメンバーが含まれていますA、およびC静的フィールドが含まれていますA、ためN2を参照する、両方をインポートAとして、 simple_nameあいまいな、コンパイル時にエラーがあります。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.

ように、 using_alias_directiveusing_namespace_directiveコンパイル単位または名前空間の基になる宣言領域に新しいメンバーは含まれませんが、代わりにのみ影響しますコンパイル単位または名前空間の本体が表示されます。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.

Namespace_nameによって参照される、 using_namespace_directiveと同じ方法で解決されて、 namespace_or_type_nameによって参照される、 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. したがって、 using_namespace_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.

Using static ディレクティブUsing static directives

A using_static_directive入れ子にされた型とする各メンバーと型の識別子を有効にする静的メンバーをすぐにそれを囲むコンパイル単位または名前空間の本体に型宣言に直接含まれているインポート修飾なしで使用します。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 ';'
    ;

メンバー宣言が含まれるコンパイル単位または名前空間本文内で、 using_static_directive型と静的メンバー (拡張メソッド) を除くの宣言に直接含まれている、アクセス可能な入れ子にします指定した型を直接参照できます。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. 例: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(); }
    }
}

上記のメンバー宣言内で、N2名前空間、静的メンバーと入れ子にされた型のN1.A直接使用できますが、およびそのため、メソッドN両方を参照することは、BMのメンバー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.

A using_static_directive具体的には、静的メソッドとして直接拡張メソッドをインポートできませんが、拡張メソッド呼び出しの使用可能になります (拡張メソッド呼び出し)。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). In 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
        }
    }
}

using_static_directive拡張メソッドをインポートMに含まれているN1.A、拡張メソッドとしてのみです。the using_static_directive imports the extension method M contained in N1.A, but only as an extension method. したがって、最初に参照されるMの本体でB.Nメンバーが指定されていないため、コンパイル時エラー結果Mスコープ内にあります。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.

A using_static_directiveのみをインポート メンバーと型指定された型で直接宣言された基本クラスで宣言されたメンバーと型ではありません。A using_static_directive only imports members and types declared directly in the given type, not members and types declared in base classes.

TODO:例TODO: Example

複数のあいまいさusing_namespace_directivesusing_static_directivesは、後ほど名前空間ディレクティブを使用してします。Ambiguities between multiple using_namespace_directives and using_static_directives are discussed in Using namespace directives.

Namespace メンバーNamespace members

A namespace_member_declarationか、 namespace_declaration (Namespace 宣言) またはtype_declaration (入力宣言)。A namespace_member_declaration is either a namespace_declaration (Namespace declarations) or a type_declaration (Type declarations).

namespace_member_declaration
    : namespace_declaration
    | type_declaration
    ;

コンパイル単位または名前空間の本文を含めることができますnamespace_member_declarationと、このような宣言は、新しいメンバーを含むコンパイル単位または名前空間の本体の基になる宣言領域を投稿します。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.

型の宣言Type declarations

A type_declarationは、 class_declaration (クラス クラスの宣言)、 struct_declaration (構造体宣言)、 interface_declaration (インターフェイスの宣言)、 enum_declaration (列挙型宣言)、またはdelegate_declaration (デリゲートの宣言)。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
    ;

A type_declarationコンパイル単位内の最上位レベルの宣言、または名前空間、クラスまたは構造体内でメンバーの宣言として発生することができます。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.

型の型宣言T新しく宣言された型の完全修飾名が単には、コンパイル単位内の最上位レベルの宣言と発生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. 型の型宣言Tクラスまたは構造体、新しく宣言された型の完全修飾名が、名前空間内で発生N.Tここで、N含んでいる名前空間、クラスまたは構造体の完全修飾の名前を指定します。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.

クラス内で宣言された型または構造体には、入れ子にされた型が呼び出された (入れ子になった型)。A type declared within a class or struct is called a nested type (Nested types).

使用できるアクセス修飾子と型の宣言の既定のアクセスを宣言が行われるコンテキストに依存 (宣言されたアクセシビリティ)。The permitted access modifiers and the default access for a type declaration depend on the context in which the declaration takes place (Declared accessibility):

  • コンパイル単位または名前空間で宣言された型を持つことができますpublicまたはinternalアクセスします。Types declared in compilation units or namespaces can have public or internal access. 既定値はinternalアクセスします。The default is internal access.
  • クラスで宣言された型を持つことができますpublicprotected internalprotectedinternal、またはprivateアクセスします。Types declared in classes can have public, protected internal, protected, internal, or private access. 既定値はprivateアクセスします。The default is private access.
  • 構造体で宣言された型を持つことができますpublicinternal、またはprivateアクセスします。Types declared in structs can have public, internal, or private access. 既定値はprivateアクセスします。The default is private access.

Namespace エイリアス修飾子Namespace alias qualifiers

名前空間エイリアス修飾子::型名の検索が新しい型とメンバーの導入によって影響を受けるいないことを保証することになります。The namespace alias qualifier :: makes it possible to guarantee that type name lookups are unaffected by the introduction of new types and members. 名前空間エイリアス修飾子は、左辺と右辺の識別子と呼ばれる 2 つの識別子の間で常に表示されます。The namespace alias qualifier always appears between two identifiers referred to as the left-hand and right-hand identifiers. 通常とは異なり.修飾子の左側の識別子、::修飾子は、参照が、extern、またはエイリアスを使用してとしてのみです。Unlike the regular . qualifier, the left-hand identifier of the :: qualifier is looked up only as an extern or using alias.

A qualified_alias_memberが次のように定義されています。A qualified_alias_member is defined as follows:

qualified_alias_member
    : identifier '::' identifier type_argument_list?
    ;

A qualified_alias_memberとして使用できる、 namespace_or_type_name (Namespace と型の名前) またはの左辺のオペランドとして、 member_access(メンバー アクセス)。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).

A qualified_alias_memberが 2 つの形式のいずれか。A qualified_alias_member has one of two forms:

  • N::I<A1, ..., Ak>、、NI、識別子を表すと<A1, ..., Ak>が型引数リスト。N::I<A1, ..., Ak>, where N and I represent identifiers, and <A1, ..., Ak> is a type argument list. (Kは常に少なくとも 1 つです)。(K is always at least one.)
  • N::I、、NI識別子を表します。N::I, where N and I represent identifiers. (この場合、 K 0 と見なされます)。(In this case, K is considered to be zero.)

意味、この表記を使用して、 qualified_alias_memberは次のように決定されます。Using this notation, the meaning of a qualified_alias_member is determined as follows:

  • 場合N識別子global、グローバル名前空間を検索し、 I:If N is the identifier global, then the global namespace is searched for I:

    • グローバル名前空間には、名前空間が含まれている場合 IK0 の場合は、次に、 qualified_alias_memberその名前空間を参照します。If the global namespace contains a namespace named I and K is zero, then the qualified_alias_member refers to that namespace.
    • それ以外の場合、グローバル名前空間には、という名前の非ジェネリック型が含まれている場合 IK0 の場合は、次に、 qualified_alias_memberはその型を表します。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.
    • それ以外の場合、グローバル名前空間には、という名前の型が含まれている場合 Iを持つK パラメーター、入力、 qualified_alias_memberは特定の型引数を使用して構築する型を表します。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.
    • それ以外の場合、 qualified_alias_memberは未定義となり、コンパイル時エラーが発生します。Otherwise, the qualified_alias_member is undefined and a compile-time error occurs.
  • それ以外の場合、名前空間の宣言で始まる (Namespace 宣言) 含まれている、 qualified_alias_member (ある場合)、それを囲む各名前空間宣言で継続的(ある場合) を含むコンパイル単位で終わる、 qualified_alias_memberエンティティが見つかるまで、次の手順が評価されます。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:

    • 名前空間の宣言またはコンパイル ユニットに含まれる場合、 using_alias_directiveを関連付けるN型を持つ、 qualified_alias_memberが定義されていないと、コンパイル時エラーが発生します。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.
    • それ以外の場合、名前空間の宣言またはコンパイル ユニットに含まれる場合、 extern_alias_directiveまたはusing_alias_directiveを関連付けるN名前空間、しに。Otherwise, if the namespace declaration or compilation unit contains an extern_alias_directive or using_alias_directive that associates N with a namespace, then:
      • 名前空間に関連付けられている場合Nという名前空間が含まれています IK0 の場合は、次に、 qualified_alias_memberその名前空間を参照します。If the namespace associated with N contains a namespace named I and K is zero, then the qualified_alias_member refers to that namespace.
      • それ以外の場合、名前空間に関連付けられている場合Nという名前の非ジェネリック型が含まれています IK0 の場合は、次に、 qualified_alias_memberはその型を表します。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.
      • それ以外の場合、名前空間に関連付けられている場合Nという名前の型が含まれています Iを持つK パラメーターを入力し、 qualified_alias_memberを持つ型を構築するには指定された型引数。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.
      • それ以外の場合、 qualified_alias_memberは未定義となり、コンパイル時エラーが発生します。Otherwise, the qualified_alias_member is undefined and a compile-time error occurs.
  • それ以外の場合、 qualified_alias_memberは未定義となり、コンパイル時エラーが発生します。Otherwise, the qualified_alias_member is undefined and a compile-time error occurs.

型を参照するエイリアスで名前空間エイリアス修飾子を使用して、コンパイル時エラーが発生に注意してください。Note that using the namespace alias qualifier with an alias that references a type causes a compile-time error. いる場合に、id をメモ Nglobal、使用してエイリアスに関連付けることがある場合でも、グローバル名前空間で検索を実行し、global型または名前空間。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.

エイリアスの一意性Uniqueness of aliases

各コンパイル単位と名前空間の本体がの extern エイリアスを別の宣言領域とエイリアスを使用します。Each compilation unit and namespace body has a separate declaration space for extern aliases and using aliases. そのため、エイリアスを使用してまたは extern エイリアスの名前は、extern エイリアスのセット内で一意である必要があります、すぐに親のコンパイル単位または名前空間の本体で宣言されたエイリアスを使用して、エイリアスが型または名前空間の長さと同じ名前を持つことができますはt はでのみ使用、::修飾子。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.

In 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
    }
}

名前Aため、2 つ目の名前空間の 2 つの可能性のある意味を持つクラスにもAを使用して、およびエイリアスAスコープ内にあります。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. このため、使用A修飾名でA.Streamがあいまいであり、コンパイル時エラーが発生します。For this reason, use of A in the qualified name A.Stream is ambiguous and causes a compile-time error to occur. ただしの使用Aで、::修飾子エラーではないため、A名前空間の別名としてのみを検索します。However, use of A with the :: qualifier is not an error because A is looked up only as a namespace alias.