共通型システムCommon Type System

共通型システム (CTS: Common Type System) は、共通言語ランタイムにおける型の宣言、使用、および管理の方法を定義しており、ランタイムによる言語間統合のサポートにおいても重要な役割を果たします。The common type system defines how types are declared, used, and managed in the common language runtime, and is also an important part of the runtime's support for cross-language integration. 共通型システムには次のような機能があります。The common type system performs the following functions:

  • 言語間の統合、タイプ セーフ、およびパフォーマンスの高いコードの実行を可能にするフレームワークを確立します。Establishes a framework that helps enable cross-language integration, type safety, and high-performance code execution.

  • さまざまなプログラミング言語の完全な実装をサポートするオブジェクト指向モデルを提供します。Provides an object-oriented model that supports the complete implementation of many programming languages.

  • 異なる言語で記述されたオブジェクトが相互に対話できるように、各言語が準拠すべき規則を定義します。Defines rules that languages must follow, which helps ensure that objects written in different languages can interact with each other.

  • アプリケーション開発に使用されるプリミティブ データ型 (BooleanByteCharInt32UInt64 など) を含んだライブラリを提供します。Provides a library that contains the primitive data types (such as Boolean, Byte, Char, Int32, and UInt64) used in application development.

このトピックは、次のセクションで構成されています。This topic contains the following sections:

.NET の型Types in .NET

.NET に存在するすべての型は、値型と参照型のどちらかに区別されます。All types in .NET are either value types or reference types.

値型は、オブジェクトがその実際の値で表されるデータ型です。Value types are data types whose objects are represented by the object's actual value. 変数に値型のインスタンスが割り当てられると、その変数には値の新しいコピーが代入されます。If an instance of a value type is assigned to a variable, that variable is given a fresh copy of the value.

参照型は、オブジェクトがその実際の値を指す参照 (ポインターのようなもの) によって表されるデータ型です。Reference types are data types whose objects are represented by a reference (similar to a pointer) to the object's actual value. 参照型が変数に割り当てられている場合、その変数は元の値を参照します (つまり、元の値を指します)。If a reference type is assigned to a variable, that variable references (points to) the original value. コピーは作成されません。No copy is made.

.NET の共通型システムは、次の 5 つの型のカテゴリをサポートしています。The common type system in .NET supports the following five categories of types:

クラスClasses

クラスは参照型であり、他のクラスから直接派生させることも、System.Object から暗黙的に派生させることもできます。A class is a reference type that can be derived directly from another class and that is derived implicitly from System.Object. クラスは、オブジェクト (クラスのインスタンス) が実行できる操作 (メソッド、イベント、またはプロパティ) およびオブジェクトが保持するデータ (フィールド) を定義するものです。The class defines the operations that an object (which is an instance of the class) can perform (methods, events, or properties) and the data that the object contains (fields). 通常、クラスは、たとえば定義のみを持ち実装は持たないインターフェイスとは対照的に、定義と実装の両方を持ちます。しかし、実装を持たないメンバーが 1 つ以上存在するクラスもあります。Although a class generally includes both definition and implementation (unlike interfaces, for example, which contain only definition without implementation), it can have one or more members that have no implementation.

クラスが持つことのできる特性のいくつかを次の表で説明します。The following table describes some of the characteristics that a class may have. ランタイムをサポートする言語にはそれぞれ、クラスまたはクラス メンバーに対し、こうした特性の 1 つ以上を指定する手段が用意されています。Each language that supports the runtime provides a way to indicate that a class or class member has one or more of these characteristics. ただし、.NET を対象とするすべてのプログラミング言語で、これらすべての特性を利用できるわけではありません。However, individual programming languages that target .NET may not make all these characteristics available.

特徴Characteristic 説明Description
sealedsealed 型から別のクラスを派生できないことを示します。Specifies that another class cannot be derived from this type.
実装implements クラスが、インターフェイスのメンバーの実装を提供することによって、1 つ以上のインターフェイスを使用することを示します。Indicates that the class uses one or more interfaces by providing implementations of interface members.
abstractabstract クラスをインスタンス化できないことを示します。Indicates that the class cannot be instantiated. クラスを使用するには、このクラスから別のクラスを派生させる必要があります。To use it, you must derive another class from it.
継承inherits クラスのインスタンスを、基底クラスが指定されている任意の場所で使用できることを示します。Indicates that instances of the class can be used anywhere the base class is specified. 基底クラスから継承する派生クラスは、基底クラスによって提供されるすべてのパブリック メンバーの実装を使用できます。または、派生クラスは、パブリック メンバーの実装をその独自の実装でオーバーライドできます。A derived class that inherits from a base class can use the implementation of any public members provided by the base class, or the derived class can override the implementation of the public members with its own implementation.
exported または not exportedexported or not exported クラスが定義されているアセンブリの外部から、そのクラスを参照できるかどうかを示します。Indicates whether a class is visible outside the assembly in which it is defined. この特性は、最上位のクラスにのみ適用され、入れ子にされたクラスには適用されません。This characteristic applies only to top-level classes and not to nested classes.

注意

クラスは、親クラスまたは構造体で入れ子にすることもできます。A class can also be nested in a parent class or structure. 入れ子にされたクラスにも、メンバー特性を適用できます。Nested classes also have member characteristics. 詳細については、「入れ子にされた型」を参照してください。For more information, see Nested Types.

実装を持たないクラス メンバーは抽象メンバーです。Class members that have no implementation are abstract members. 1 つ以上の抽象メンバーを持つクラスは、それ自体が抽象クラスとなり、新しいインスタンスを作成できません。A class that has one or more abstract members is itself abstract; new instances of it cannot be created. ランタイムに対応する言語の中には、抽象メンバーを持たないクラスも抽象クラスとしてマークできるものがあります。Some languages that target the runtime let you mark a class as abstract even if none of its members are abstract. 抽象クラスは、派生クラスが必要に応じて継承したりオーバーライドしたりできる基本的な一連の機能をカプセル化する必要がある場合に使用できます。You can use an abstract class when you want to encapsulate a basic set of functionality that derived classes can inherit or override when appropriate. 抽象クラスでないクラスを具象クラスと呼びます。Classes that are not abstract are referred to as concrete classes.

