基本的な概念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つのプログラム内では、クラスまたは構造体に、アプリケーションのエントリポイントとして使用されることを修飾する 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. ただし、複数のパラメーターがある場合、またはその唯一のパラメーターが型 string[]以外の場合は、Main の他のオーバーロードされたバージョンを使用できます。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_declarationを持たないnamespace_member_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_declaration内のnamespace_member_declarationは、完全修飾された同じ名前空間名を持つ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_parameters を介してこの宣言領域に導入されます。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 およびparameter_arrays) とtype_parameters を使用して、この宣言領域に導入されます。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 およびparameter_arrays) とtype_parameters を使用して、この宣言領域に導入されます。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 、およびforforeach 、およびusingステートメントでは、ローカル変数とローカル定数のローカル変数宣言空間が作成されます。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_declarations を介してこの宣言領域に導入されます。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_statements を介してこの宣言領域に導入され、名前は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.

名前空間の宣言領域は "open 終了" であり、同じ完全修飾名を持つ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.Customer および Megacorp.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. したがって、次の例では、F メソッドと G メソッドによってコンパイル時エラーが発生します。これは、名前 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. ただし、2つの iが入れ子になっていない個別のブロックで宣言されているため、H メソッドと 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 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

列挙体のメンバーは、列挙体で宣言された定数と、列挙体の direct 基底クラス 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 修飾子を含めることによって選択されます。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 修飾子を含めることによって選択されます。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 修飾子を含めることによって選択されます。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 internal (protected または internal)。メンバー宣言に 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 修飾子を含めることによって選択されます。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 として宣言されたアクセシビリティを持つことができ、構造体は暗黙的にシールされるため、宣言されたアクセシビリティを既定で privateStruct 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_declarations に含まれるすべてのプログラムテキストとして定義されます (場合によっては、型の中で入れ子になっている型を含みます)。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).

定義済みの型 (objectintdoubleなど) のアクセシビリティドメインは無制限です。The accessibility domain of a predefined type (such as object, int, or double) is unlimited.

プログラム P で宣言されている最上位レベルのバインドされていない型 T のアクセシビリティドメインは、次のように定義されています。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:

  • 宣言された T のアクセシビリティが public場合、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.

入れ子になったメンバーのアクセシビリティドメインは、プログラム内で T 型で宣言されている M 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.
  • 宣言された M のアクセシビリティが protected internal場合は、P のプログラムテキストと Tから派生した任意の型のプログラムテキストの和集合に D します。これは 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 のアクセシビリティドメインは、T のアクセシビリティドメインと Dの共通部分です。The accessibility domain of M is the intersection of the accessibility domain of T with D.
  • 宣言された M のアクセシビリティが protected場合は、T のプログラムテキストと Tから派生した任意の型のプログラムテキストの和集合を D ます。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 のアクセシビリティドメインは、T のアクセシビリティドメインと Dの共通部分です。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:

  • 1つ目の方法として 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.XB.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.C および B.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.C および B.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 クラスは、A クラスからプライベートメンバー x を継承します。the B class inherits the private member x from the A class. メンバーはプライベートであるため、Aclass_body内でのみアクセスできます。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.

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

  • Mフォームの修飾されていないtype_nameまたはprimary_expressionAn unqualified type_name or primary_expression of the form M.
  • フォーム E.Mprimary_expressionE の型が T であるか、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
  • フォーム base.Mprimary_expressionA 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内では、ABの両方のインスタンスを介して x にアクセスすることができます。どちらの場合も、アクセスは 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内では、ABから派生していないため、Aのインスタンスを介して x にアクセスすることはできません。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";
    }
}

x に対する3つの割り当ては、ジェネリック型から構築されたクラス型のインスタンスを通じてすべての処理が行われるため、許可されます。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. つまり、M にアクセスできるすべてのコンテキストで T にアクセスできる場合、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() {...}
}

BH メソッドは、戻り値の型 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.

out および ref パラメーター修飾子はシグネチャの一部と見なされますが、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
}

ref および out パラメーター修飾子 (メソッドパラメーター) は、シグネチャの一部であることに注意してください。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_declarationを含まないnamespace_member_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.
  • 完全修飾名が Nnamespace_declaration内のnamespace_member_declarationによって宣言された名前空間メンバーのスコープは、完全修飾名が namespace_declaration であるか N で始まり、その後にピリオドが続くすべての Nnamespace_bodyです。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_attributesおよびnamespace_member_declarationを超えています。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によって定義またはインポートされた名前のスコープ (ディレクティブを使用) は、 using_directiveが発生するcompilation_unitまたはnamespace_bodynamespace_member_declarationを超えています。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. 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.
  • Class_declaration (クラス宣言) のtype_parameter_listによって宣言された型パラメーターのスコープは、そのclass_bodyclass_basetype_parameter_constraints_clauses、および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.
  • Struct_declaration (構造体宣言) のtype_parameter_listによって宣言された型パラメーターのスコープは、そのstruct_bodystruct_interfacestype_parameter_constraints_clauses、および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.
  • Interface_declaration (インターフェイス宣言) のtype_parameter_listによって宣言された型パラメーターのスコープは、そのinterface_bodyinterface_basetype_parameter_constraints_clauses、および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.
  • Delegate_declaration (デリゲート宣言) のtype_parameter_listによって宣言された型パラメーターのスコープは、そのtype_parameter_constraints_clausereturn_typeformal_parameter_list、および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_declarationmethod_bodyです。The scope of a parameter declared in a method_declaration (Methods) is the method_body of that method_declaration.
  • Indexer_declaration (インデクサー) で宣言されたパラメーターのスコープは、そのindexer_declarationaccessor_declarationsです。The scope of a parameter declared in an indexer_declaration (Indexers) is the accessor_declarations of that indexer_declaration.
  • Operator_declaration (Operators) で宣言されたパラメーターのスコープは、そのoperator_declarationブロックです。The scope of a parameter declared in an operator_declaration (Operators) is the block of that operator_declaration.
  • Constructor_declaration (インスタンスコンストラクター) で宣言されたパラメーターのスコープは、そのconstructor_declarationconstructor_initializerおよびブロックです。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_expressionThe 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 ステートメント (switch ステートメント) のswitch_blockで宣言されたローカル変数のスコープは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 ステートメント (for ステートメント) のfor_initializerで宣言されたローカル変数のスコープは、 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_declaration内の以前のlocal_variable_declaratorで宣言されたローカル変数を正しく参照します。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)Inner で宣言された F を呼び出します。これは、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
}

