基本的な概念Basic concepts

アプリケーションの起動Application Startup

アセンブリが、エントリ ポイントと呼ばれますが、アプリケーションします。An assembly that has an entry point is called an application. ときに、アプリケーションは、実行、新しいアプリケーション ドメインが作成されます。When an application is run, a new application domain is created. 同時に、アプリケーションのいくつかの異なるインスタンス化が同じコンピューターに存在して、それぞれが独自のアプリケーション ドメイン。Several different instantiations of an application may exist on the same machine at the same time, and each has its own application domain.

アプリケーション ドメインでは、アプリケーションの状態のコンテナーとして機能するによって、アプリケーション分離を実現します。An application domain enables application isolation by acting as a container for application state. アプリケーション ドメインは、コンテナーと、アプリケーションと、使用するクラス ライブラリで定義された型の境界として機能します。An application domain acts as a container and boundary for the types defined in the application and the class libraries it uses. 1 つのアプリケーション ドメインに読み込まれた型は別のアプリケーション ドメインに読み込まれる同じ種類の異なると、オブジェクトのインスタンスは直接のアプリケーション ドメイン間で共有されません。Types loaded into one application domain are distinct from the same type loaded into another application domain, and instances of objects are not directly shared between application domains. たとえば、各アプリケーション ドメインは、これらの型の静的変数の独自のコピーと、型の静的コンス トラクターはアプリケーション ドメインごとに最大 1 回実行します。For instance, each application domain has its own copy of static variables for these types, and a static constructor for a type is run at most once per application domain. 実装では、作成とアプリケーション ドメインの破棄の実装に固有のポリシーまたはメカニズムを提供する無料です。Implementations are free to provide implementation-specific policy or mechanisms for the creation and destruction of application domains.

アプリケーションの起動実行環境がアプリケーションのエントリ ポイントと呼ばれる、指定されたメソッドを呼び出すときに発生します。Application startup occurs when the execution environment calls a designated method, which is referred to as the application's entry point. このエントリ ポイント メソッドの名前は常にMain、次のシグネチャのいずれかを指定できます。This entry point method is always named Main, and can have one of the following signatures:

static void Main() {...}

static void Main(string[] args) {...}

static int Main() {...}

static int Main(string[] args) {...}

エントリ ポイントが必要に応じて返す可能性がありますに示すように、int値。As shown, the entry point may optionally return an int value. これでアプリケーションの終了値が使用されますが返されます (アプリケーションの終了)。This return value is used in application termination (Application termination).

エントリ ポイントは、1 つの仮パラメーターを必要に応じてがあります。The entry point may optionally have one formal parameter. パラメーターは、任意の名前を必要がありますが、パラメーターの型である必要がありますstring[]します。The parameter may have any name, but the type of the parameter must be string[]. 実行環境を作成し、渡します仮パラメーターが存在する場合、string[]されたコマンドライン引数を含む引数は、アプリケーションが開始された日時を指定します。If the formal parameter is present, the execution environment creates and passes a string[] argument containing the command-line arguments that were specified when the application was started. string[]引数が null ではありませんが、コマンドライン引数が指定されていない場合、長さ 0 の可能性があります。The string[] argument is never null, but it may have a length of zero if no command-line arguments were specified.

C# メソッドのオーバー ロードをサポートするためクラスまたは構造体を含めることはいくつかのメソッドの複数の定義それぞれがある異なるシグネチャで提供されます。Since C# supports method overloading, a class or struct may contain multiple definitions of some method, provided each has a different signature. ただし、1 つのプログラム内でクラスまたは構造体ことないという 1 つ以上のメソッドがMainの定義が適用されるアプリケーションのエントリ ポイントとして使用されるようにします。However, within a single program, no class or struct may contain more than one method called Main whose definition qualifies it to be used as an application entry point. 他のオーバー ロードされたバージョンのMainは許可されて、ただし、1 つ以上のパラメーター、または型以外の唯一のパラメーターは、提供されるstring[]します。Other overloaded versions of Main are permitted, however, provided they have more than one parameter, or their only parameter is other than type string[].

アプリケーションは、複数のクラスまたは構造体の構成できます。An application can be made up of multiple classes or structs. 呼び出されるメソッドを格納するこれらのクラスまたは構造体の 1 つ以上のことはMainの定義が適用されるアプリケーションのエントリ ポイントとして使用されるようにします。It is possible for more than one of these classes or structs to contain a method called Main whose definition qualifies it to be used as an application entry point. このような場合は、次のいずれかを選択する (コマンド ライン コンパイラ オプション) などの外部メカニズムを使用する必要がありますMainエントリ ポイントとしてメソッド。In such cases, an external mechanism (such as a command-line compiler option) must be used to select one of these Main methods as the entry point.

C# でクラスまたは構造体のメンバーとしてすべてのメソッドを定義する必要があります。In C#, every method must be defined as a member of a class or struct. 通常、宣言されたアクセシビリティ (宣言されたアクセシビリティ) メソッドのアクセス修飾子によって決定されます (アクセス修飾子)、その宣言と同様に宣言で指定されました。型のアクセシビリティは、その宣言で指定されたアクセス修飾子によって決定されます。Ordinarily, the declared accessibility (Declared accessibility) of a method is determined by the access modifiers (Access modifiers) specified in its declaration, and similarly the declared accessibility of a type is determined by the access modifiers specified in its declaration. 指定された型の特定のメソッドを呼び出せるようにする、型とメンバーの両方必要がありますでアクセスできます。In order for a given method of a given type to be callable, both the type and the member must be accessible. ただし、アプリケーションのエントリ ポイントは、特殊なケースです。However, the application entry point is a special case. 具体的には、実行環境は、宣言されたアクセシビリティに関係なく、その外側の型宣言の宣言されたアクセシビリティに関係なく、アプリケーションのエントリ ポイントにアクセスできます。Specifically, the execution environment can access the application's entry point regardless of its declared accessibility and regardless of the declared accessibility of its enclosing type declarations.

アプリケーションのエントリ ポイント メソッドがジェネリック クラス宣言でできないがあります。The application entry point method may not be in a generic class declaration.

その他のすべての点は、エントリ ポイント メソッドは、エントリ ポイントではないよう動作します。In all other respects, entry point methods behave like those that are not entry points.

アプリケーションの終了Application termination

アプリケーションの終了実行環境にコントロールを返します。Application termination returns control to the execution environment.

戻り値の型のアプリケーションの場合エントリ ポイントメソッドはint、返される値は、アプリケーションの終了ステータス コードします。If the return type of the application's entry point method is int, the value returned serves as the application's termination status code. このコードでは、成功または失敗、実行時環境への通信を許可します。The purpose of this code is to allow communication of success or failure to the execution environment.

エントリ ポイント メソッドの戻り値の型がある場合void、右中かっこに到達 (}) を終了するメソッド、またはを実行する、return式を持たないステートメントの結果の終了ステータス コード0します。If the return type of the entry point method is void, reaching the right brace (}) which terminates that method, or executing a return statement that has no expression, results in a termination status code of 0.

このようなクリーンアップが中止された場合を除き、アプリケーションの終了前にすべてのガベージ コレクションをまだしていないオブジェクトのデストラクターが呼び出されます (ライブラリのメソッドを呼び出してGC.SuppressFinalizeなど)。Prior to an application's termination, destructors for all of its objects that have not yet been garbage collected are called, unless such cleanup has been suppressed (by a call to the library method GC.SuppressFinalize, for example).

宣言Declarations

C# プログラム内の宣言では、プログラムの構成要素を定義します。Declarations in a C# program define the constituent elements of the program. 名前空間を使用して c# プログラムの構成 (名前空間)、型を含めることができる宣言と入れ子になった名前空間を宣言します。C# programs are organized using namespaces (Namespaces), which can contain type declarations and nested namespace declarations. 型宣言 (入力宣言) クラスを定義するために使用されます (クラス)、構造体 (構造体)、インターフェイス (インターフェイス)、列挙型 (列挙型)、およびデリゲート (デリゲート)。Type declarations (Type declarations) are used to define classes (Classes), structs (Structs), interfaces (Interfaces), enums (Enums), and delegates (Delegates). 型の宣言でメンバーの種類は、型宣言の形式に依存します。The kinds of members permitted in a type declaration depend on the form of the type declaration. たとえば、クラス宣言が定数の宣言を含めることができます (定数)、フィールド (フィールド)、メソッド (メソッド)、プロパティ (プロパティ)、イベント (イベント)、インデクサー (インデクサー)、演算子 (演算子)、インスタンス コンス トラクター (インスタンス コンス トラクター)、静的コンス トラクター (静的コンス トラクター)、デストラクター (デストラクター)、入れ子にされた型と (入れ子になった型).For instance, class declarations can contain declarations for constants (Constants), fields (Fields), methods (Methods), properties (Properties), events (Events), indexers (Indexers), operators (Operators), instance constructors (Instance constructors), static constructors (Static constructors), destructors (Destructors), and nested types (Nested types).

宣言内の名前を定義する、宣言領域宣言が属しています。A declaration defines a name in the declaration space to which the declaration belongs. 以外のメンバーはオーバー ロード (シグネチャとオーバー ロード)、宣言領域内の同じ名前のメンバーを導入する 2 つ以上の宣言すると、コンパイル時エラーします。Except for overloaded members (Signatures and overloading), it is a compile-time error to have two or more declarations that introduce members with the same name in a declaration space. さまざまな種類の同じ名前を持つメンバーを格納する宣言領域のことはできません。It is never possible for a declaration space to contain different kinds of members with the same name. たとえば、宣言領域が含まれないことフィールドとメソッドを同じ名前。For example, a declaration space can never contain a field and a method by the same name.