クラスで実装できるインターフェイスの数に制限はありませんが、すべてのクラスが暗黙的に継承する System.Object を除き、継承できる基底クラスは 1 つだけです。A class can implement any number of interfaces, but it can inherit from only one base class in addition to System.Object, from which all classes inherit implicitly. すべてのクラスには少なくとも 1 つのコンストラクターが必要で、このコンストラクターにより、各クラスの新しいインスタンスが初期化されます。All classes must have at least one constructor, which initializes new instances of the class. コンストラクターを明示的に定義しなかった場合、ほとんどのコンパイラでは、自動的にパラメーターなしのコンストラクターが使用されます。If you do not explicitly define a constructor, most compilers will automatically provide a parameterless constructor.

構造体Structures

構造体は、System.ValueType から派生する System.Object から暗黙的に派生する値型です。A structure is a value type that derives implicitly from System.ValueType, which in turn is derived from System.Object. 構造体は、メモリ要件が小さい値を表す場合や、厳密に型指定されたパラメーターを持つメソッドに対してパラメーターを値渡しする場合などに、非常に便利です。A structure is very useful for representing values whose memory requirements are small, and for passing values as by-value parameters to methods that have strongly typed parameters. .NET では、すべてのプリミティブ データ型 (BooleanByteCharDateTimeDecimalDoubleInt16Int32Int64SByteSingleUInt16UInt32UInt64) が構造体として定義されています。In .NET, all primitive data types (Boolean, Byte, Char, DateTime, Decimal, Double, Int16, Int32, Int64, SByte, Single, UInt16, UInt32, and UInt64) are defined as structures.

クラスと同様、構造体にもデータ (構造体のフィールド) と、そのデータに対して実行できる操作 (構造体のメソッド) が定義されます。Like classes, structures define both data (the fields of the structure) and the operations that can be performed on that data (the methods of the structure). これは、System.Object クラスと System.ValueType クラスで定義されている仮想メソッドなどのメソッドと、値型そのものに定義されているすべてのメソッドを、構造体に対して呼び出すことができることを意味します。This means that you can call methods on structures, including the virtual methods defined on the System.Object and System.ValueType classes, and any methods defined on the value type itself. 言い換えれば、構造体には、静的メソッドと非静的メソッドに加え、フィールド、プロパティ、およびイベントを持たせることができます。In other words, structures can have fields, properties, and events, as well as static and nonstatic methods. 構造体のインスタンスを作成したり、構造体をパラメーターとして渡したりできるほか、構造体をローカル変数として格納することも、別の値型または参照型のフィールドに格納することもできます。You can create instances of structures, pass them as parameters, store them as local variables, or store them in a field of another value type or reference type. 構造体でインターフェイスを実装することもできます。Structures can also implement interfaces.

ただし、値型は、いくつかの点でクラスとは異なります。Value types also differ from classes in several respects. まず、値型は System.ValueType を暗黙的に継承しますが、他の型を直接継承することはできません。First, although they implicitly inherit from System.ValueType, they cannot directly inherit from any type. 同様に、すべての値型には、値型から他の型が派生できないことを示す sealed 属性が適用されます。Similarly, all value types are sealed, which means that no other type can be derived from them. また、値型はコンストラクターを必要としません。They also do not require constructors.

共通言語ランタイムは、それぞれの値型に対応するボックス化された型を提供します。ボックス化された型とは、値型と同じ状態および動作を備えたクラスのことです。For each value type, the common language runtime supplies a corresponding boxed type, which is a class that has the same state and behavior as the value type. 値型のインスタンスは、System.Object 型のパラメーターを受け入れるメソッドに渡されると、ボックス化されます。An instance of a value type is boxed when it is passed to a method that accepts a parameter of type System.Object. 参照渡しのパラメーターとして値型を受け入れるメソッドの呼び出しから制御が返されると、ボックス化が解除 (つまり、クラスのインスタンスから値型のインスタンスに変換) されます。It is unboxed (that is, converted from an instance of a class back to an instance of a value type) when control returns from a method call that accepts a value type as a by-reference parameter. 言語によっては、ボックス化された型が必要なときに特別な構文を使用する必要がありますが、ボックス化された型を必要に応じて自動的に使用する言語もあります。Some languages require that you use special syntax when the boxed type is required; others automatically use the boxed type when it is needed. 値型を定義するときには、ボックス化された型とボックス化解除された型の両方を定義します。When you define a value type, you are defining both the boxed and the unboxed type.

列挙Enumerations

列挙型 (enum) は、System.Enum から直接継承される値型で、基になるプリミティブ型の値に対して別名を割り当てます。An enumeration (enum) is a value type that inherits directly from System.Enum and that supplies alternate names for the values of an underlying primitive type. 列挙型には名前、基になる型、および一連のフィールドが存在します。基になる型は、組み込みの符号付きまたは符号なし整数型 (ByteInt32UInt64 など) であることが必要です。An enumeration type has a name, an underlying type that must be one of the built-in signed or unsigned integer types (such as Byte, Int32, or UInt64), and a set of fields. フィールドは静的リテラル フィールドで、各フィールドが 1 つの定数を表します。The fields are static literal fields, each of which represents a constant. 複数のフィールドに同じ値を割り当てることもできます。The same value can be assigned to multiple fields. その場合は、リフレクションや文字列変換を行うために、いずれかの値をプライマリ列挙値としてマークしておく必要があります。When this occurs, you must mark one of the values as the primary enumeration value for reflection and string conversion.

基になる型の値を列挙型に割り当てることも、その逆も可能です (キャストは必要ありません)。You can assign a value of the underlying type to an enumeration and vice versa (no cast is required by the runtime). 列挙型のインスタンスを作成し、System.Enum のメソッドや、その列挙型の基となる型に定義されている任意のメソッドを呼び出すことができます。You can create an instance of an enumeration and call the methods of System.Enum, as well as any methods defined on the enumeration's underlying type. しかし、言語によっては、基になる型のインスタンスが必要とされるときに、列挙型をパラメーターとして渡すことが許可されていない場合もあります (またはその逆)。However, some languages might not let you pass an enumeration as a parameter when an instance of the underlying type is required (or vice versa).