DerivedF を宣言すると、警告が報告されます。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 修飾子は Derived 内の F が "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
}

上の例では、Derived 内の F の宣言によって Baseから継承された F が非表示になりますが、F の新しい Derived にはプライベートアクセスがあるため、そのスコープは 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. したがって、MoreDerived.G 内の F() 呼び出しは有効で、Base.Fを呼び出します。Thus, the call F() in MoreDerived.G is valid and will invoke Base.F.

名前空間と型名Namespace and type names

プログラム内のいくつかのコンテキストでは、 namespace_nameまたは type_name を指定する必要があります。 C#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
    ;

Namespace_nameは、名前空間を参照するnamespace_or_type_nameです。A namespace_name is a namespace_or_type_name that refers to a namespace. 以下で説明するように、 namespace_namenamespace_or_type_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).

Type_nameは、型を参照するnamespace_or_type_nameです。A type_name is a namespace_or_type_name that refers to a type. 以下で説明するように、 type_namenamespace_or_type_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が修飾エイリアスメンバーである場合は、「名前空間エイリアス修飾子」で説明されているように意味があります。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 が1つの識別子であり、Nnamespace_or_type_nameであり、<A1, ..., Ak> は省略可能なtype_argument_listです。where 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がジェネリックメソッド宣言 (メソッド) 内に存在し、その宣言に Iという名前の型パラメーター (パラメーター) が含まれている場合、 namespace_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 がゼロで、T の宣言に Iという名前の型パラメーターが含まれている場合、 namespace_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 またはその基本型のいずれかに、名前 I および Kの型パラメーターを持つ入れ子になったアクセス可能な型が含まれている場合、 * * は、指定された型引数を使用して構築されたその型を参照します。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. このような型が複数ある場合は、より多くの派生型で宣言された型が選択されます。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.
    • 前の手順が正常に完了しなかった場合は、各名前空間 Nnamespace_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* はあいまいで、コンパイル時エラーが発生します。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_nameN内の I という名前空間を参照します。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 がゼロで、 namespace_or_type_nameが発生した場所が N の名前空間宣言によって囲まれており、名前空間を名前空間または型に関連付けるextern_alias_directiveまたはusing_alias_directiveが名前空間宣言に含まれている場合、 * I* はあいまいで、コンパイル時エラーが発生します。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 がゼロで、名前空間の宣言に、名前 I をインポートした名前空間または型に関連付けるextern_alias_directiveまたはusing_alias_directiveが含まれている場合、 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によってインポートされた名前空間と型の宣言に、name I および Kの型パラメーターを持つアクセス可能な型が1つだけ含まれる場合、 * * は、指定された型引数を使用して構築されたその型を参照します。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によってインポートされた名前空間と型の宣言に、名前 I および Kの型パラメーターを持つアクセス可能な型が複数含まれていると、 * * があいまいになり、エラーが発生します。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 が名前空間を参照し、NI名前の入れ子になった名前空間を含んでいる場合、 namespace_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 名前 I および K型パラメーターを持つアクセス可能な型が含まれている場合、 * * は、指定された型引数を使用して構築されたその型を参照します。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 またはその基本クラスに、名前 I および K型パラメーターを持つ入れ子になったアクセス可能な型が含まれている場合、 * * は、指定された型引数を使用して構築された型を参照します。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. このような型が複数ある場合は、より多くの派生型で宣言された型が選択されます。If there is more than one such type, the type declared within the more derived type is selected. N.I の意味が N の基底クラスの指定の解決の一部として決定される場合、N の直接の基底クラスは object (基底クラス) と見なされます。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.

Namespace_or_type_nameは、静的クラス (静的クラス) を参照することが許可されています。A namespace_or_type_name is permitted to reference a static class (Static classes) only if

  • Namespace_or_type_nameT.Iフォームのnamespace_or_type_nameT です。The namespace_or_type_name is the T in a namespace_or_type_name of the form T.I, or
  • Namespace_or_type_nameは、typeof(T)フォームのtypeof_expression (引数リスト1) の 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になります。 SN が宣言されている名前空間または型の完全修飾名です。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. 通常の状況下では、オブジェクトのデストラクターが1回だけ実行されます。ただし、実装固有の Api では、この動作がオーバーライドされる可能性があります。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");
    }
}

上記のプログラムでは、ガベージコレクターが Bのデストラクターの前に A のデストラクターを実行するように選択した場合、このプログラムの出力は次のようになります。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 ステートメント (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. 副作用は、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.