さまざまな種類の宣言のスペースがある、次に示すようにします。There are several different types of declaration spaces, as described in the following.

  • プログラムのすべてのソース ファイル内でnamespace_member_declarationを囲むありませんnamespace_declarationという 1 つの結合された宣言領域のメンバーである、グローバル宣言領域します。Within all source files of a program, namespace_member_declarations with no enclosing namespace_declaration are members of a single combined declaration space called the global declaration space.
  • プログラムのすべてのソース ファイル内でnamespace_member_declarationnamespace_declarations 同じ完全修飾名前空間の名前を持つ 1 つの結合された宣言のメンバーであります。領域。Within all source files of a program, namespace_member_declarations within namespace_declarations that have the same fully qualified namespace name are members of a single combined declaration space.
  • 各クラス、構造体、またはインターフェイスの宣言は、新しい宣言領域を作成します。Each class, struct, or interface declaration creates a new declaration space. この宣言領域に名前が導入class_member_declarations、 struct_member_declarations、 interface_member_declarations、またはtype_parameter秒。Names are introduced into this declaration space through class_member_declarations, struct_member_declarations, interface_member_declarations, or type_parameters. オーバー ロードされたコンス トラクターを除く宣言と宣言、クラスまたは構造体の静的コンス トラクターは、クラスまたは構造体と同じ名前のメンバーの宣言を含めることはできません。Except for overloaded instance constructor declarations and static constructor declarations, a class or struct cannot contain a member declaration with the same name as the class or struct. クラス、構造体、またはインターフェイスは、オーバー ロードされたメソッドとインデクサーの宣言を許可します。A class, struct, or interface permits the declaration of overloaded methods and indexers. さらに、クラスまたは構造体は、オーバー ロードされたインスタンスのコンス トラクターと演算子の宣言を許可します。Furthermore, a class or struct permits the declaration of overloaded instance constructors and operators. たとえば、クラス、構造体、またはインターフェイス含めることができます、同じ名前を持つ複数のメソッド宣言のシグネチャでこれらのメソッド宣言が異なるので (シグネチャとオーバー ロード)。For example, a class, struct, or interface may contain multiple method declarations with the same name, provided these method declarations differ in their signature (Signatures and overloading). 基底クラスは、クラスの宣言領域には影響しません、基本インターフェイスは、インターフェイスの宣言領域に関係のないことに注意してください。Note that base classes do not contribute to the declaration space of a class, and base interfaces do not contribute to the declaration space of an interface. したがって、派生クラスまたはインターフェイスは継承メンバーと同じ名前のメンバーを宣言できます。Thus, a derived class or interface is allowed to declare a member with the same name as an inherited member. このようなメンバーといいますを非表示に継承されたメンバー。Such a member is said to hide the inherited member.
  • 各デリゲート宣言では、新しい宣言領域を作成します。Each delegate declaration creates a new declaration space. 仮パラメーターでは、この宣言領域に名前が導入 (fixed_parameters と括らs) とtype_parameter秒。Names are introduced into this declaration space through formal parameters (fixed_parameters and parameter_arrays) and type_parameters.
  • 各列挙体の宣言は、新しい宣言領域を作成します。Each enumeration declaration creates a new declaration space. この宣言領域に名前が導入enum_member_declarationsします。Names are introduced into this declaration space through enum_member_declarations.
  • 各メソッドの宣言、インデクサーの宣言、演算子の宣言、インスタンス コンス トラクターの宣言および匿名関数の作成と呼ばれる新しい宣言領域、ローカル変数の宣言領域します。Each method declaration, indexer declaration, operator declaration, instance constructor declaration and anonymous function creates a new declaration space called a local variable declaration space. 仮パラメーターでは、この宣言領域に名前が導入 (fixed_parameters と括らs) とtype_parameter秒。Names are introduced into this declaration space through formal parameters (fixed_parameters and parameter_arrays) and type_parameters. 関数メンバーまたは匿名関数の本体、存在する場合と見なされます、ローカル変数の宣言領域内で入れ子にします。The body of the function member or anonymous function, if any, is considered to be nested within the local variable declaration space. ローカル変数の宣言領域と同じ名前の要素を格納するローカル変数の宣言を入れ子になった領域エラーになります。It is an error for a local variable declaration space and a nested local variable declaration space to contain elements with the same name. したがって、入れ子になった宣言領域の外側の宣言領域で、ローカル変数またはローカル変数と同じ名前の定数または定数を宣言することはできません。Thus, within a nested declaration space it is not possible to declare a local variable or constant with the same name as a local variable or constant in an enclosing declaration space. どちらの宣言領域に、もう一方が含まれている限り、同じ名前の要素を格納する 2 つの宣言スペースのことができます。It is possible for two declaration spaces to contain elements with the same name as long as neither declaration space contains the other.
  • ブロックまたはswitch_blockと同様に、foreachを使用してステートメントでは、作成します。ローカル変数とローカル定数のローカル変数の宣言領域です。Each block or switch_block , as well as a for, foreach and using statement, creates a local variable declaration space for local variables and local constants . この宣言領域に名前が導入local_variable_declarations とlocal_constant_declaration秒。Names are introduced into this declaration space through local_variable_declarations and local_constant_declarations. として、または関数のメンバーまたは匿名関数の本文内で発生するブロックがそのパラメーターに対してこれらの関数によって宣言されたローカル変数の宣言領域内で入れ子にされていることに注意してください。Note that blocks that occur as or within the body of a function member or anonymous function are nested within the local variable declaration space declared by those functions for their parameters. そのため、エラーにローカル変数と同じ名前のパラメーターのメソッドになどになります。Thus it is an error to have e.g. a method with a local variable and a parameter of the same name.
  • ブロックまたはswitch_blockラベルの別の宣言領域を作成します。Each block or switch_block creates a separate declaration space for labels. この宣言領域に名前が導入labeled_statement秒、および名前がを通じて参照goto_statements。Names are introduced into this declaration space through labeled_statements, and the names are referenced through goto_statements. 宣言領域にラベルを付けるブロックの入れ子になったブロックが含まれています。The label declaration space of a block includes any nested blocks. したがって、入れ子になったブロックの外側のブロックのラベルと同じ名前のラベルを宣言することはできません。Thus, within a nested block it is not possible to declare a label with the same name as a label in an enclosing block.

名が宣言されているテキストの順序は、一般にあまり意味はありません。The textual order in which names are declared is generally of no significance. 具体的には、テキストの順序は、宣言と名前空間、定数、メソッド、プロパティ、イベント、インデクサー、演算子、インスタンス コンス トラクター、デストラクター、静的コンス トラクター、および種類の意味ではありません。In particular, textual order is not significant for the declaration and use of namespaces, constants, methods, properties, events, indexers, operators, instance constructors, destructors, static constructors, and types. 宣言の順序は、次の方法で重要です。Declaration order is significant in the following ways:

  • フィールドの宣言とローカル変数宣言の宣言の順序は、(ある場合) には、初期化子が実行される順序を決定します。Declaration order for field declarations and local variable declarations determines the order in which their initializers (if any) are executed.
  • 使用されるように、ローカル変数を定義する必要があります (スコープ)。Local variables must be defined before they are used (Scopes).
  • 列挙型メンバーの宣言の宣言の順序 (列挙型メンバー) ときに、大きなconstant_expression値が省略されます。Declaration order for enum member declarations (Enum members) is significant when constant_expression values are omitted.

名前空間の宣言領域は、"終了"開き、2 つの名前空間と同じ完全修飾名の宣言が同じ宣言領域を構成します。The declaration space of a namespace is "open ended", and two namespace declarations with the same fully qualified name contribute to the same declaration space. 次に例を示します。For example

namespace Megacorp.Data
{
    class Customer
    {
        ...
    }
}

namespace Megacorp.Data
{
    class Order
    {
        ...
    }
}

ここで完全修飾の名前を持つ 2 つのクラスを宣言する、同じ宣言領域に 2 つの名前空間宣言が貢献Megacorp.Data.CustomerMegacorp.Data.Orderします。The two namespace declarations above contribute to the same declaration space, in this case declaring two classes with the fully qualified names Megacorp.Data.Customer and Megacorp.Data.Order. 同じ宣言領域に 2 つの宣言がドキュメントに投稿するためにはエラーが発生、コンパイル時場合と同じ名前のクラスの宣言が含まれている各します。Because the two declarations contribute to the same declaration space, it would have caused a compile-time error if each contained a declaration of a class with the same name.

上で指定した、ブロックの宣言領域には、任意の入れ子になったブロックが含まれています。As specified above, the declaration space of a block includes any nested blocks. したがって、次の例で、FGメソッドがコンパイル時エラーが発生するため、名前iは外側のブロックで宣言されており、内側のブロックで再宣言することはできません。Thus, in the following example, the F and G methods result in a compile-time error because the name i is declared in the outer block and cannot be redeclared in the inner block. ただし、HIメソッドは、2 つから有効なiの入れ子になっていない別のブロックで宣言されます。However, the H and I methods are valid since the two i's are declared in separate non-nested blocks.

class A
{
    void F() {
        int i = 0;
        if (true) {
            int i = 1;            
        }
    }

    void G() {
        if (true) {
            int i = 0;
        }
        int i = 1;                
    }

    void H() {
        if (true) {
            int i = 0;
        }
        if (true) {
            int i = 1;
        }
    }

    void I() {
        for (int i = 0; i < 10; i++)
            H();
        for (int i = 0; i < 10; i++)
            H();
    }
}

メンバーMembers

名前空間と型がメンバーします。Namespaces and types have members. エンティティのメンバーは、一般提供開始後に、エンティティへの参照で始まる修飾名を使用して、"."トークン、その後に、メンバーの名前。The members of an entity are generally available through the use of a qualified name that starts with a reference to the entity, followed by a "." token, followed by the name of the member.

型のメンバーが型の宣言で宣言されたか、または継承型の基本クラスから。Members of a type are either declared in the type declaration or inherited from the base class of the type. 型が基本クラス、インスタンス コンス トラクター、デストラクター、および静的コンス トラクターを除く、基底クラスのすべてのメンバーから継承する場合は、派生型のメンバーになります。When a type inherits from a base class, all members of the base class, except instance constructors, destructors and static constructors, become members of the derived type. 基底クラスのメンバーの宣言されたアクセシビリティは、メンバーが継承されるかどうかを制御しません-継承は、インスタンス コンス トラクター、静的コンス トラクターまたはデストラクター以外の任意のメンバーを拡張します。The declared accessibility of a base class member does not control whether the member is inherited—inheritance extends to any member that isn't an instance constructor, static constructor, or destructor. ただし、継承されたメンバーをアクセスできない派生型で宣言されたアクセシビリティのいずれかで (宣言されたアクセシビリティ)、型自体で宣言によって非表示になっているため、または (を非表示継承)。However, an inherited member may not be accessible in a derived type, either because of its declared accessibility (Declared accessibility) or because it is hidden by a declaration in the type itself (Hiding through inheritance).

Namespace メンバーNamespace members

名前空間とそれを囲む名前空間を持たない型のメンバーである、グローバル名前空間します。Namespaces and types that have no enclosing namespace are members of the global namespace. これは、グローバル宣言領域で宣言された名前に直接対応します。This corresponds directly to the names declared in the global declaration space.

名前空間と名前空間内で宣言された型は、その名前空間のメンバーです。Namespaces and types declared within a namespace are members of that namespace. これは、名前空間の宣言領域で宣言された名前に直接対応します。This corresponds directly to the names declared in the declaration space of the namespace.

名前空間には、アクセス制限がありません。Namespaces have no access restrictions. プライベート、プロテクト、または内部の名前空間を宣言することはできませんし、名前空間の名前はパブリックにアクセスできる、常にします。It is not possible to declare private, protected, or internal namespaces, and namespace names are always publicly accessible.

構造体のメンバーStruct members

構造体のメンバーは、構造体で宣言されたメンバーと、構造体の直接基底クラスから継承されたメンバーSystem.ValueType間接基底クラスとobjectします。The members of a struct are the members declared in the struct and the members inherited from the struct's direct base class System.ValueType and the indirect base class object.

単純型のメンバーは、単純型によって構造体の型エイリアスのメンバーに直接対応しています。The members of a simple type correspond directly to the members of the struct type aliased by the simple type:

  • メンバーsbyteのメンバーである、System.SByte構造体。The members of sbyte are the members of the System.SByte struct.
  • メンバーbyteのメンバーである、System.Byte構造体。The members of byte are the members of the System.Byte struct.
  • メンバーshortのメンバーである、System.Int16構造体。The members of short are the members of the System.Int16 struct.
  • メンバーushortのメンバーである、System.UInt16構造体。The members of ushort are the members of the System.UInt16 struct.
  • メンバーintのメンバーである、System.Int32構造体。The members of int are the members of the System.Int32 struct.
  • メンバーuintのメンバーである、System.UInt32構造体。The members of uint are the members of the System.UInt32 struct.
  • メンバーlongのメンバーである、System.Int64構造体。The members of long are the members of the System.Int64 struct.
  • メンバーulongのメンバーである、System.UInt64構造体。The members of ulong are the members of the System.UInt64 struct.
  • メンバーcharのメンバーである、System.Char構造体。The members of char are the members of the System.Char struct.
  • メンバーfloatのメンバーである、System.Single構造体。The members of float are the members of the System.Single struct.
  • メンバーdoubleのメンバーである、System.Double構造体。The members of double are the members of the System.Double struct.
  • メンバーdecimalのメンバーである、System.Decimal構造体。The members of decimal are the members of the System.Decimal struct.
  • メンバーboolのメンバーである、System.Boolean構造体。The members of bool are the members of the System.Boolean struct.

列挙型メンバーEnumeration members

列挙体のメンバーは、列挙体で宣言された定数と列挙型の直接基底クラスから継承されたメンバーSystem.Enumと間接基底クラスSystem.ValueTypeobjectします。The members of an enumeration are the constants declared in the enumeration and the members inherited from the enumeration's direct base class System.Enum and the indirect base classes System.ValueType and object.

クラス メンバーClass members

クラスのメンバーは、クラスで宣言されたメンバーと基本クラスから継承されたメンバー (クラスを除くobjectする基本クラスがありません)。The members of a class are the members declared in the class and the members inherited from the base class (except for class object which has no base class). 基本クラスから継承されたメンバーには、定数、フィールド、メソッド、プロパティ、イベント、インデクサー、演算子、および、基底クラスですがない、インスタンス コンス トラクター、デストラクターおよび基底クラスの静的コンス トラクターの型が含まれます。The members inherited from the base class include the constants, fields, methods, properties, events, indexers, operators, and types of the base class, but not the instance constructors, destructors and static constructors of the base class. アクセシビリティに関係なく、基本クラスのメンバーが継承されます。Base class members are inherited without regard to their accessibility.

クラス宣言では、定数、フィールド、メソッド、プロパティ、イベント、インデクサー、演算子、インスタンス コンス トラクター、デストラクター、静的コンス トラクターと型の宣言を含めることができます。A class declaration may contain declarations of constants, fields, methods, properties, events, indexers, operators, instance constructors, destructors, static constructors and types.