また、列挙型には次のような制限があります。The following additional restrictions apply to enumerations:

  • 独自のメソッドは定義できません。They cannot define their own methods.

  • インターフェイスを実装できません。They cannot implement interfaces.

  • プロパティまたはイベントを定義できません。They cannot define properties or events.

  • 列挙型は、ジェネリック型に入れ子にされているという理由だけでジェネリックである場合を除き、ジェネリックにはなりません。They cannot be generic, unless they are generic only because they are nested within a generic type. つまり、列挙型は、独自の型パラメーターを持つことができません。That is, an enumeration cannot have type parameters of its own.

    注意

    Visual Basic、C#、および C++ で作成された入れ子にされた型 (列挙型を含む) は、それを囲むすべてのジェネリック型の型パラメーターを含むため、独自の型パラメーターは持ちませんが、ジェネリックです。Nested types (including enumerations) created with Visual Basic, C#, and C++ include the type parameters of all enclosing generic types, and are therefore generic even if they do not have type parameters of their own. 詳細については、「Type.MakeGenericType」のリファレンス トピックの「入れ子にされた型」を参照してください。For more information, see "Nested Types" in the Type.MakeGenericType reference topic.

FlagsAttribute 属性は、ビット フィールドと呼ばれる特別な種類の列挙型を表します。The FlagsAttribute attribute denotes a special kind of enumeration called a bit field. ランタイム自体は通常の列挙型とビット フィールドを区別しませんが、言語の中にはそれらを区別するものもあります。The runtime itself does not distinguish between traditional enumerations and bit fields, but your language might do so. 列挙型とビット フィールドが区別される場合、ビット フィールドではビットごとの演算子を使用して名前のない値を生成できますが、列挙型ではビットごとの演算子は使用できません。When this distinction is made, bitwise operators can be used on bit fields, but not on enumerations, to generate unnamed values. 通常、列挙型は、曜日、国名、地域名などの一意の要素のリストに使用されます。Enumerations are generally used for lists of unique elements, such as days of the week, country or region names, and so on. 通常、ビット フィールドは、Red And Big And Fast のような、特性や数量を組み合わせて示すリストに使用されます。Bit fields are generally used for lists of qualities or quantities that might occur in combination, such as Red And Big And Fast.

ビット フィールドと通常の列挙型を両方とも使用する方法を次の例に示します。The following example shows how to use both bit fields and traditional enumerations.

using System;
using System.Collections.Generic;

// A traditional enumeration of some root vegetables.
public enum SomeRootVegetables
{
    HorseRadish,
    Radish,
    Turnip
}

// A bit field or flag enumeration of harvesting seasons.
[Flags]
public enum Seasons
{
    None = 0,
    Summer = 1,
    Autumn = 2,
    Winter = 4,
    Spring = 8,
    All = Summer | Autumn | Winter | Spring
}

public class Example
{
   public static void Main()
   {
       // Hash table of when vegetables are available.
       Dictionary<SomeRootVegetables, Seasons> AvailableIn = new Dictionary<SomeRootVegetables, Seasons>();

       AvailableIn[SomeRootVegetables.HorseRadish] = Seasons.All;
       AvailableIn[SomeRootVegetables.Radish] = Seasons.Spring;
       AvailableIn[SomeRootVegetables.Turnip] = Seasons.Spring | 
            Seasons.Autumn;

       // Array of the seasons, using the enumeration.
       Seasons[] theSeasons = new Seasons[] { Seasons.Summer, Seasons.Autumn, 
            Seasons.Winter, Seasons.Spring };

       // Print information of what vegetables are available each season.
       foreach (Seasons season in theSeasons)
       {
          Console.Write(String.Format(
              "The following root vegetables are harvested in {0}:\n", 
              season.ToString("G")));
          foreach (KeyValuePair<SomeRootVegetables, Seasons> item in AvailableIn)
          {
             // A bitwise comparison.
             if (((Seasons)item.Value & season) > 0)
                 Console.Write(String.Format("  {0:G}\n", 
                      (SomeRootVegetables)item.Key));
          }
       }
   }
}
// The example displays the following output:
//    The following root vegetables are harvested in Summer:
//      HorseRadish
//    The following root vegetables are harvested in Autumn:
//      Turnip
//      HorseRadish
//    The following root vegetables are harvested in Winter:
//      HorseRadish
//    The following root vegetables are harvested in Spring:
//      Turnip
//      Radish
//      HorseRadish
Imports System.Collections.Generic

' A traditional enumeration of some root vegetables.
Public Enum SomeRootVegetables
   HorseRadish
   Radish
   Turnip
End Enum 

' A bit field or flag enumeration of harvesting seasons.
<Flags()> Public Enum Seasons
   None = 0
   Summer = 1
   Autumn = 2
   Winter = 4
   Spring = 8
   All = Summer Or Autumn Or Winter Or Spring
End Enum 

' Entry point.
Public Class Example
   Public Shared Sub Main()
      ' Hash table of when vegetables are available.
      Dim AvailableIn As New Dictionary(Of SomeRootVegetables, Seasons)()
        
      AvailableIn(SomeRootVegetables.HorseRadish) = Seasons.All
      AvailableIn(SomeRootVegetables.Radish) = Seasons.Spring
      AvailableIn(SomeRootVegetables.Turnip) = Seasons.Spring Or _
                                               Seasons.Autumn
        
      ' Array of the seasons, using the enumeration.
      Dim theSeasons() As Seasons = {Seasons.Summer, Seasons.Autumn, _
                                     Seasons.Winter, Seasons.Spring}
        
      ' Print information of what vegetables are available each season.
      For Each season As Seasons In theSeasons
         Console.WriteLine(String.Format( _
              "The following root vegetables are harvested in {0}:", _
              season.ToString("G")))
         For Each item As KeyValuePair(Of SomeRootVegetables, Seasons) In AvailableIn
            ' A bitwise comparison.
            If(CType(item.Value, Seasons) And season) > 0 Then
               Console.WriteLine("  " + _
                     CType(item.Key, SomeRootVegetables).ToString("G"))
            End If
         Next
      Next
   End Sub 
End Class 
' The example displays the following output:
'    The following root vegetables are harvested in Summer:
'      HorseRadish
'    The following root vegetables are harvested in Autumn:
'      Turnip
'      HorseRadish
'    The following root vegetables are harvested in Winter:
'      HorseRadish
'    The following root vegetables are harvested in Spring:
'      Turnip
'      Radish
'      HorseRadish

インターフェイスInterfaces

インターフェイスは、"can do" 関係または "has a" 関係を指定するコントラクトを定義します。An interface defines a contract that specifies a "can do" relationship or a "has a" relationship. インターフェイスは、多くの場合、比較と並べ替え (IComparable インターフェイスや IComparable<T> インターフェイス)、等価テスト (IEquatable<T> インターフェイス)、コレクション内の項目の列挙 (IEnumerable インターフェイスや IEnumerable<T> インターフェイス) などの機能を実装するために使用されます。Interfaces are often used to implement functionality, such as comparing and sorting (the IComparable and IComparable<T> interfaces), testing for equality (the IEquatable<T> interface), or enumerating items in a collection (the IEnumerable and IEnumerable<T> interfaces). インターフェイスには、プロパティ、メソッド、およびイベント (すべて抽象メンバー) を設定できます。つまり、インターフェイスは、メンバーとメンバーの署名を定義しますが、インターフェイス メンバーの機能を定義するインターフェイスを実装する型に依存します。Interfaces can have properties, methods, and events, all of which are abstract members; that is, although the interface defines the members and their signatures, it leaves it to the type that implements the interface to define the functionality of each interface member. これは、インターフェイスを実装するクラスまたは構造体が、そのインターフェイスで宣言されている抽象メンバーの定義を提供する必要があることを意味します。This means that any class or structure that implements an interface must supply definitions for the abstract members declared in the interface. インターフェイスは、そのインターフェイスを実装するクラスまたは構造体に対して、1 つ以上の他のインターフェイスも同時に実装するように要求できます。An interface can require any implementing class or structure to also implement one or more other interfaces.

インターフェイスには、次のような制限があります。The following restrictions apply to interfaces:

  • 任意のアクセシビリティを指定してインターフェイスを宣言できますが、そのすべてのメンバーのアクセシビリティは public であることが必要です。An interface can be declared with any accessibility, but interface members must all have public accessibility.

  • インターフェイスでコンストラクターを定義することはできません。Interfaces cannot define constructors.

  • インターフェイスでフィールドを定義することはできません。Interfaces cannot define fields.

  • インターフェイスで定義できるのはインスタンスのメンバーだけです。Interfaces can define only instance members. 静的メンバーを定義することはできません。They cannot define static members.

各言語には、メンバーの実装をそのメンバーを要求するインターフェイスに割り当てるための規則があります。これは、複数のインターフェイスで同じシグネチャを持つメンバーを宣言でき、それらのメンバーが別個の実装を持つことができるためです。Each language must provide rules for mapping an implementation to the interface that requires the member, because more than one interface can declare a member with the same signature, and these members can have separate implementations.

デリゲートDelegates

デリゲートは、C++ の関数ポインターと類似の目的で使用される参照型です。Delegates are reference types that serve a purpose similar to that of function pointers in C++. これらは、.NET のイベント ハンドラーとコールバック関数に使用されます。They are used for event handlers and callback functions in .NET. 関数ポインターとは異なり、デリゲートは安全で、検証可能で、タイプ セーフです。Unlike function pointers, delegates are secure, verifiable, and type safe. デリゲート型は、互換性のあるシグネチャを持つすべてのインスタンス メソッドまたは静的メソッドを表すことができます。A delegate type can represent any instance method or static method that has a compatible signature.

デリゲートのパラメーターにメソッドのパラメーターよりも限定的な型が指定された場合、両者のパラメーター間に型の互換性があると見なされます。これによって、デリゲートに渡された引数が、メソッドに対して安全に渡されることが保証されます。A parameter of a delegate is compatible with the corresponding parameter of a method if the type of the delegate parameter is more restrictive than the type of the method parameter, because this guarantees that an argument passed to the delegate can be passed safely to the method.

同様に、メソッドの戻り値の型の制限がデリゲートの戻り値の型より多いと、メソッドの戻り値がデリゲートの戻り値の型に安全にキャストされることが保証されるため、デリゲートの戻り値の型とメソッドの戻り値の型には互換性があります。Similarly, the return type of a delegate is compatible with the return type of a method if the return type of the method is more restrictive than the return type of the delegate, because this guarantees that the return value of the method can be cast safely to the return type of the delegate.

たとえば、IEnumerable 型のパラメーターおよび Object 型の戻り値を持つデリゲートは、Object 型のパラメーターおよび IEnumerable 型の戻り値を持ったメソッドを表すことができます。For example, a delegate that has a parameter of type IEnumerable and a return type of Object can represent a method that has a parameter of type Object and a return value of type IEnumerable. 詳細およびプログラム例については、「Delegate.CreateDelegate(Type, Object, MethodInfo)」を参照してください。For more information and example code, see Delegate.CreateDelegate(Type, Object, MethodInfo).

よく "デリゲートは、それが表すメソッドにバインドされる" と言われます。A delegate is said to be bound to the method it represents. デリゲートは、メソッドにバインドされる以外にも、オブジェクトにバインドされる場合もあります。In addition to being bound to the method, a delegate can be bound to an object. オブジェクトはメソッドの第 1 パラメーターを表し、デリゲートが呼び出されるたびにメソッドに渡されます。The object represents the first parameter of the method, and is passed to the method every time the delegate is invoked. インスタンス メソッドの場合、バインドされたオブジェクトは、暗黙的な this パラメーター (Visual Basic では Me) として渡されます。静的メソッドの場合、オブジェクトは、メソッドの 1 つ目の仮パラメーターとして渡され、デリゲートのシグネチャは、その残りのパラメーターと完全に一致している必要があります。If the method is an instance method, the bound object is passed as the implicit this parameter (Me in Visual Basic); if the method is static, the object is passed as the first formal parameter of the method, and the delegate signature must match the remaining parameters. 詳細およびプログラム例については、「System.Delegate」を参照してください。For more information and example code, see System.Delegate.