メンバーobjectstringに直接対応して、クラス型のメンバーがエイリアス。The members of object and string correspond directly to the members of the class types they alias:

  • メンバーobjectのメンバーである、System.Objectクラス。The members of object are the members of the System.Object class.
  • メンバーstringのメンバーである、System.Stringクラス。The members of string are the members of the System.String class.

インターフェイスのメンバーInterface members

インターフェイスのメンバーは、インターフェイス、およびインターフェイスのすべての基本インターフェイスで宣言されたメンバーです。The members of an interface are the members declared in the interface and in all base interfaces of the interface. クラスでメンバーobject厳密に言うと、任意のインターフェイスのメンバーは使用されません (インターフェイスのメンバー)。The members in class object are not, strictly speaking, members of any interface (Interface members). ただし、クラスでメンバーobjectは任意のインターフェイス型でメンバーの検索で利用できます (メンバー ルックアップ)。However, the members in class object are available via member lookup in any interface type (Member lookup).

配列メンバーArray members

配列のメンバーは、クラスから継承されたメンバーSystem.Arrayします。The members of an array are the members inherited from class System.Array.

デリゲートのメンバーDelegate members

デリゲートのメンバーは、クラスから継承されたメンバーSystem.Delegateします。The members of a delegate are the members inherited from class System.Delegate.

メンバー アクセス。Member access

メンバーの宣言では、メンバー アクセス制御を許可します。Declarations of members allow control over member access. メンバーのアクセシビリティが宣言されたアクセシビリティで確立されます (宣言されたアクセシビリティ) メンバーのアクセシビリティとの組み合わせ、すぐにそれを含む型の存在する場合。The accessibility of a member is established by the declared accessibility (Declared accessibility) of the member combined with the accessibility of the immediately containing type, if any.

特定のメンバーへのアクセスを許可すると、メンバーがあると言います。アクセスします。When access to a particular member is allowed, the member is said to be accessible. 逆に、特定のメンバーへのアクセスが許可されていない場合、メンバー言いますアクセスできないします。Conversely, when access to a particular member is disallowed, the member is said to be inaccessible. アクセシビリティ ドメインにアクセスが行われる場所が含まれている場合、メンバーへのアクセスが許可されて (アクセシビリティ ドメイン) のメンバー。Access to a member is permitted when the textual location in which the access takes place is included in the accessibility domain (Accessibility domains) of the member.

アクセシビリティの宣言Declared accessibility

宣言されたアクセシビリティメンバーのことができますが、次のいずれか。The declared accessibility of a member can be one of the following:

  • パブリックで、含めることでが選択されている、publicメンバーの宣言での修飾子。Public, which is selected by including a public modifier in the member declaration. 直感的な意味public「アクセスは制限されません」です。The intuitive meaning of public is "access not limited".
  • 保護をオンになっていますを含めることによって、protectedメンバーの宣言での修飾子。Protected, which is selected by including a protected modifier in the member declaration. 直感的な意味protectedが"アクセスはコンテナーのクラスまたは型に制限されます、コンテナー クラスから派生"。The intuitive meaning of protected is "access limited to the containing class or types derived from the containing class".
  • 内部で、含めることでが選択されている、internalメンバーの宣言での修飾子。Internal, which is selected by including an internal modifier in the member declaration. 直感的な意味internal「このプログラムにだけがアクセス」。The intuitive meaning of internal is "access limited to this program".
  • プロテクト内部 (つまり、protected、または内部) 両方を含めることによってこれが選択されている、protectedinternalメンバーの宣言に修飾子。Protected internal (meaning protected or internal), which is selected by including both a protected and an internal modifier in the member declaration. 直感的な意味protected internalが「このプログラムにだけがアクセスまたは含んでいるクラスから派生した型」です。The intuitive meaning of protected internal is "access limited to this program or types derived from the containing class".
  • プライベートで、含めることでが選択されている、privateメンバーの宣言での修飾子。Private, which is selected by including a private modifier in the member declaration. 直感的な意味private「を含んでいる型だけがアクセス」。The intuitive meaning of private is "access limited to the containing type".

メンバーの宣言をコンテキストに応じて配置、宣言されたアクセシビリティの特定の種類のみが許可されます。Depending on the context in which a member declaration takes place, only certain types of declared accessibility are permitted. さらに、メンバーの宣言に、アクセス修飾子が含まれていない場合、宣言が行われるコンテキストには、既定の宣言されたアクセシビリティが決まります。Furthermore, when a member declaration does not include any access modifiers, the context in which the declaration takes place determines the default declared accessibility.

  • 名前空間が暗黙的がpublicアクセシビリティを宣言します。Namespaces implicitly have public declared accessibility. 名前空間の宣言では、アクセス修飾子は許可されません。No access modifiers are allowed on namespace declarations.
  • コンパイル単位または名前空間で宣言された型を持つことができますpublicまたはinternalアクセシビリティおよび既定値は宣言されているinternalアクセシビリティを宣言します。Types declared in compilation units or namespaces can have public or internal declared accessibility and default to internal declared accessibility.
  • クラスのメンバーが宣言されたアクセシビリティの 5 種類のいずれかがあるし、する既定のprivateアクセシビリティを宣言します。Class members can have any of the five kinds of declared accessibility and default to private declared accessibility. (を型として宣言されたクラスのメンバーが宣言されたアクセシビリティの 5 種類のいずれかを持つことができますのみ名前空間のメンバーは、宣言された型に対してに注意してくださいpublicまたはinternalアクセシビリティで宣言されています。)。(Note that a type declared as a member of a class can have any of the five kinds of declared accessibility, whereas a type declared as a member of a namespace can have only public or internal declared accessibility.)
  • 構造体のメンバーが持つことができますpublicinternal、またはprivateアクセシビリティおよび既定値は宣言されているprivate構造体は暗黙的にシールされているため、アクセシビリティを宣言します。Struct members can have public, internal, or private declared accessibility and default to private declared accessibility because structs are implicitly sealed. 構造体のメンバー (には、その構造体によって継承されません) 構造体で導入されたことはできませんprotectedまたはprotected internalアクセシビリティを宣言します。Struct members introduced in a struct (that is, not inherited by that struct) cannot have protected or protected internal declared accessibility. (構造体のメンバーであることができますが型に宣言されていることに注意してくださいpublicinternal、またはprivateのみ名前空間のメンバーは、宣言された型は、アクセシビリティを宣言publicまたはinternal宣言されたアクセシビリティ。)。(Note that a type declared as a member of a struct can have public, internal, or private declared accessibility, whereas a type declared as a member of a namespace can have only public or internal declared accessibility.)
  • インターフェイス メンバーが暗黙的がpublicアクセシビリティを宣言します。Interface members implicitly have public declared accessibility. インターフェイス メンバー宣言では、アクセス修飾子は許可されません。No access modifiers are allowed on interface member declarations.
  • 列挙型メンバーが暗黙的がpublicアクセシビリティを宣言します。Enumeration members implicitly have public declared accessibility. 列挙体メンバーの宣言では、アクセス修飾子は許可されません。No access modifiers are allowed on enumeration member declarations.

アクセシビリティ ドメインAccessibility domains

アクセシビリティ ドメインメンバーのメンバーへのアクセスが許可されているプログラム テキストの (場合によって不整合のある) のセクションで構成されます。The accessibility domain of a member consists of the (possibly disjoint) sections of program text in which access to the member is permitted. メンバーのアクセシビリティ ドメインを定義するために、メンバーがあると言いますトップレベル場合は、型の中で宣言されていないと、メンバーがあると言います入れ子になった別の種類内で宣言されている場合。For purposes of defining the accessibility domain of a member, a member is said to be top-level if it is not declared within a type, and a member is said to be nested if it is declared within another type. さらに、プログラム テキストプログラムは、すべてのプログラム、プログラムのすべてのソース ファイルに含まれるテキストと型のプログラム テキストがすべてのプログラム テキストに含まれるように定義されている、定義、 type_declarationなど、場合によっては、型の中で入れ子にされた型、その型の秒。Furthermore, the program text of a program is defined as all program text contained in all source files of the program, and the program text of a type is defined as all program text contained in the type_declarations of that type (including, possibly, types that are nested within the type).

定義済みの型のアクセシビリティ ドメイン (などobjectint、またはdouble) に制限はありません。The accessibility domain of a predefined type (such as object, int, or double) is unlimited.

最上位のアクセシビリティ ドメインには、型がバインドされていないT(バインドされ、型がバインドされていない) プログラムで宣言されているPが次のように定義されています。The accessibility domain of a top-level unbound type T (Bound and unbound types) that is declared in a program P is defined as follows:

  • 場合の宣言されたアクセシビリティTpublicのアクセシビリティ ドメインTのプログラム テキストPと参照するすべてのプログラムPします。If the declared accessibility of T is public, the accessibility domain of T is the program text of P and any program that references P.
  • T に対して宣言されているアクセシビリティが internal の場合、T のアクセシビリティ ドメインは P のプログラム テキストになります。If the declared accessibility of T is internal, the accessibility domain of T is the program text of P.

これらの定義からは、最上位レベルのバインドされていない型のアクセシビリティ ドメインは常に、少なくともを次の種類をプログラムのプログラム テキストを宣言します。From these definitions it follows that the accessibility domain of a top-level unbound type is always at least the program text of the program in which that type is declared.

構築された型のアクセシビリティ ドメインT<A1, ..., An>バインドされていないジェネリック型のアクセシビリティ ドメインとの積集合Tと型引数のアクセシビリティ ドメインA1, ..., Anします。The accessibility domain for a constructed type T<A1, ..., An> is the intersection of the accessibility domain of the unbound generic type T and the accessibility domains of the type arguments A1, ..., An.

入れ子にされたメンバーのアクセシビリティ ドメインM型で宣言T、プログラム内でPが次のように定義されている (いうM自体は型である可能性があります可能性があります)。The accessibility domain of a nested member M declared in a type T within a program P is defined as follows (noting that M itself may possibly be a type):

  • M に対して宣言されたアクセシビリティが public の場合、M のアクセシビリティ ドメインは T のアクセシビリティ ドメインになります。If the declared accessibility of M is public, the accessibility domain of M is the accessibility domain of T.
  • 場合の宣言されたアクセシビリティMprotected internalDのプログラム テキストの和集合をするPから派生した任意の型のプログラム テキストとTの外部で宣言されているPします。If the declared accessibility of M is protected internal, let D be the union of the program text of P and the program text of any type derived from T, which is declared outside P. アクセシビリティ ドメインMのアクセシビリティ ドメインとの積集合TDします。The accessibility domain of M is the intersection of the accessibility domain of T with D.
  • 場合の宣言されたアクセシビリティMprotectedDのプログラム テキストの和集合をするTから派生した任意の型のプログラム テキストとTします。If the declared accessibility of M is protected, let D be the union of the program text of T and the program text of any type derived from T. アクセシビリティ ドメインMのアクセシビリティ ドメインとの積集合TDします。The accessibility domain of M is the intersection of the accessibility domain of T with D.
  • M に対して宣言されているアクセシビリティが internal の場合、M のアクセシビリティ ドメインは、T のアクセシビリティ ドメインと P のプログラム テキストとの積集合になります。If the declared accessibility of M is internal, the accessibility domain of M is the intersection of the accessibility domain of T with the program text of P.
  • M に対して宣言されているアクセシビリティが private の場合、M のアクセシビリティ ドメインは T のプログラム テキストになります。If the declared accessibility of M is private, the accessibility domain of M is the program text of T.

これらの定義からは、入れ子にされたメンバーのアクセシビリティ ドメインは常に、少なくともを次のメンバーが宣言されている種類のプログラム テキストです。From these definitions it follows that the accessibility domain of a nested member is always at least the program text of the type in which the member is declared. さらに、メンバーのアクセシビリティ ドメインはさらに、メンバーが宣言されている型のアクセシビリティ ドメインより包括的でないことに従います。Furthermore, it follows that the accessibility domain of a member is never more inclusive than the accessibility domain of the type in which the member is declared.