すべてのデリゲートが System.MulticastDelegate を継承し、System.MulticastDelegate は System.Delegate を継承します。All delegates inherit from System.MulticastDelegate, which inherits from System.Delegate. C#、Visual Basic、および C++ 言語では、これらの型からの継承は許可されていません。The C#, Visual Basic, and C++ languages do not allow inheritance from these types. 代わりに、デリゲートを宣言するためのキーワードが用意されています。Instead, they provide keywords for declaring delegates.

デリゲートは MulticastDelegate を継承するため、デリゲートには呼び出しリストがあります。これは、デリゲートが表し、デリゲートが呼び出されたときに実行されるメソッドのリストです。Because delegates inherit from MulticastDelegate, a delegate has an invocation list, which is a list of methods that the delegate represents and that are executed when the delegate is invoked. リストのすべてのメソッドは、デリゲートが呼び出されたときに指定される引数を受け取ります。All methods in the list receive the arguments supplied when the delegate is invoked.

注意

デリゲートに戻り値が含まれていても、呼び出しリストに複数のメソッドが含まれているデリゲートに対しては、戻り値は定義されません。The return value is not defined for a delegate that has more than one method in its invocation list, even if the delegate has a return type.

コールバック メソッドの場合のように、多くの場合、デリゲートは 1 つのメソッドのみを表すため、デリゲートを作成し、呼び出す以外の処理は必要ありません。In many cases, such as with callback methods, a delegate represents only one method, and the only actions you have to take are creating the delegate and invoking it.

複数のメソッドを表すデリゲートの場合、.NET は DelegateMulticastDelegate デリゲート クラスのメソッドを提供し、デリゲートの呼び出しリスト (Delegate.Combine メソッド) にメソッドを追加したり、メソッド (Delegate.Remove メソッド) を削除したり、呼び出しリスト (Delegate.GetInvocationListメソッド) を取得したりする操作をサポートしています。For delegates that represent multiple methods, .NET provides methods of the Delegate and MulticastDelegate delegate classes to support operations such as adding a method to a delegate's invocation list (the Delegate.Combine method), removing a method (the Delegate.Remove method), and getting the invocation list (the Delegate.GetInvocationList method).

注意

C#、C++、および Visual Basic では、イベント ハンドラー デリゲートに対して、これらのメソッドを使用する必要はありません。これらの言語には、イベント ハンドラーの追加および削除に使用する構文が用意されているためです。It is not necessary to use these methods for event-handler delegates in C#, C++, and Visual Basic, because these languages provide syntax for adding and removing event handlers.

型定義Type Definitions

型定義には、次のものが含まれます。A type definition includes the following:

  • 型に対して定義される属性Any attributes defined on the type.

  • 型のアクセシビリティ (参照範囲)The type's accessibility (visibility).

  • 型の名前The type's name.

  • 型の基本型The type's base type.

  • 型が実装するインターフェイスAny interfaces implemented by the type.

  • 型の各メンバーの定義Definitions for each of the type's members.

属性Attributes

属性を使用して、ユーザー定義のメタデータを追加できます。Attributes provide additional user-defined metadata. 属性の最も一般的な用途は、型についての補足的な情報をそのアセンブリに保存したり、型のメンバーの動作をデザイン時または実行時環境で変更したりすることです。Most commonly, they are used to store additional information about a type in its assembly, or to modify the behavior of a type member in either the design-time or run-time environment.

属性は、それ自体が System.Attribute を継承するクラスです。Attributes are themselves classes that inherit from System.Attribute. 属性を使用できる言語にはそれぞれ、言語要素に属性を適用するための固有の構文があります。Languages that support the use of attributes each have their own syntax for applying attributes to a language element. 属性はほぼすべての言語要素に適用できます。具体的にどの要素に属性を適用できるかは、その属性クラスに適用されている AttributeUsageAttribute によって定義されます。Attributes can be applied to almost any language element; the specific elements to which an attribute can be applied are defined by the AttributeUsageAttribute that is applied to that attribute class.

型のアクセシビリティType Accessibility

すべての型には、他の型からのアクセシビリティを制御する修飾子があります。All types have a modifier that governs their accessibility from other types. ランタイムによってサポートされる型のアクセシビリティについて次の表で説明します。The following table describes the type accessibilities supported by the runtime.

ユーザー補助Accessibility 説明Description
publicpublic すべてのアセンブリから型にアクセスできます。The type is accessible by all assemblies.
アセンブリassembly 同じアセンブリ内からだけ型にアクセスできます。The type is accessible only from within its assembly.

入れ子にされた型のアクセシビリティは、その型のアクセシビリティ ドメインによって決まります。このアクセシビリティ ドメインは、そのメンバーに対して宣言されているアクセシビリティと、そのメンバーの直接のコンテナーである型のアクセシビリティ ドメインの両方によって決定されます。The accessibility of a nested type depends on its accessibility domain, which is determined by both the declared accessibility of the member and the accessibility domain of the immediately containing type. ただし、入れ子にされた型のアクセシビリティ ドメインが、その型を含んでいる型のアクセシビリティ ドメインを上回ることはできません。However, the accessibility domain of a nested type cannot exceed that of the containing type.

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 might itself 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 の場合、M のアクセシビリティ ドメインは、T のアクセシビリティ ドメインと、P のプログラム テキストおよび T の外側で宣言された P から派生した任意の型のプログラム テキストとの積集合になります。If the declared accessibility of M is protected internal, the accessibility domain of M is the intersection of the accessibility domain of T with the program text of P and the program text of any type derived from T declared outside P.

  • M に対して宣言されているアクセシビリティが protected の場合、M のアクセシビリティ ドメインは、T のアクセシビリティ ドメインと、T のプログラム テキストおよび T から派生した任意の型との積集合になります。If the declared accessibility of M is protected, the accessibility domain of M is the intersection of the accessibility domain of T with the program text of T and any type derived from T.

  • 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.

型名Type Names

共通型システムでは、名前に関して適用される制限は次の 2 つだけです。The common type system imposes only two restrictions on names:

  • すべての名前は Unicode (16 ビット) 文字列としてエンコードされます。All names are encoded as strings of Unicode (16-bit) characters.

  • 名前には、値 0x0000 (16 ビット) を埋め込むことはできません。Names are not permitted to have an embedded (16-bit) value of 0x0000.