わかりやすく言うと、型またはメンバーとMがアクセスするには、次の手順は、アクセスが許可されていることを確認に評価されます。In intuitive terms, when a type or member M is accessed, the following steps are evaluated to ensure that the access is permitted:

  • 最初に、if M (と対照的にコンパイル単位または名前空間)、型で宣言は、その型にアクセスできない場合、コンパイル時エラーが発生します。First, if M is declared within a type (as opposed to a compilation unit or a namespace), a compile-time error occurs if that type is not accessible.
  • 場合はその後、Mpublicアクセスを許可します。Then, if M is public, the access is permitted.
  • の場合Mprotected internal、をプログラム内で発生した場合、アクセスが許可されますMを宣言したクラスから派生したクラス内に現れたかどうかまたはMは宣言されており、派生クラスで行われますクラスの種類 (保護されるインスタンスのメンバーにアクセス)。Otherwise, if M is protected internal, the access is permitted if it occurs within the program in which M is declared, or if it occurs within a class derived from the class in which M is declared and takes place through the derived class type (Protected access for instance members).
  • の場合Mprotected、クラス内で発生した場合、アクセスが許可されてMが宣言されているクラスから派生したクラス内に現れたかどうかまたはMは宣言されており、派生クラスで行われますクラスの種類 (保護されるインスタンスのメンバーにアクセス)。Otherwise, if M is protected, the access is permitted if it occurs within the class in which M is declared, or if it occurs within a class derived from the class in which M is declared and takes place through the derived class type (Protected access for instance members).
  • の場合Minternal、をプログラム内で発生した場合に、アクセスが許可されているMは宣言されています。Otherwise, if M is internal, the access is permitted if it occurs within the program in which M is declared.
  • の場合Mprivate、の種類内で発生した場合、アクセスが許可されてMは宣言されています。Otherwise, if M is private, the access is permitted if it occurs within the type in which M is declared.
  • それ以外の場合、型またはメンバーにアクセスできないと、コンパイル時エラーが発生します。Otherwise, the type or member is inaccessible, and a compile-time error occurs.

In the example

public class A
{
    public static int X;
    internal static int Y;
    private static int Z;
}

internal class B
{
    public static int X;
    internal static int Y;
    private static int Z;

    public class C
    {
        public static int X;
        internal static int Y;
        private static int Z;
    }

    private class D
    {
        public static int X;
        internal static int Y;
        private static int Z;
    }
}

クラスとメンバーは、次のアクセシビリティ ドメインにあります。the classes and members have the following accessibility domains:

  • アクセシビリティ ドメインAA.Xに制限はありません。The accessibility domain of A and A.X is unlimited.
  • アクセシビリティ ドメインA.YBB.XB.YB.CB.C.X、およびB.C.Y含んでいるプログラムのプログラム テキストです。The accessibility domain of A.Y, B, B.X, B.Y, B.C, B.C.X, and B.C.Y is the program text of the containing program.
  • アクセシビリティ ドメインA.Zのプログラム テキストAします。The accessibility domain of A.Z is the program text of A.
  • アクセシビリティ ドメインB.ZB.Dのプログラム テキストBのプログラム テキストを含むB.CB.Dします。The accessibility domain of B.Z and B.D is the program text of B, including the program text of B.C and B.D.
  • アクセシビリティ ドメインB.C.Zのプログラム テキストB.Cします。The accessibility domain of B.C.Z is the program text of B.C.
  • アクセシビリティ ドメインB.D.XB.D.Yのプログラム テキストBのプログラム テキストを含むB.CB.Dします。The accessibility domain of B.D.X and B.D.Y is the program text of B, including the program text of B.C and B.D.
  • アクセシビリティ ドメインB.D.Zのプログラム テキストB.Dします。The accessibility domain of B.D.Z is the program text of B.D.

例に示すように、メンバーのアクセシビリティ ドメインを含んでいる型よりも大きいことはありません。As the example illustrates, the accessibility domain of a member is never larger than that of a containing type. たとえば、場合でもすべてXがあるパブリックの宣言されたアクセシビリティのメンバー以外のすべてA.Xアクセシビリティ ドメインは、それを含む型によって制限されます。For example, even though all X members have public declared accessibility, all but A.X have accessibility domains that are constrained by a containing type.

」の説明に従ってメンバー、コンス トラクター、デストラクター、および静的コンス トラクター、インスタンスを除く、基底クラスのすべてのメンバーが派生型によって継承されます。As described in Members, all members of a base class, except for instance constructors, destructors and static constructors, are inherited by derived types. これには、基底クラスのプライベート メンバーも含まれています。This includes even private members of a base class. ただし、プライベート メンバーのアクセシビリティ ドメインには、メンバーが宣言されている型のプログラム テキストのみが含まれています。However, the accessibility domain of a private member includes only the program text of the type in which the member is declared. In the example

class A
{
    int x;

    static void F(B b) {
        b.x = 1;        // Ok
    }
}

class B: A
{
    static void F(B b) {
        b.x = 1;        // Error, x not accessible
    }
}

Bクラスは、プライベート メンバーを継承xから、Aクラス。the B class inherits the private member x from the A class. 内でアクセスできる、のみ、メンバーはプライベートなので、 class_bodyAします。Because the member is private, it is only accessible within the class_body of A. アクセスをそのため、b.xに成功すると、A.Fメソッドが失敗で、B.Fメソッド。Thus, the access to b.x succeeds in the A.F method, but fails in the B.F method.

インスタンス メンバーの保護されたアクセスProtected access for instance members

ときに、protectedインスタンス メンバーのアクセスが宣言されるクラスのプログラム テキストの外側とタイミングをprotected internalインスタンス メンバーが宣言されているプログラムのプログラム テキストの外側からアクセス、アクセスは内で行う必要があります、宣言されているクラスから派生したクラスの宣言。When a protected instance member is accessed outside the program text of the class in which it is declared, and when a protected internal instance member is accessed outside the program text of the program in which it is declared, the access must take place within a class declaration that derives from the class in which it is declared. さらに、アクセスは、そこから作成されたクラス型、またはその派生クラス型のインスタンスを介して行う必要があります。Furthermore, the access is required to take place through an instance of that derived class type or a class type constructed from it. この制限は、1 つの派生クラスが、メンバーが、同じ基本クラスから継承された場合でも、他の派生クラスのプロテクト メンバーにアクセスすることを防ぎます。This restriction prevents one derived class from accessing protected members of other derived classes, even when the members are inherited from the same base class.

ようにB保護されたインスタンス メンバーを宣言する基本クラスであるM、させてDから派生したクラスでなければBします。Let B be a base class that declares a protected instance member M, and let D be a class that derives from B. 内で、 class_bodyDへのアクセスをM形式は次のいずれかを実行します。Within the class_body of D, access to M can take one of the following forms:

  • 非限定type_nameまたはprimary_expressionフォームのMします。An unqualified type_name or primary_expression of the form M.
  • A primary_expressionフォームのE.Mの型を提供ETから派生したクラスまたはTここで、Tクラス型は、 D、またはクラス型構築されました。 DA primary_expression of the form E.M, provided the type of E is T or a class derived from T, where T is the class type D, or a class type constructed from D
  • A primary_expressionフォームのbase.Mします。A primary_expression of the form base.M.

派生クラスがで基底クラスのインスタンスが保護されたコンス トラクターのアクセス時にこれらの形式のアクセスに加え、 constructor_initializer (コンス トラクター初期化子)。In addition to these forms of access, a derived class can access a protected instance constructor of a base class in a constructor_initializer (Constructor initializers).

In the example

public class A
{
    protected int x;

    static void F(A a, B b) {
        a.x = 1;        // Ok
        b.x = 1;        // Ok
    }
}

public class B: A
{
    static void F(A a, B b) {
        a.x = 1;        // Error, must access through instance of B
        b.x = 1;        // Ok
    }
}

内でA、アクセスすることはx両方のインスタンスを通じてABいずれの場合では、アクセスがのインスタンスを通じて行われますので、Aから派生したクラスまたはAします。within A, it is possible to access x through instances of both A and B, since in either case the access takes place through an instance of A or a class derived from A. ただし、内Bにアクセスすることはできませんxのインスタンスを通じてA、ためAから派生していないBします。However, within B, it is not possible to access x through an instance of A, since A does not derive from B.

In the example

class C<T>
{
    protected T x;
}

class D<T>: C<T>
{
    static void F() {
        D<T> dt = new D<T>();
        D<int> di = new D<int>();
        D<string> ds = new D<string>();
        dt.x = default(T);
        di.x = 123;
        ds.x = "test";
    }
}

次の 3 つの割り当てをxジェネリック型から構築されたクラス型のインスタンスで実行されるので許可されます。the three assignments to x are permitted because they all take place through instances of class types constructed from the generic type.

アクセシビリティの制約Accessibility constraints

C# 言語のいくつかの構成要素に必要な型にとして以上のアクセシビリティメンバーまたは別の型。Several constructs in the C# language require a type to be at least as accessible as a member or another type. T少なくともメンバーまたは型と同程度にアクセスできるように言いますM場合のアクセシビリティ ドメインTのアクセシビリティ ドメインのスーパー セットMします。A type T is said to be at least as accessible as a member or type M if the accessibility domain of T is a superset of the accessibility domain of M. つまり、Tとして以上のアクセシビリティはM場合Tをすべてのコンテキストでアクセス可能なMにアクセスします。In other words, T is at least as accessible as M if T is accessible in all contexts in which M is accessible.

次のユーザー補助の制約があります。The following accessibility constraints exist:

  • クラスの型の直接基底クラスは、少なくとも、クラスの型自体と同程度にアクセス可能である必要があります。The direct base class of a class type must be at least as accessible as the class type itself.
  • インターフェイスの型の明示的な基本インターフェイスは、少なくとも、インターフェイスの型自体と同程度にアクセス可能である必要があります。The explicit base interfaces of an interface type must be at least as accessible as the interface type itself.
  • デリゲート型の戻り値の型およびパラメーターの型は、少なくとも、デリゲート型自体と同程度にアクセス可能である必要があります。The return type and parameter types of a delegate type must be at least as accessible as the delegate type itself.
  • 定数の型は、少なくとも定数自体と同程度にアクセス可能である必要があります。The type of a constant must be at least as accessible as the constant itself.
  • フィールドの型は、少なくともフィールド自体と同程度にアクセス可能である必要があります。The type of a field must be at least as accessible as the field itself.
  • メソッドの戻り値の型およびパラメーターの型は、少なくとも、メソッド自体と同程度にアクセス可能である必要があります。The return type and parameter types of a method must be at least as accessible as the method itself.
  • プロパティの型は、少なくともプロパティ自体と同程度にアクセス可能である必要があります。The type of a property must be at least as accessible as the property itself.
  • イベントの型は、少なくともイベント自体と同程度にアクセス可能である必要があります。The type of an event must be at least as accessible as the event itself.
  • インデクサーの型とパラメーターの型は、少なくとも、インデクサー自体と同程度にアクセス可能である必要があります。The type and parameter types of an indexer must be at least as accessible as the indexer itself.
  • 演算子の戻り値の型とパラメーターの型は、少なくとも、演算子自体と同程度にアクセス可能である必要があります。The return type and parameter types of an operator must be at least as accessible as the operator itself.
  • インスタンス コンス トラクターのパラメーターの型は、少なくとも、インスタンス コンス トラクター自体と同程度にアクセスできなければなりません。The parameter types of an instance constructor must be at least as accessible as the instance constructor itself.

In the example

class A {...}

public class B: A {...}

Bため、クラスがコンパイル時エラー結果Aとして少なくともアクセス可能でないBします。the B class results in a compile-time error because A is not at least as accessible as B.

例では同様に、Likewise, in the example

class A {...}

public class B
{
    A F() {...}

    internal A G() {...}

    public A H() {...}
}

HメソッドB結果、戻り値の型のため、コンパイル時エラー、Aは少なくともメソッドと同程度にアクセスできません。the H method in B results in a compile-time error because the return type A is not at least as accessible as the method.

シグネチャとオーバー ロードSignatures and overloading

メソッド、インスタンス コンス トラクター、インデクサー、および演算子の特性は、その署名:Methods, instance constructors, indexers, and operators are characterized by their signatures:

  • メソッドのシグネチャは、メソッド、型パラメーターの数と型と仮パラメーターが左から右へ順に検討のそれぞれの種類 (値、参照、または出力) の名前で構成されます。The signature of a method consists of the name of the method, the number of type parameters and the type and kind (value, reference, or output) of each of its formal parameters, considered in the order left to right. このため、その名前ではなく、メソッドの型引数リストの序数位置を使用して、仮パラメーターの型で使用されるメソッドの型パラメーターが識別されます。For these purposes, any type parameter of the method that occurs in the type of a formal parameter is identified not by its name, but by its ordinal position in the type argument list of the method. メソッドのシグネチャが具体的には戻り値の型では含まない、params右端のパラメーターも省略可能な型パラメーターの制約で指定できる修飾子。The signature of a method specifically does not include the return type, the params modifier that may be specified for the right-most parameter, nor the optional type parameter constraints.
  • インスタンス コンス トラクターのシグネチャは、型と仮パラメーターが左から右へ順に検討のそれぞれの種類 (値、参照、または出力) で構成されます。The signature of an instance constructor consists of the type and kind (value, reference, or output) of each of its formal parameters, considered in the order left to right. 具体的には、インスタンス コンス トラクターのシグネチャが含まれません場合は、params右端のパラメーターで指定できる修飾子。The signature of an instance constructor specifically does not include the params modifier that may be specified for the right-most parameter.
  • インデクサーのシグネチャは、左から右へ順番と見なされます、仮パラメーターのそれぞれの種類で構成されます。The signature of an indexer consists of the type of each of its formal parameters, considered in the order left to right. インデクサーのシグネチャが具体的には、要素の型では含まないも含まれる、params右端のパラメーターで指定できる修飾子。The signature of an indexer specifically does not include the element type, nor does it include the params modifier that may be specified for the right-most parameter.
  • 演算子のシグネチャは、演算子と仮パラメーターが左から右へ順に検討のそれぞれの型の名前で構成されます。The signature of an operator consists of the name of the operator and the type of each of its formal parameters, considered in the order left to right. 具体的には、演算子のシグネチャでは、結果型は含まれません。The signature of an operator specifically does not include the result type.

署名の有効化のメカニズムは、オーバー ロードクラス、構造体、およびインターフェイス内のメンバーの。Signatures are the enabling mechanism for overloading of members in classes, structs, and interfaces:

  • メソッドのオーバー ロードは、クラス、構造体、またはシグネチャの同じ名前を持つ複数のメソッドはそのクラス、構造体、またはインターフェイス内で一意で宣言するインターフェイスを許可します。Overloading of methods permits a class, struct, or interface to declare multiple methods with the same name, provided their signatures are unique within that class, struct, or interface.
  • インスタンス コンス トラクターのオーバー ロードは、そのシグネチャはそのクラスまたは構造体内で一意で提供される、クラスまたは複数のインスタンス コンス トラクターを宣言する構造体をできます。Overloading of instance constructors permits a class or struct to declare multiple instance constructors, provided their signatures are unique within that class or struct.
  • そのシグネチャは、クラス、構造体、またはインターフェイス内で一意で提供される、クラス、構造体、または複数のインデクサーを宣言するインターフェイスを許可インデクサーのオーバー ロードします。Overloading of indexers permits a class, struct, or interface to declare multiple indexers, provided their signatures are unique within that class, struct, or interface.
  • 演算子のオーバー ロードにより、クラスまたは構造体がそのクラスまたは構造体内で一意で、シグネチャの同じ名前の複数の演算子を宣言します。Overloading of operators permits a class or struct to declare multiple operators with the same name, provided their signatures are unique within that class or struct.