ただし、ほとんどの言語に型名に関する追加の制約が存在します。However, most languages impose additional restrictions on type names. すべての比較はバイト単位で行われるため、大文字と小文字を区別し、ロケールに依存しません。All comparisons are done on a byte-by-byte basis, and are therefore case-sensitive and locale-independent.

型は、他のモジュールおよびアセンブリの型を参照する場合もありますが、1 つの .NET モジュール内で完全に定義されますAlthough a type might reference types from other modules and assemblies, a type must be fully defined within one .NET module. (ただし、コンパイラがサポートしていれば、複数のソース コード ファイルに分割できる場合もあります)。型名は 1 つの名前空間内で一意である必要があります。(Depending on compiler support, however, it can be divided into multiple source code files.) Type names need be unique only within a namespace. 型が完全に識別されるようにするため、その型名は、その型の実装を含んでいる名前空間によって修飾される必要があります。To fully identify a type, the type name must be qualified by the namespace that contains the implementation of the type.

基本型とインターフェイスBase Types and Interfaces

型は、別の型から値と動作を継承できます。A type can inherit values and behaviors from another type. 共通型システムでは、複数の基本型から継承する型を作成することはできません。The common type system does not allow types to inherit from more than one base type.

型は任意の数のインターフェイスを実装できます。A type can implement any number of interfaces. 型にインターフェイスを実装するには、そのインターフェイスのすべての仮想メンバーをその型に実装する必要があります。To implement an interface, a type must implement all the virtual members of that interface. 仮想メソッドは派生型によって実装でき、静的または動的に呼び出すことができます。A virtual method can be implemented by a derived type and can be invoked either statically or dynamically.

型のメンバーType Members

ランタイムでは、型の動作と状態を指定する型のメンバーを定義できます。The runtime enables you to define members of your type, which specifies the behavior and state of a type. 型のメンバーには、次のようなものがあります。Type members include the following:

フィールドFields

フィールドは、型の状態の一部を表し、格納するものです。A field describes and contains part of the type's state. フィールドは、ランタイムがサポートする任意の型にすることができます。Fields can be of any type supported by the runtime. 通常、フィールドは、同じクラスまたはその派生クラスからしかアクセスできないように、private または protected のいずれかに設定されます。Most commonly, fields are either private or protected, so that they are accessible only from within the class or from a derived class. フィールドの値を型の外部から変更できるようにする場合は、プロパティの set アクセサーを使用するのが一般的です。If the value of a field can be modified from outside its type, a property set accessor is typically used. パブリックに公開されたフィールドは、通常、読み取り専用であり、次の 2 種類に分けることができます。Publicly exposed fields are usually read-only and can be of two types:

  • 定数。その値は、デザイン時に割り当てられます。Constants, whose value is assigned at design time. これらはクラスの静的メンバーですが、static (Visual Basic では Shared) キーワードを使用して定義されません。These are static members of a class, although they are not defined using the static (Shared in Visual Basic) keyword.

  • 読み取り専用の変数。その値は、クラスのコンストラクターで割り当てることができます。Read-only variables, whose values can be assigned in the class constructor.

次の例は、読み取り専用フィールドの 2 つの用法を示しています。The following example illustrates these two usages of read-only fields.

using System;

public class Constants
{
   public const double Pi = 3.1416;
   public readonly DateTime BirthDate;
   
   public Constants(DateTime birthDate)
   {
      this.BirthDate = birthDate;
   }
}

public class Example
{
   public static void Main()
   {
      Constants con = new Constants(new DateTime(1974, 8, 18));
      Console.Write(Constants.Pi + "\n");
      Console.Write(con.BirthDate.ToString("d") + "\n");
   }
}
// The example displays the following output if run on a system whose current
// culture is en-US:
//    3.1416
//    8/18/1974
Public Class Constants
   Public Const Pi As Double = 3.1416
   Public ReadOnly BirthDate As Date
   
   Public Sub New(birthDate As Date)
      Me.BirthDate = birthDate
   End Sub
End Class