outrefパラメーター修飾子は、シグネチャの一部と見なされます、1 つの型で宣言されたメンバーがだけでの署名で異なることはできませんrefoutします。Although out and ref parameter modifiers are considered part of a signature, members declared in a single type cannot differ in signature solely by ref and out. 2 つのメンバーが宣言されている場合場合でも同じになるシグネチャを持つ同じ型ですべてのパラメーターを両方の方法で、コンパイル時エラーが発生したoutに変更された修飾子ref修飾子。A compile-time error occurs if two members are declared in the same type with signatures that would be the same if all parameters in both methods with out modifiers were changed to ref modifiers. シグネチャの一致の他の目的 (非表示やオーバーライドなど)、refoutシグネチャの一部と見なされ、他の一致していません。For other purposes of signature matching (e.g., hiding or overriding), ref and out are considered part of the signature and do not match each other. (この制限は、許可するC#実行で、共通言語基盤 (CLI) でのみ異なるメソッドを定義する方法を提供しないに簡単に変換するプログラムrefout.)(This restriction is to allow C#  programs to be easily translated to run on the Common Language Infrastructure (CLI), which does not provide a way to define methods that differ solely in ref and out.)

型の署名のためobjectdynamic同じと見なされます。For the purposes of signatures, the types object and dynamic are considered the same. 1 つの型で宣言されたメンバーできますしたがってされませんが異なるシグネチャでのみobjectdynamicします。Members declared in a single type can therefore not differ in signature solely by object and dynamic.

次の例では、一連のオーバー ロードされたメソッドの宣言とそのシグネチャを示します。The following example shows a set of overloaded method declarations along with their signatures.

interface ITest
{
    void F();                        // F()

    void F(int x);                   // F(int)

    void F(ref int x);               // F(ref int)

    void F(out int x);               // F(out int)      error

    void F(int x, int y);            // F(int, int)

    int F(string s);                 // F(string)

    int F(int x);                    // F(int)          error

    void F(string[] a);              // F(string[])

    void F(params string[] a);       // F(string[])     error
}

注意してくださいrefoutパラメーター修飾子 (メソッド パラメーター) は、署名の一部です。Note that any ref and out parameter modifiers (Method parameters) are part of a signature. したがって、F(int)F(ref int)は一意の署名。Thus, F(int) and F(ref int) are unique signatures. ただし、F(ref int)F(out int)、シグネチャがによって異なるため、同じインターフェイス内で宣言することはできませんrefoutします。However, F(ref int) and F(out int) cannot be declared within the same interface because their signatures differ solely by ref and out. また、戻り値の型を注とparams修飾子に含まれていない、シグネチャの戻り値の型または包含または除外のみに基づいてオーバー ロードすることはできませんので、params修飾子。Also, note that the return type and the params modifier are not part of a signature, so it is not possible to overload solely based on return type or on the inclusion or exclusion of the params modifier. これらのメソッドの宣言としてF(int)F(params string[])上に示したコンパイル時エラーが発生します。As such, the declarations of the methods F(int) and F(params string[]) identified above result in a compile-time error.

スコープScopes

スコープの名前が名前の修飾なしの名前で宣言されたエンティティを参照する、プログラム テキストの範囲。The scope of a name is the region of program text within which it is possible to refer to the entity declared by the name without qualification of the name. スコープは、入れ子になった、内側のスコープを再宣言することがあります、外部スコープから名前の意味と (これは、ただし、削除されませんによって課される制限宣言入れ子になったブロック内ではありません可能な限り、それを囲むブロック内のローカル変数と同じ名前でローカル変数を宣言する)。Scopes can be nested, and an inner scope may redeclare the meaning of a name from an outer scope (this does not, however, remove the restriction imposed by Declarations that within a nested block it is not possible to declare a local variable with the same name as a local variable in an enclosing block). 外側のスコープの名前にしすることを言います隠しプログラムのリージョン内のテキストが内側のスコープでカバーし、外部名へのアクセスは、名前を修飾することによってのみ可能です。The name from the outer scope is then said to be hidden in the region of program text covered by the inner scope, and access to the outer name is only possible by qualifying the name.

  • 宣言された名前空間のメンバーのスコープをnamespace_member_declaration (Namespace メンバー) それを囲むなしでnamespace_declarationプログラム全体は、テキスト。The scope of a namespace member declared by a namespace_member_declaration (Namespace members) with no enclosing namespace_declaration is the entire program text.
  • 宣言された名前空間のメンバーのスコープをnamespace_member_declaration内、 namespace_declarationの完全修飾名はNは、 namespace_bodyのすべてnamespace_declarationの完全修飾名はNで始まるまたはNとピリオドが続く。The scope of a namespace member declared by a namespace_member_declaration within a namespace_declaration whose fully qualified name is N is the namespace_body of every namespace_declaration whose fully qualified name is N or starts with N, followed by a period.
  • によって定義された名前のスコープ、 extern_alias_directiveにわたる、 using_directives、 global_attributesnamespace_member_宣言s がすぐに親のコンパイル単位または名前空間本文。The scope of name defined by 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基になる宣言領域に新しいメンバーは含まれません。An extern_alias_directive 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.
  • 名前のスコープが定義されているまたはによってインポートされた、 using_directive (ディレクティブを使用して) にわたる、 namespace_member_declarationの s、 compilation_unitまたはnamespace_bodyusing_directiveに発生します。The scope of a name defined or imported by a using_directive (Using directives) extends over the namespace_member_declarations of the compilation_unit or namespace_body in which the using_directive occurs. A using_directive 0 個以上の名前空間、型またはメンバー名を特定内で使用できるようにcompilation_unitまたはnamespace_body、しませんが、基になる宣言領域に新しいメンバーを追加します。A using_directive may make zero or more namespace, type or member names available within a particular compilation_unit or namespace_body, but does not contribute any new members to the underlying declaration space. つまり、 using_directiveは推移的ではありませんが、代わりにのみ影響、 compilation_unitまたはnamespace_bodyそれが出現します。In other words, a using_directive is not transitive but rather affects only the compilation_unit or namespace_body in which it occurs.
  • 宣言された型パラメーターのスコープをtype_parameter_list上、 class_declaration (クラス クラスの宣言) は、 class_basetype_parameter_constraints_clause秒、およびclass_bodyそのclass_declarationします。The scope of a type parameter declared by a type_parameter_list on a class_declaration (Class declarations) is the class_base, type_parameter_constraints_clauses, and class_body of that class_declaration.
  • 宣言された型パラメーターのスコープをtype_parameter_list上、 struct_declaration (構造体の宣言) は、 struct_interfacestype_parameter_constraints_clause秒、およびstruct_bodyそのstruct_declarationします。The scope of a type parameter declared by a type_parameter_list on a struct_declaration (Struct declarations) is the struct_interfaces, type_parameter_constraints_clauses, and struct_body of that struct_declaration.
  • 宣言された型パラメーターのスコープをtype_parameter_list上、 interface_declaration (インターフェイスの宣言) は、 interface_basetype_parameter_constraints_clause秒、およびinterface_bodyそのinterface_declarationします。The scope of a type parameter declared by a type_parameter_list on an interface_declaration (Interface declarations) is the interface_base, type_parameter_constraints_clauses, and interface_body of that interface_declaration.
  • 宣言された型パラメーターのスコープをtype_parameter_list上、 delegate_declaration (デリゲートの宣言) は、 return_typeformal_parameter_list、およびtype_parameter_constraints_clauseその s delegate_declarationします。The scope of a type parameter declared by a type_parameter_list on a delegate_declaration (Delegate declarations) is the return_type, formal_parameter_list, and type_parameter_constraints_clauses of that delegate_declaration.
  • 宣言されたメンバーのスコープをclass_member_declaration (クラス本体) は、 class_bodyの宣言が発生します。The scope of a member declared by a class_member_declaration (Class body) is the class_body in which the declaration occurs. クラス メンバーのスコープまで、さらに、 class_bodyこれらのアクセシビリティ ドメインに含まれているクラスを派生 (アクセシビリティ ドメイン) のメンバー。In addition, the scope of a class member extends to the class_body of those derived classes that are included in the accessibility domain (Accessibility domains) of the member.
  • 宣言されたメンバーのスコープをstruct_member_declaration (構造体のメンバー) は、 struct_bodyの宣言が発生します。The scope of a member declared by a struct_member_declaration (Struct members) is the struct_body in which the declaration occurs.
  • 宣言されたメンバーのスコープ、 enum_member_declaration (列挙型メンバー) は、 enum_bodyの宣言が発生します。The scope of a member declared by an enum_member_declaration (Enum members) is the enum_body in which the declaration occurs.
  • 宣言されたパラメーターのスコープをmethod_declaration (メソッド) は、 method_bodyそのmethod_declarationします。The scope of a parameter declared in a method_declaration (Methods) is the method_body of that method_declaration.
  • 宣言されたパラメーターのスコープ、 indexer_declaration (インデクサー) は、 accessor_declarationsそのindexer_declaration.The scope of a parameter declared in an indexer_declaration (Indexers) is the accessor_declarations of that indexer_declaration.
  • 宣言されたパラメーターのスコープ、 operator_declaration (演算子) は、ブロックそのoperator_declarationします。The scope of a parameter declared in an operator_declaration (Operators) is the block of that operator_declaration.
  • 宣言されたパラメーターのスコープをconstructor_declaration (インスタンス コンス トラクター) は、 constructor_initializerブロックそのconstructor_declarationします。The scope of a parameter declared in a constructor_declaration (Instance constructors) is the constructor_initializer and block of that constructor_declaration.
  • 宣言されたパラメーターのスコープをlambda_expression (匿名関数式) は、 anonymous_function_bodyそのlambda_式The scope of a parameter declared in a lambda_expression (Anonymous function expressions) is the anonymous_function_body of that lambda_expression
  • 宣言されたパラメーターのスコープ、 anonymous_method_expression (匿名関数式) は、ブロックそのanonymous_method_expressionします。The scope of a parameter declared in an anonymous_method_expression (Anonymous function expressions) is the block of that anonymous_method_expression.
  • 宣言されているラベルのスコープをlabeled_statement (というラベルの付いたステートメント) は、ブロックの宣言が発生します。The scope of a label declared in a labeled_statement (Labeled statements) is the block in which the declaration occurs.
  • 宣言されたローカル変数のスコープをlocal_variable_declaration (ローカル変数宣言) ブロックの宣言が発生します。The scope of a local variable declared in a local_variable_declaration (Local variable declarations) is the block in which the declaration occurs.
  • 宣言されたローカル変数のスコープをswitch_blockswitchステートメント (switch ステートメント) は、 switch_blockします。The scope of a local variable declared in a switch_block of a switch statement (The switch statement) is the switch_block.
  • 宣言されたローカル変数のスコープをfor_initializerforステートメント (、ステートメントの) は、 for_initializerfor_conditionfor_iterator、格納されているとステートメントforステートメント。The scope of a local variable declared in a for_initializer of a for statement (The for statement) is the for_initializer, the for_condition, the for_iterator, and the contained statement of the for statement.
  • 宣言されたローカル定数のスコープをlocal_constant_declaration (ローカル定数宣言) ブロックの宣言が発生します。The scope of a local constant declared in a local_constant_declaration (Local constant declarations) is the block in which the declaration occurs. 前にあるテキストの位置でのローカル定数を参照すると、コンパイル時エラーがそのconstant_declaratorします。It is a compile-time error to refer to a local constant in a textual position that precedes its constant_declarator.
  • 変数のスコープが宣言の一部として、 foreach_statementusing_statementlock_statementまたはquery_expressionは特定の構造の拡張によって決まります。The scope of a variable declared as part of a foreach_statement, using_statement, lock_statement or query_expression is determined by the expansion of the given construct.

名前空間、クラス、構造体、または列挙型メンバーのスコープ内のメンバーの宣言の前にあるテキストの位置にメンバーを参照することです。Within the scope of a namespace, class, struct, or enumeration member it is possible to refer to the member in a textual position that precedes the declaration of the member. 次に例を示します。For example

class A
{
    void F() {
        i = 1;
    }

    int i = 0;
}

ここでは、それが有効でFを参照するi宣言されています。Here, it is valid for F to refer to i before it is declared.

前にあるテキストの位置にローカル変数を参照すると、コンパイル時エラーは、ローカル変数のスコープ内で、 local_variable_declaratorのローカル変数。Within the scope of a local variable, it is a compile-time error to refer to the local variable in a textual position that precedes the local_variable_declarator of the local variable. 次に例を示します。For example

class A
{
    int i = 0;

    void F() {
        i = 1;                  // Error, use precedes declaration
        int i;
        i = 2;
    }

    void G() {
        int j = (j = 1);        // Valid
    }

    void H() {
        int a = 1, b = ++a;    // Valid
    }
}

F上記のメソッドは、最初の割り当てをi具体的には、外側のスコープで宣言されているフィールドを参照しません。In the F method above, the first assignment to i specifically does not refer to the field declared in the outer scope. 代わりに、ローカル変数を参照し、代入変数の宣言にコンパイル時エラーが発生します。Rather, it refers to the local variable and it results in a compile-time error because it textually precedes the declaration of the variable. Gメソッドは、の使用jの宣言の初期化子でjため、使用前に有効では、 local_variable_declaratorします。In the G method, the use of j in the initializer for the declaration of j is valid because the use does not precede the local_variable_declarator. Hメソッドは、後ろに続くlocal_variable_declarator以前で宣言されたローカル変数を正しく指すlocal_variable_declarator内で同じlocal_variable_declarationします。In the H method, a subsequent local_variable_declarator correctly refers to a local variable declared in an earlier local_variable_declarator within the same local_variable_declaration.

ローカル変数のスコープ規則は、式のコンテキストで使用される名前の意味が常に同じであるブロック内で保証するために設計されています。The scoping rules for local variables are designed to guarantee that the meaning of a name used in an expression context is always the same within a block. ローカル変数のスコープ、ブロックの末尾に、宣言からのみを拡張する場合は、上記の例では、最初の代入は、インスタンス変数、2 つ目の代入はローカル変数につながる可能性があります。ブロックのステートメントが再整列される以降の場合のコンパイル時エラー。If the scope of a local variable were to extend only from its declaration to the end of the block, then in the example above, the first assignment would assign to the instance variable and the second assignment would assign to the local variable, possibly leading to compile-time errors if the statements of the block were later to be rearranged.

ブロック内で名前の意味は、名前が使用されるコンテキストに応じて異なる場合があります。The meaning of a name within a block may differ based on the context in which the name is used. In the example

using System;

class A {}

class Test
{
    static void Main() {
        string A = "hello, world";
        string s = A;                            // expression context

        Type t = typeof(A);                      // type context

        Console.WriteLine(s);                    // writes "hello, world"
        Console.WriteLine(t);                    // writes "A"
    }
}

名前A式のコンテキストでローカル変数を参照するために使用Aと、クラスを参照する型のコンテキストでAします。the name A is used in an expression context to refer to the local variable A and in a type context to refer to the class A.

名前の隠ぺいName hiding

通常、エンティティのスコープには、エンティティの宣言領域よりも多くのプログラム テキストが含まれます。The scope of an entity typically encompasses more program text than the declaration space of the entity. 具体的には、エンティティのスコープは、同じ名前のエンティティを含む新しい宣言空間を導入する宣言を含めることができます。In particular, the scope of an entity may include declarations that introduce new declaration spaces containing entities of the same name. このような宣言により、元のエンティティになる隠しします。Such declarations cause the original entity to become hidden. 逆に、エンティティがあると言えます表示非表示しない場合。Conversely, an entity is said to be visible when it is not hidden.

名前の非表示には、スコープが入れ子スコープが継承によるオーバー ラップしてが重複する場合に発生します。Name hiding occurs when scopes overlap through nesting and when scopes overlap through inheritance. 次のセクションでは、2 種類の非表示の特性を説明します。The characteristics of the two types of hiding are described in the following sections.

入れ子を非表示Hiding through nesting

入れ子による名前の隠ぺいは、名前空間またはクラスまたは構造体、およびパラメーターやローカル変数の宣言型の入れ子の結果として、名前空間内の型の入れ子の結果として発生します。Name hiding through nesting can occur as a result of nesting namespaces or types within namespaces, as a result of nesting types within classes or structs, and as a result of parameter and local variable declarations.

In the example

class A
{
    int i = 0;

    void F() {
        int i = 1;
    }

    void G() {
        i = 1;
    }
}

内で、Fメソッドは、インスタンス変数iローカル変数によって隠されているiが内、Gメソッド、iインスタンス変数を参照します。within the F method, the instance variable i is hidden by the local variable i, but within the G method, i still refers to the instance variable.

内側のスコープに名前が外側のスコープでの名前を非表示にすると、その名前のすべてのオーバー ロードされた出現箇所は非表示になります。When a name in an inner scope hides a name in an outer scope, it hides all overloaded occurrences of that name. In the example

class Outer
{
    static void F(int i) {}

    static void F(string s) {}

    class Inner
    {
        void G() {
            F(1);              // Invokes Outer.Inner.F
            F("Hello");        // Error
        }

        static void F(long l) {}
    }
}

呼び出しF(1)呼び出す、Fで宣言されているInnerため、外部出現するすべてのF内部宣言では表示されません。the call F(1) invokes the F declared in Inner because all outer occurrences of F are hidden by the inner declaration. 同じ理由、呼び出しからF("Hello")コンパイル時エラーが発生します。For the same reason, the call F("Hello") results in a compile-time error.

継承によって非表示Hiding through inheritance

継承による名前の隠ぺいは、クラスまたは構造体の基本クラスから継承した名前を再宣言するときに発生します。Name hiding through inheritance occurs when classes or structs redeclare names that were inherited from base classes. この種類の名前の隠ぺいは、次の種類のいずれかです。This type of name hiding takes one of the following forms:

  • 定数、フィールド、プロパティ、イベント、またはクラスまたは構造体で導入された型と同じ名前のすべての基底クラス メンバーを非表示にします。A constant, field, property, event, or type introduced in a class or struct hides all base class members with the same name.
  • クラスまたは構造体で導入されたメソッドには、同じ名前を持つすべてのメソッド以外の基本クラス メンバーと (メソッド名とパラメーターの数、修飾子、および種類) は、同じシグネチャを持つすべての基底クラス メソッドが非表示にします。A method introduced in a class or struct hides all non-method base class members with the same name, and all base class methods with the same signature (method name and parameter count, modifiers, and types).
  • クラスまたは構造体で導入されたインデクサーには、(パラメーターの数と型) は、同じシグネチャを持つすべての基底クラス インデクサーが非表示にします。An indexer introduced in a class or struct hides all base class indexers with the same signature (parameter count and types).

演算子の宣言に関する規則 (演算子) 基本クラスでは演算子として同じシグネチャを持つ演算子を宣言する派生クラスを使用できなくなります。The rules governing operator declarations (Operators) make it impossible for a derived class to declare an operator with the same signature as an operator in a base class. そのため、演算子が互いの演算子を隠ぺいすることはありません。Thus, operators never hide one another.

外側のスコープから名前を非表示とは異なりは、継承したスコープからアクセス可能な名前を非表示と、警告が報告されます。Contrary to hiding a name from an outer scope, hiding an accessible name from an inherited scope causes a warning to be reported. In the example

class Base
{
    public void F() {}
}

class Derived: Base
{
    public void F() {}        // Warning, hiding an inherited name
}

宣言FDerivedにより警告が報告されます。the declaration of F in Derived causes a warning to be reported. 継承された名前を非表示でない具体的には、エラーを基底クラスの個別の進化を来たすため。Hiding an inherited name is specifically not an error, since that would preclude separate evolution of base classes. たとえば、上記のような状況が発生する以降のバージョンのBase導入された、F以前のバージョンのクラスには存在しなかったメソッド。For example, the above situation might have come about because a later version of Base introduced an F method that wasn't present in an earlier version of the class. 上記のような状況は、エラーになっていた、個別にバージョン管理されたクラス ライブラリで基底クラスへの変更可能性がある可能性が派生クラスを無効になります。Had the above situation been an error, then any change made to a base class in a separately versioned class library could potentially cause derived classes to become invalid.

使用して、継承された名前を非表示にして警告を取り除くことができます、new修飾子。The warning caused by hiding an inherited name can be eliminated through use of the new modifier:

class Base
{
    public void F() {}
}

class Derived: Base
{
    new public void F() {}
}

new修飾子には、ことを示します、FDerivedはこれが実際にものである継承されたメンバーを非表示にして"new"。The new modifier indicates that the F in Derived is "new", and that it is indeed intended to hide the inherited member.

新しいメンバーの宣言では、新しいメンバーのスコープ内でのみ、継承されたメンバーを非表示にします。A declaration of a new member hides an inherited member only within the scope of the new member.

class Base
{
    public static void F() {}
}

class Derived: Base
{
    new private static void F() {}    // Hides Base.F in Derived only
}

class MoreDerived: Derived
{
    static void G() { F(); }          // Invokes Base.F
}

宣言の前の例ではFDerivedを非表示に、Fから継承されているBase、ただし、新しいFDerivedプライベート アクセスは、そのスコープには適用されませんMoreDerived.In the example above, the declaration of F in Derived hides the F that was inherited from Base, but since the new F in Derived has private access, its scope does not extend to MoreDerived. したがって、呼び出しF()MoreDerived.Gが有効では呼び出すBase.Fします。Thus, the call F() in MoreDerived.G is valid and will invoke Base.F.

Namespace と型の名前Namespace and type names

内のいくつかのコンテキストをC#プログラムが必要なnamespace_nameまたはtype_nameを指定します。Several contexts in a C# program require a namespace_name or a type_name to be specified.

namespace_name
    : namespace_or_type_name
    ;

type_name
    : namespace_or_type_name
    ;

namespace_or_type_name
    : identifier type_argument_list?
    | namespace_or_type_name '.' identifier type_argument_list?
    | qualified_alias_member
    ;

A namespace_nameは、 namespace_or_type_name名前空間を参照します。A namespace_name is a namespace_or_type_name that refers to a namespace. 以下に示すように、解像度を次のnamespace_or_type_namenamespace_name 、名前空間を参照する必要がありますそれ以外の場合、コンパイル時エラーが発生します。Following resolution as described below, the namespace_or_type_name of a namespace_name must refer to a namespace, or otherwise a compile-time error occurs. 型引数なし (引数を入力) で使用できる、 namespace_name (専用の種類には、型引数を指定できます)。No type arguments (Type arguments) can be present in a namespace_name (only types can have type arguments).

A type_nameは、 namespace_or_type_name型を参照します。A type_name is a namespace_or_type_name that refers to a type. 以下に示すように、解像度を次、 namespace_or_type_nametype_name型を参照する必要がありますそれ以外の場合、コンパイル時エラーが発生します。Following resolution as described below, the namespace_or_type_name of a type_name must refer to a type, or otherwise a compile-time error occurs.

場合、 namespace_or_type_name修飾-エイリアス - メンバーの意味は」の説明に従ってNamespace エイリアス修飾子します。If the namespace_or_type_name is a qualified-alias-member its meaning is as described in Namespace alias qualifiers. それ以外の場合、 namespace_or_type_nameが 4 つの形式のいずれか。Otherwise, a namespace_or_type_name has one of four forms:

  • I
  • I<A1, ..., Ak>
  • N.I
  • N.I<A1, ..., Ak>

場所I、単一の識別子は、Nは、 namespace_or_type_name<A1, ..., Ak>は省略可能なtype_argument_listwhere I is a single identifier, N is a namespace_or_type_name and <A1, ..., Ak> is an optional type_argument_list. ない場合type_argument_listが指定するを検討してくださいkを 0 にします。When no type_argument_list is specified, consider k to be zero.

意味をnamespace_or_type_nameは次のように決定されます。The meaning of a namespace_or_type_name is determined as follows:

  • 場合、 namespace_or_type_nameの形式はIまたはフォームのI<A1, ..., Ak>:If the namespace_or_type_name is of the form I or of the form I<A1, ..., Ak>:
    • 場合Kゼロ、 namespace_or_type_nameジェネリック メソッドの宣言内で表示されます (メソッド) し、その宣言には、型パラメーターが含まれている場合 (型パラメーター) 名前を持つ Inamespace_or_type_nameその型パラメーターを参照します。If K is zero and the namespace_or_type_name appears within a generic method declaration (Methods) and if that declaration includes a type parameter (Type parameters) with name I, then the namespace_or_type_name refers to that type parameter.
    • の場合、 namespace_or_type_name型の宣言内で次の各インスタンス タイプが表示されます T(インスタンス型)、その型のインスタンスの型宣言と各外側のクラスまたは構造体の宣言のインスタンスの型 (存在する場合) を続行します。Otherwise, if the namespace_or_type_name appears within a type declaration, then for each instance type T (The instance type), starting with the instance type of that type declaration and continuing with the instance type of each enclosing class or struct declaration (if any):
      • 場合Kは 0 との宣言T名前の型パラメーターを含む Inamespace_or_type_nameその型パラメーターを参照します。If K is zero and the declaration of T includes a type parameter with name I, then the namespace_or_type_name refers to that type parameter.
      • の場合、 namespace_or_type_name型の宣言の本文内に表示し、Tまたはその基本型の名前を持つ入れ子になったアクセス可能な型が含まれている IK  パラメーターを入力し、 namespace_or_type_nameは特定の型引数を使用して構築する型を表します。Otherwise, if the namespace_or_type_name appears within the body of the type declaration, and T or any of its base types contain a nested accessible type having name I and K type parameters, then the namespace_or_type_name refers to that type constructed with the given type arguments. このような 1 つ以上の型がある場合より強い派生型で宣言された型が選択されます。If there is more than one such type, the type declared within the more derived type is selected. 意味を決定するときに、非型のメンバー (定数、フィールド、メソッド、プロパティ、インデクサー、演算子、インスタンス コンス トラクター、デストラクター、および静的コンス トラクター) と型パラメーターの数が異なる型のメンバーが無視されることに注意してください、namespace_or_type_nameします。Note that non-type members (constants, fields, methods, properties, indexers, operators, instance constructors, destructors, and static constructors) and type members with a different number of type parameters are ignored when determining the meaning of the namespace_or_type_name.
    • かどうか、前の手順を各名前空間の次に、失敗しました Nを名前空間を以降のnamespace_or_type_name外側にある各名前空間 (存在する場合) を続行し、終わるが発生した、グローバル名前空間、エンティティが見つかるまで、次の手順が評価されます。If the previous steps were unsuccessful then, for each namespace N, starting with the namespace in which the namespace_or_type_name occurs, continuing with each enclosing namespace (if any), and ending with the global namespace, the following steps are evaluated until an entity is located:
      • 場合KゼロとIで名前空間の名前を指定 N、し。If K is zero and I is the name of a namespace in N, then:
        • 場合、場所をnamespace_or_type_nameが発生した名前空間の宣言で囲まれたN名前空間宣言が含まれています、 extern_alias_directiveまたはusing_alias_directive名前に関連付ける I型、または名前空間、 namespace_or_type_nameがあいまいですし、コンパイル時エラーが発生します。If the location where the namespace_or_type_name occurs is enclosed by a namespace declaration for N and the namespace declaration contains an extern_alias_directive or using_alias_directive that associates the name I with a namespace or type, then the namespace_or_type_name is ambiguous and a compile-time error occurs.
        • それ以外の場合、 namespace_or_type_nameという名前の名前空間を指すINします。Otherwise, the namespace_or_type_name refers to the namespace named I in N.
      • の場合N名前を持つアクセス可能な型が含まれています IK し、パラメーターを入力します。Otherwise, if N contains an accessible type having name I and K type parameters, then:
        • 場合Kは 0 と場所をnamespace_or_type_nameが発生した名前空間の宣言で囲まれたN名前空間宣言が含まれています、 extern_alias_directiveまたはusing_alias_directive名前に関連付ける I型、または名前空間、 namespace_or_type_nameあいまいな、コンパイル時にエラーが発生します。If K is zero and the location where the namespace_or_type_name occurs is enclosed by a namespace declaration for N and the namespace declaration contains an extern_alias_directive or using_alias_directive that associates the name I with a namespace or type, then the namespace_or_type_name is ambiguous and a compile-time error occurs.
        • それ以外の場合、 namespace_or_type_nameは特定の型引数を使用して構築型を表します。Otherwise, the namespace_or_type_name refers to the type constructed with the given type arguments.
      • の場合、場所を、 namespace_or_type_nameが発生した名前空間の宣言で囲まれたN:Otherwise, if the location where the namespace_or_type_name occurs is enclosed by a namespace declaration for N:
        • 場合Kがゼロで、名前空間宣言が含まれています、 extern_alias_directiveまたはusing_alias_directive名前に関連付ける Iでインポートされた名前空間または型、 namespace_or_type_nameその名前空間または型を参照します。If K is zero and the namespace declaration contains an extern_alias_directive or using_alias_directive that associates the name I with an imported namespace or type, then the namespace_or_type_name refers to that namespace or type.
        • それ以外の場合、名前空間と型の宣言をインポートした場合、 using_namespace_directives とusing_alias_directive名前空間宣言の s がアクセス可能な型の 1 つだけを含める名前を持つ IK パラメーター、入力、 namespace_or_type_nameは特定の型引数を使用して構築する型を表します。Otherwise, if the namespaces and type declarations imported by the using_namespace_directives and using_alias_directives of the namespace declaration contain exactly one accessible type having name I and K type parameters, then the namespace_or_type_name refers to that type constructed with the given type arguments.
        • それ以外の場合、名前空間と型の宣言をインポートした場合、 using_namespace_directives とusing_alias_directive名前空間の宣言の 1 つ以上のアクセス可能な型を含めることが名前を持つ IK パラメーター、入力、 namespace_or_type_nameがあいまい、エラーが発生します。Otherwise, if the namespaces and type declarations imported by the using_namespace_directives and using_alias_directives of the namespace declaration contain more than one accessible type having name I and K type parameters, then the namespace_or_type_name is ambiguous and an error occurs.
    • それ以外の場合、 namespace_or_type_nameは未定義となり、コンパイル時エラーが発生します。Otherwise, the namespace_or_type_name is undefined and a compile-time error occurs.
  • それ以外の場合、 namespace_or_type_nameの形式はN.IまたはフォームのN.I<A1, ..., Ak>します。Otherwise, the namespace_or_type_name is of the form N.I or of the form N.I<A1, ..., Ak>. N として解決は、まず、 namespace_or_type_nameします。N is first resolved as a namespace_or_type_name. 場合の解像度Nが成功すると、コンパイル時エラーが発生します。If the resolution of N is not successful, a compile-time error occurs. それ以外の場合、N.IまたはN.I<A1, ..., Ak>次のように解決されます。Otherwise, N.I or N.I<A1, ..., Ak> is resolved as follows:
    • 場合KゼロとN参照名前空間とN入れ子になった名前空間が含まれていますInamespace_or_type_nameその入れ子になった名前空間を参照します。If K is zero and N refers to a namespace and N contains a nested namespace with name I, then the namespace_or_type_name refers to that nested namespace.
    • の場合N参照名前空間とN名前を持つアクセス可能な型が含まれています IK パラメーターを入力し、 namespace_or_type_name参照その型指定された型引数を使用して構築します。Otherwise, if N refers to a namespace and N contains an accessible type having name I and K type parameters, then the namespace_or_type_name refers to that type constructed with the given type arguments.
    • の場合N(場合によって構築された) クラスまたは構造体の型を参照し、Nまたはその基本クラスの名前を持つ入れ子になったアクセス可能な型が含まれている IK  、パラメーターの型namespace_or_type_nameは特定の型引数を使用して構築する型を表します。Otherwise, if N refers to a (possibly constructed) class or struct type and N or any of its base classes contain a nested accessible type having name I and K type parameters, then the namespace_or_type_name refers to that type constructed with the given type arguments. このような 1 つ以上の型がある場合より強い派生型で宣言された型が選択されます。If there is more than one such type, the type declared within the more derived type is selected. 場合の意味に注意してくださいN.I解決の基底クラスの指定の一部として特定する複素数がNの直接の基本クラスからNオブジェクトと見なされます (基底クラス)。Note that if the meaning of N.I is being determined as part of resolving the base class specification of N then the direct base class of N is considered to be object (Base classes).
    • それ以外の場合、N.Iは無効なnamespace_or_type_nameコンパイル時エラーが発生したとします。Otherwise, N.I is an invalid namespace_or_type_name, and a compile-time error occurs.

A namespace_or_type_name静的クラスの参照が許可されている (静的クラス) 場合にのみA namespace_or_type_name is permitted to reference a static class (Static classes) only if

  • Namespace_or_type_nameは、Tで、 namespace_or_type_nameフォームのT.I、またはThe namespace_or_type_name is the T in a namespace_or_type_name of the form T.I, or
  • Namespace_or_type_nameは、Tで、 typeof_expression (引数リスト1) フォームのtypeof(T)します。The namespace_or_type_name is the T in a typeof_expression (Argument lists1) of the form typeof(T).

完全修飾名Fully qualified names

すべての名前空間と型に、完全修飾名、名前空間または他のすべてのユーザーの間で型を一意に識別します。Every namespace and type has a fully qualified name, which uniquely identifies the namespace or type amongst all others. 名前空間または型の完全修飾名Nは次のように決定されます。The fully qualified name of a namespace or type N is determined as follows:

  • 場合Nメンバーは、その完全修飾名には、グローバル名前空間のNします。If N is a member of the global namespace, its fully qualified name is N.
  • その完全修飾名は、それ以外の場合、S.Nここで、 S 、名前空間の種類の完全修飾名は、Nは宣言されています。Otherwise, its fully qualified name is S.N, where S is the fully qualified name of the namespace or type in which N is declared.

完全修飾名、つまりNにつながる識別子の完全な階層パスは、 N、グローバル名前空間から開始します。In other words, the fully qualified name of N is the complete hierarchical path of identifiers that lead to N, starting from the global namespace. 名前空間または型のすべてのメンバーには、一意の名前を持つ必要があります、ために、名前空間または型の完全修飾名が常に一意であることに従います。Because every member of a namespace or type must have a unique name, it follows that the fully qualified name of a namespace or type is always unique.

次の例では、関連付けられている、完全修飾名と名前空間と型の宣言をいくつかを示します。The example below shows several namespace and type declarations along with their associated fully qualified names.

class A {}                // A

namespace X               // X
{
    class B               // X.B
    {
        class C {}        // X.B.C
    }

    namespace Y           // X.Y
    {
        class D {}        // X.Y.D
    }
}

namespace X.Y             // X.Y
{
    class E {}            // X.Y.E
}

自動メモリ管理Automatic memory management

C# 開発者は手動での割り当てとオブジェクトによって占有されているメモリを解放してから、自動メモリ管理を採用しています。C# employs automatic memory management, which frees developers from manually allocating and freeing the memory occupied by objects. 自動メモリ管理ポリシーがによって実装される、ガベージ コレクターします。Automatic memory management policies are implemented by a garbage collector. オブジェクトのメモリ管理のライフ サイクルは次のとおりです。The memory management life cycle of an object is as follows:

  1. オブジェクトが作成されたときに、メモリが割り当てられたし、コンス トラクターを実行すると、オブジェクトは、ライブと見なされます。When the object is created, memory is allocated for it, the constructor is run, and the object is considered live.
  2. 場合は、オブジェクトまたはその一部は、実行可能な継続がアクセスできない、デストラクターの実行以外オブジェクトと見なされ不要になった使用中で破壊の対象になります。If the object, or any part of it, cannot be accessed by any possible continuation of execution, other than the running of destructors, the object is considered no longer in use, and it becomes eligible for destruction. C# コンパイラと、ガベージ コレクターは、オブジェクトへの参照は、今後使用される可能性がありますを決定するコードを分析できます。The C# compiler and the garbage collector may choose to analyze code to determine which references to an object may be used in the future. たとえば、スコープ内のローカル変数は、オブジェクトを唯一の参照から、現在実行中の実行の手順でポイントをそのローカル変数が参照されない場合は、ガベージ コレクターについて、可能性があります (がないです。ために必要) 使用されていないと、オブジェクトを処理します。For instance, if a local variable that is in scope is the only existing reference to an object, but that local variable is never referred to in any possible continuation of execution from the current execution point in the procedure, the garbage collector may (but is not required to) treat the object as no longer in use.
  3. 時間、デストラクターを後で指定されていない一部のオブジェクトが破壊の対象とすると (デストラクター) (あれば) のオブジェクトを実行します。Once the object is eligible for destruction, at some unspecified later time the destructor (Destructors) (if any) for the object is run. 通常の状況で、オブジェクトのデストラクターは実装に固有の Api は、オーバーライドするには、この動作を使用する可能性がありますが 1 回だけ実行されます。Under normal circumstances the destructor for the object is run once only, though implementation-specific APIs may allow this behavior to be overridden.
  4. デストラクターの実行を含む実行可能な継続して、そのオブジェクトまたはその一部にアクセスできない場合、オブジェクトのデストラクターが実行されると、オブジェクトがアクセスできないと見なされます、オブジェクトがコレクションの対象になります。Once the destructor for an object is run, if that object, or any part of it, cannot be accessed by any possible continuation of execution, including the running of destructors, the object is considered inaccessible and the object becomes eligible for collection.
  5. 最後に、いくつかの時点で、オブジェクトがコレクションの対象になると、ガベージ コレクターが解放そのオブジェクトに関連付けられているメモリ。Finally, at some time after the object becomes eligible for collection, the garbage collector frees the memory associated with that object.

ガベージ コレクターは、オブジェクトの使用方法に関する情報を保持し、メモリ管理、決定を行うなど、オブジェクト、およびオブジェクトを再配置がなくなったときに使用されていたり、新しく作成されたオブジェクトを検索するためのメモリ内の場所はこの情報を使用します。The garbage collector maintains information about object usage, and uses this information to make memory management decisions, such as where in memory to locate a newly created object, when to relocate an object, and when an object is no longer in use or inaccessible.

ガベージ コレクターの存在を前提としている他の言語と同様に c# もはガベージ コレクターがさまざまなメモリ管理ポリシーを実装できるように設計されています。Like other languages that assume the existence of a garbage collector, C# is designed so that the garbage collector may implement a wide range of memory management policies. たとえば、c# は必要ありませんデストラクターの実行は、対象となるとすぐに、オブジェクトを収集またはデストラクターの実行します。For instance, C# does not require that destructors be run or that objects be collected as soon as they are eligible, or that destructors be run in any particular order, or on any particular thread.

クラスの静的メソッドを使用して、ある程度までのガベージ コレクターの動作を制御できますSystem.GCします。The behavior of the garbage collector can be controlled, to some degree, via static methods on the class System.GC. このクラスは、コレクションの実行 (または実行されません)、デストラクターの実行を要求するために使用してなど。This class can be used to request a collection to occur, destructors to be run (or not run), and so forth.

ガベージ コレクターがオブジェクトを収集し、デストラクターを実行する状況の判断に広くを許可されているために、準拠した実装は次のコードで示されているのとは異なる出力を生成可能性があります。Since the garbage collector is allowed wide latitude in deciding when to collect objects and run destructors, a conforming implementation may produce output that differs from that shown by the following code. プログラムThe program

using System;

class A
{
    ~A() {
        Console.WriteLine("Destruct instance of A");
    }
}

class B
{
    object Ref;

    public B(object o) {
        Ref = o;
    }

    ~B() {
        Console.WriteLine("Destruct instance of B");
    }
}

class Test
{
    static void Main() {
        B b = new B(new A());
        b = null;
        GC.Collect();
        GC.WaitForPendingFinalizers();
    }
}

クラスのインスタンスを作成しますAクラスのインスタンスとBします。creates an instance of class A and an instance of class B. これらのオブジェクトがガベージ コレクションの対象になるときに変数b値が割り当てられているnullこの時刻より後ではないためそれらにアクセスするユーザーが記述したコードを可能な。These objects become eligible for garbage collection when the variable b is assigned the value null, since after this time it is impossible for any user-written code to access them. 出力は、いずれかThe output could be either

Destruct instance of A
Destruct instance of B

またはor

Destruct instance of B
Destruct instance of A

注文の言語の制約がないため、オブジェクトはガベージ コレクションです。because the language imposes no constraints on the order in which objects are garbage collected.

わかりにくい場合は、「消滅できる」と「コレクションの対象」の違いは重要にできます。In subtle cases, the distinction between "eligible for destruction" and "eligible for collection" can be important. 例えば以下のようにします。For example,

using System;

class A
{
    ~A() {
        Console.WriteLine("Destruct instance of A");
    }

    public void F() {
        Console.WriteLine("A.F");
        Test.RefA = this;
    }
}

class B
{
    public A Ref;

    ~B() {
        Console.WriteLine("Destruct instance of B");
        Ref.F();
    }
}

class Test
{
    public static A RefA;
    public static B RefB;

    static void Main() {
        RefB = new B();
        RefA = new A();
        RefB.Ref = RefA;
        RefB = null;
        RefA = null;

        // A and B now eligible for destruction
        GC.Collect();
        GC.WaitForPendingFinalizers();

        // B now eligible for collection, but A is not
        if (RefA != null)
            Console.WriteLine("RefA is not null");
    }
}

ガベージ コレクターがのデストラクターを実行する場合は、上記のプログラムでAのデストラクターの前にB、このプログラムの出力である可能性があります。In the above program, if the garbage collector chooses to run the destructor of A before the destructor of B, then the output of this program might be:

Destruct instance of A
Destruct instance of B
A.F
RefA is not null

インスタンスA使用されていないとAのデストラクターが実行された、方法のことができますがA(この場合、 F) 別のデストラクターから呼び出されます。Note that although the instance of A was not in use and A's destructor was run, it is still possible for methods of A (in this case, F) to be called from another destructor. また、デストラクターの実行は、オブジェクトをもう一度でメインライン プログラムから使用可能な状態で発生する可能性がありますに注意してください。Also, note that running of a destructor may cause an object to become usable from the mainline program again. ここでの実行Bデストラクターは、インスタンスの原因となったAが以前ではなくを使用するライブ参照からアクセスできるようにTest.RefAします。In this case, the running of B's destructor caused an instance of A that was previously not in use to become accessible from the live reference Test.RefA. 呼び出し後WaitForPendingFinalizersのインスタンスBが、コレクションが、インスタンスの対象であるA、参照が原因でないTest.RefAします。After the call to WaitForPendingFinalizers, the instance of B is eligible for collection, but the instance of A is not, because of the reference Test.RefA.

混乱や予期しない動作を避けるため、一般に、お勧めのデストラクターのみ、オブジェクトのフィールドに格納されているデータに対してクリーンアップを実行してを参照先のオブジェクトまたは静的フィールドに対するアクションは実行が。To avoid confusion and unexpected behavior, it is generally a good idea for destructors to only perform cleanup on data stored in their object's own fields, and not to perform any actions on referenced objects or static fields.

デストラクターを使用する代わりには、実装クラスを使用する、System.IDisposableインターフェイス。An alternative to using destructors is to let a class implement the System.IDisposable interface. これにより、クライアントは、リソースとして、オブジェクトにアクセスして、通常、オブジェクトのリソースを解放するタイミングを決定するオブジェクトのusingステートメント (、ステートメントを使用して)。This allows the client of the object to determine when to release the resources of the object, typically by accessing the object as a resource in a using statement (The using statement).

実行順序Execution order

C# プログラムの実行は、各実行中のスレッドの副作用が重大な実行ポイントで維持されるように進みます。Execution of a C# program proceeds such that the side effects of each executing thread are preserved at critical execution points. A副作用読み取りまたは書き込み volatile フィールドの非揮発性変数への書き込み、外部のリソースと、例外のスローへの書き込みとして定義されます。A side effect is defined as a read or write of a volatile field, a write to a non-volatile variable, a write to an external resource, and the throwing of an exception. 副作用の順序を保持する必要がある重大な実行ポイントは volatile フィールドへの参照 (Volatile フィールド)、lockステートメント (lock ステートメント)、およびスレッドの作成と終了します。The critical execution points at which the order of these side effects must be preserved are references to volatile fields (Volatile fields), lock statements (The lock statement), and thread creation and termination. 実行環境では、次の制約を前提と c# プログラムの実行の順序を変更する無料です。The execution environment is free to change the order of execution of a C# program, subject to the following constraints:

  • データの依存関係は、実行のスレッド内で保持されます。Data dependence is preserved within a thread of execution. つまり、各変数の値は、スレッドのすべてのステートメントは、元のプログラムの順序で実行されたかのように計算されます。That is, the value of each variable is computed as if all statements in the thread were executed in original program order.
  • 初期化の順序の規則は保持されます (フィールドの初期化変数初期化子)。Initialization ordering rules are preserved (Field initialization and Variable initializers).
  • 揮発性の読み取りと書き込みに関して、副作用の順序は保持されます (Volatile フィールド)。The ordering of side effects is preserved with respect to volatile reads and writes (Volatile fields). さらに、その式の値が使用されないことと、必要な副作用は生成されません (メソッドの呼び出しまたは volatile フィールドへのアクセスが原因でいずれかを含む) を推定できる場合、実行環境は式の一部を評価しない必要があります。Additionally, the execution environment need not evaluate part of an expression if it can deduce that that expression's value is not used and that no needed side effects are produced (including any caused by calling a method or accessing a volatile field). (別のスレッドによってスローされる例外) など、非同期イベントでは、プログラムの実行が中断された場合、監視可能な副作用が元のプログラムの順序で表示されることは限りません。When program execution is interrupted by an asynchronous event (such as an exception thrown by another thread), it is not guaranteed that the observable side effects are visible in the original program order.