Public Module Example
   Public Sub Main()
      Dim con As New Constants(#8/18/1974#)
      Console.WriteLine(Constants.Pi.ToString())
      Console.WriteLine(con.BirthDate.ToString("d"))
   End Sub
End Module
' The example displays the following output if run on a system whose current
' culture is en-US:
'    3.1416
'    8/18/1974

プロパティProperties

プロパティは、型の値または状態に名前を付け、そのプロパティの値を取得または設定するためのメソッドを定義します。A property names a value or state of the type and defines methods for getting or setting the property's value. プロパティは、プリミティブ型、プリミティブ型のコレクション、ユーザー定義型、ユーザー定義型のコレクションにすることができます。Properties can be primitive types, collections of primitive types, user-defined types, or collections of user-defined types. 多くの場合、プロパティは、型のパブリックなインターフェイスを、その型の個々の実装とは切り離すために使用されます。Properties are often used to keep the public interface of a type independent from the type's actual representation. これにより、クラスに直接格納されていない値をプロパティに反映させたり (プロパティが計算後の値を返す場合など)、プライベート フィールドに割り当てる値を事前に検証したりすることが可能です。This enables properties to reflect values that are not directly stored in the class (for example, when a property returns a computed value) or to perform validation before values are assigned to private fields. 後者のパターンを説明する例を次に示します。The following example illustrates the latter pattern.

using System;

public class Person
{
   private int m_Age;
   
   public int Age
   { 
      get { return m_Age; }
      set {
         if (value < 0 || value > 125)
         {
            throw new ArgumentOutOfRangeException("The value of the Age property must be between 0 and 125.");
         }
         else
         {
            m_Age = value;
         }         
      }
   }
}
Public Class Person
   Private m_Age As Integer
   
   Public Property Age As Integer
      Get
         Return m_Age
      End Get
      Set
         If value < 0 Or value > 125 Then
            Throw New ArgumentOutOfRangeException("The value of the Age property must be between 0 and 125.")
         Else
            m_Age = value
         End If
      End Set
   End Property
End Class

読み取り可能なプロパティを含んだ型の Microsoft Intermediate Language (MSIL) には、プロパティそのもののほかに、get_propertyname メソッドが含まれています。また、書き込み可能なプロパティを含んだ型の MSIL には、set_propertyname メソッドが含まれています。In addition to including the property itself, the Microsoft intermediate language (MSIL) for a type that contains a readable property includes a get_propertyname method, and the MSIL for a type that contains a writable property includes a set_propertyname method.

メソッドMethods

メソッドは、その型で利用できる操作を表します。A method describes operations that are available on the type. メソッドのシグネチャは、そのメソッドのパラメーターの型および戻り値の型として許可される型を示します。A method's signature specifies the allowable types of all its parameters and of its return value.

ほとんどのメソッドでは、メソッド呼び出しに必要なパラメーターの厳密な個数が定義されていますが、いくつかのメソッドは可変個のパラメーターをサポートしています。Although most methods define the precise number of parameters required for method calls, some methods support a variable number of parameters. このようなメソッドで最後に宣言されるパラメーターには、ParamArrayAttribute 属性が適用されます。The final declared parameter of these methods is marked with the ParamArrayAttribute attribute. 通常、言語コンパイラには、C# の params や Visual Basic の ParamArray など、ParamArrayAttribute の明示的な使用を不要にするキーワードがあります。Language compilers typically provide a keyword, such as params in C# and ParamArray in Visual Basic, that makes explicit use of ParamArrayAttribute unnecessary.

コンストラクターConstructors

コンストラクターは、クラスまたは構造体の新しいインスタンスを作成する特殊なメソッドです。A constructor is a special kind of method that creates new instances of a class or structure. 他のメソッドと同様に、コンストラクターには、パラメーターを指定することができます。ただし、コンストラクターには戻り値はありません (つまり、void が返されます)。Like any other method, a constructor can include parameters; however, constructors have no return value (that is, they return void).

クラスのソース コードに明示的にコンストラクターが定義されていない場合は、コンパイラによってパラメーターなしのコンストラクターが追加されます。If the source code for a class does not explicitly define a constructor, the compiler includes a parameterless constructor. ただし、パラメーター化されたコンストラクターのみがクラスのソース コードで定義されている場合は、Visual Basic および C# のコンパイラが、パラメーターなしのコンストラクターを生成しません。However, if the source code for a class defines only parameterized constructors, the Visual Basic and C# compilers do not generate a parameterless constructor.

構造体のソース コードでコンストラクターが定義される場合は、それらのコンストラクターがパラメーター化されている必要があります。構造体ではパラメーターなしのコンストラクターを定義できず、コンパイラは、構造体および他の値型のいずれに対しても、パラメーターなしのコンストラクターを生成しません。If the source code for a structure defines constructors, they must be parameterized; a structure cannot define a parameterless constructor, and compilers do not generate parameterless constructors for structures or other value types. すべての値の型には暗黙的なパラメーターなしのコンストラクターがあります。All value types do have an implicit parameterless constructor. このコンストラクターは、共通言語ランタイムによって実装され、構造体のすべてのフィールドを既定の値に初期化します。This constructor is implemented by the common language runtime and initializes all fields of the structure to their default values.

イベントEvents

イベントは、応答可能な事象 (イベント) を定義し、イベントへのサブスクライブ、イベントからのサブスクライブ解除、およびイベントの発生用のメソッドを定義します。An event defines an incident that can be responded to, and defines methods for subscribing to, unsubscribing from, and raising the event. 多くの場合、イベントは、他の型に対して状態の変更を通知するために使用されます。Events are often used to inform other types of state changes. 詳細については、「イベント」を参照してください。For more information, see Events.

入れ子にされた型Nested Types

入れ子にされた型とは、他の型のメンバーである型です。A nested type is a type that is a member of some other type. 入れ子にされた型はその親の型と密に結合されているため、汎用型としては使用できません。Nested types should be tightly coupled to their containing type and must not be useful as a general-purpose type. 入れ子にされた型は、宣言型で、入れ子にされた型のインスタンスを使用したり作成したりする場合に便利で、入れ子にされた型の使用はパブリック メンバーに公開されません。Nested types are useful when the declaring type uses and creates instances of the nested type, and use of the nested type is not exposed in public members.

入れ子にされた型は、混乱を招くおそれがあるため、特別な理由がない限り、パブリックに参照可能にすることはお勧めできません。Nested types are confusing to some developers and should not be publicly visible unless there is a compelling reason for visibility. 適切にデザインされたライブラリでは、入れ子にされた型を使ってオブジェクトをインスタンス化したり、変数を宣言したりすることが必要になることはほとんどありません。In a well-designed library, developers should rarely have to use nested types to instantiate objects or declare variables.

型のメンバーの特性Characteristics of Type Members

共通型システムでは、型のメンバーにさまざまな特性を適用できますが、各言語で、これらの特性がすべてサポートされている必要はありません。The common type system allows type members to have a variety of characteristics; however, languages are not required to support all these characteristics. メンバーの特性について次の表で説明します。The following table describes member characteristics.

特徴Characteristic 適用対象Can apply to 説明Description
abstractabstract メソッド、プロパティ、およびイベントMethods, properties, and events 型はメソッドの実装を提供しません。The type does not supply the method's implementation. 抽象メソッドを継承または実装する型は、そのメソッドの実装を提供する必要があります。Types that inherit or implement abstract methods must supply an implementation for the method. 唯一の例外は、派生型自体が抽象型である場合です。The only exception is when the derived type is itself an abstract type. すべての抽象メソッドは仮想メソッドです。All abstract methods are virtual.
private、family、assembly、family and assembly、family or assembly、または publicprivate, family, assembly, family and assembly, family or assembly, or public すべてAll メンバーのアクセシビリティを次のように定義します。Defines the accessibility of the member:

privateprivate
メンバーが含まれているのと同じ型の内部、またはその型に入れ子にされた型の内部からだけアクセスできます。Accessible only from within the same type as the member, or within a nested type.

familyfamily
メンバーが含まれているのと同じ型の内部、およびその型を継承した派生型からアクセスできます。Accessible from within the same type as the member, and from derived types that inherit from it.

アセンブリassembly
型が定義されているアセンブリ内でだけアクセスできます。Accessible only in the assembly in which the type is defined.

family and assemblyfamily and assembly
family アクセスと assembly アクセスの両特性を満たす型からだけアクセスできます。Accessible only from types that qualify for both family and assembly access.

family or assemblyfamily or assembly
family アクセスまたは assembly アクセスのいずれかの特性を満たす型からだけアクセスできます。Accessible only from types that qualify for either family or assembly access.

publicpublic
すべての型からアクセスできます。Accessible from any type.
finalfinal メソッド、プロパティ、およびイベントMethods, properties, and events その仮想メソッドを派生型ではオーバーライドできません。The virtual method cannot be overridden in a derived type.
initialize-onlyinitialize-only フィールドFields 値を初期化することだけでき、初期化後の書き込みは実行できません。The value can only be initialized, and cannot be written after initialization.
インスタンスinstance フィールド、メソッド、プロパティ、およびイベントFields, methods, properties, and events メンバーが static (C# および C++)、Shared (Visual Basic)、virtual (C# および C++)、または Overridable (Visual Basic) でマークされていない場合、それはインスタンス メンバーです (instance キーワードはありません)。If a member is not marked as static (C# and C++), Shared (Visual Basic), virtual (C# and C++), or Overridable (Visual Basic), it is an instance member (there is no instance keyword). このようなメンバーについては、型を使用するオブジェクトと同数のコピーがメモリ内に格納されます。There will be as many copies of such members in memory as there are objects that use it.
リテラルliteral フィールドFields このフィールドには、組み込みの値型の、コンパイル時点の固定値が割り当てられます。The value assigned to the field is a fixed value, known at compile time, of a built-in value type. リテラル フィールドを定数と呼ぶこともあります。Literal fields are sometimes referred to as constants.
newslot または overridenewslot or override すべてAll メンバーが、同じシグネチャを持つ継承メンバーとどのようにやり取りするかを定義します。Defines how the member interacts with inherited members that have the same signature:

newslotnewslot
同じシグネチャを持つ継承されたメンバーを隠ぺいします。Hides inherited members that have the same signature.

overrideoverride
継承された仮想メソッドの定義を置き換えます。Replaces the definition of an inherited virtual method.

既定値は newslot です。The default is newslot.
静的static フィールド、メソッド、プロパティ、およびイベントFields, methods, properties, and events メンバーは、型の特定のインスタンスではなく、そのメンバーが定義されている型に属します。つまり、メンバーは型がインスタンス化されていなくても存在し、その型のすべてのインスタンスによって共有されます。The member belongs to the type it is defined on, not to a particular instance of the type; the member exists even if an instance of the type is not created, and it is shared among all instances of the type.
virtualvirtual メソッド、プロパティ、およびイベントMethods, properties, and events メソッドは、派生型で実装でき、静的または動的に呼び出すことができます。The method can be implemented by a derived type and can be invoked either statically or dynamically. 動的呼び出しが使用される場合は、実行時に呼び出しを行うインスタンスの型によって (コンパイル時に判明する型ではなく)、メソッドのどの実装が呼び出されるかが決定されます。If dynamic invocation is used, the type of the instance that makes the call at run time (rather than the type known at compile time) determines which implementation of the method is called. 仮想メソッドを静的に呼び出すには、目的のバージョンのメソッドを使用する型に、変数をキャストする必要が生じる場合があります。To invoke a virtual method statically, the variable might have to be cast to a type that uses the desired version of the method.

オーバーロードOverloading

型のメンバーには、それぞれ固有のシグネチャがあります。Each type member has a unique signature. メソッドのシグネチャは、メソッドの名前とパラメーター リスト (メソッドの引数の順序と型) で構成されます。Method signatures consist of the method name and a parameter list (the order and types of the method's arguments). シグネチャが同じでなければ、同じ名前を持つ複数のメソッドを 1 つの型の中で定義できます。Multiple methods with the same name can be defined within a type as long as their signatures differ. 同じ名前を持つ 2 つ以上のメソッドが定義されている場合、そのメソッドはオーバーロードされている、と言います。When two or more methods with the same name are defined, the method is said to be overloaded. たとえば、System.Char では、IsDigit メソッドがオーバーロードされています。For example, in System.Char, the IsDigit method is overloaded. 一方のメソッドは Char を受け取ります。One method takes a Char. もう一方のメソッドは、String および Int32 を受け取ります。The other method takes a String and an Int32.

注意

戻り値の型は、メソッドのシグネチャの一部として見なされません。The return type is not considered part of a method's signature. つまり、戻り値の型が異なっているだけでは、メソッドをオーバーロードすることはできません。That is, methods cannot be overloaded if they differ only by return type.

メンバーの継承、オーバーライド、および隠ぺいInheriting, Overriding, and Hiding Members

派生型は、その基本型のすべてのメンバーを継承します。つまり、基本型のすべてのメンバーは、派生型に対しても定義されており、使用可能です。A derived type inherits all members of its base type; that is, these members are defined on, and available to, the derived type. 継承されたメンバーの動作または特性は、次の 2 つの方法で変更できます。The behavior or qualities of inherited members can be modified in two ways:

  • 派生型で、同じシグネチャを持つ新しいメンバーを定義することによって、継承されたメンバーを隠ぺいできます。A derived type can hide an inherited member by defining a new member with the same signature. この方法は、public のメンバーを private に変更したり、final としてマークされている継承メソッドに新しい動作を定義したりするために使用します。This might be done to make a previously public member private or to define new behavior for an inherited method that is marked as final.

  • 派生型で、継承された仮想メソッドをオーバーライドできます。A derived type can override an inherited virtual method. オーバーライドするメソッドでは、コンパイル時点の変数の型ではなく、実行時の値の型に基づいて呼び出される、メソッドの新しい定義を提供します。The overriding method provides a new definition of the method that will be invoked based on the type of the value at run time rather than the type of the variable known at compile time. メソッドが仮想メソッドをオーバーライドできるのは、その仮想メソッドが final としてマークされておらず、新しいメソッドのアクセシビリティがその仮想メソッドと少なくとも同じ場合に限られます。A method can override a virtual method only if the virtual method is not marked as final and the new method is at least as accessible as the virtual method.

関連項目See also