組み込みの参照型 (C# リファレンス)Built-in reference types (C# reference)

C# には複数の組み込み参照型があります。C# has a number of built-in reference types. それらには、.NET ライブラリでの型に対するシノニムであるキーワードまたは演算子があります。They have keywords or operators that are synonyms for a type in the .NET library.

オブジェクト型The object type

object 型は .NET での System.Object の別名です。The object type is an alias for System.Object in .NET. C# の統一型システムでは、すべての型 (定義済み、ユーザー定義、参照型、および値型) が、直接または間接的に System.Object を継承します。In the unified type system of C#, all types, predefined and user-defined, reference types and value types, inherit directly or indirectly from System.Object. object 型の変数には、任意の型の値を割り当てることができます。You can assign values of any type to variables of type object. すべての object 変数には、リテラル null を使って既定値を割り当てることができます。Any object variable can be assigned to its default value using the literal null. 値型の変数が object に変換されることを、ボックス化されると言います。When a variable of a value type is converted to object, it is said to be boxed. object 型の変数が値型に変換されることを、ボックス化解除されると言います。When a variable of type object is converted to a value type, it is said to be unboxed. 詳細については、「ボックス化とボックス化解除」を参照してください。For more information, see Boxing and Unboxing.

文字列型The string type

string 型は、0 個以上の Unicode 文字のシーケンスを表します。The string type represents a sequence of zero or more Unicode characters. string は .NET の System.String の別名です。string is an alias for System.String in .NET.

string は参照型ですが、等値演算子 == および != は、string オブジェクトの参照ではなく、値を比較するように定義されています。Although string is a reference type, the equality operators == and != are defined to compare the values of string objects, not references. これにより、文字列が等しいかを直感的にテストできます。This makes testing for string equality more intuitive. 次に例を示します。For example:

string a = "hello";
string b = "h";
// Append to contents of 'b'
b += "ello";
Console.WriteLine(a == b);
Console.WriteLine(object.ReferenceEquals(a, b));

文字列の内容が等しいので、"True"、"False" の順に表示されますが、a および b は同じ文字列インスタンスを参照しません。This displays "True" and then "False" because the content of the strings are equivalent, but a and b do not refer to the same string instance.

+ 演算子では、文字列が連結されます。The + operator concatenates strings:

string a = "good " + "morning";

これは、"good morning" を含む文字列オブジェクトを作成します。This creates a string object that contains "good morning".

文字列は "変更不可" です。文字列オブジェクトの作成後、そのコンテンツを変更することはできません。構文では変更可能に見えても、変更不可です。Strings are immutable--the contents of a string object cannot be changed after the object is created, although the syntax makes it appear as if you can do this. たとえば、このコードを作成すると、コンパイラによって新しい文字列オブジェクトを格納する新しいシーケンス オブジェクトが生成され、その新しいオブジェクトが b に割り当てられます。For example, when you write this code, the compiler actually creates a new string object to hold the new sequence of characters, and that new object is assigned to b. b に割り当てられたメモリは (文字列 "h" が含まれている場合)、ガベージ コレクションの対象になります。The memory that had been allocated for b (when it contained the string "h") is then eligible for garbage collection.

string b = "h";
b += "ello";

[] 演算子は、文字列の各文字への読み取り専用アクセスに使用できます。The [] operator can be used for readonly access to individual characters of a string. 有効なインデックス値は 0 から始まり、文字列の長さ未満である必要があります。Valid index values start at 0 and must be less than the length of the string:

string str = "test";
char x = str[2];  // x = 's';

同様に、[] 演算子を使って文字列内の各文字を反復処理することもできます。In similar fashion, the [] operator can also be used for iterating over each character in a string:

string str = "test";

for (int i = 0; i < str.Length; i++)
{
  Console.Write(str[i] + " ");
}
// Output: t e s t

文字列リテラルは string 型であり、二重引用符で囲む形式と、@ 付きの二重引用符で囲む形式の 2 種類があります。String literals are of type string and can be written in two forms, quoted and @-quoted. 二重引用符で囲む場合は、リテラル文字列の前後に二重引用符 (") を付けます。Quoted string literals are enclosed in double quotation marks ("):

"good morning"  // a string literal

リテラル文字列には、任意の文字リテラルを含めることができます。String literals can contain any character literal. これにはエスケープ シーケンスが含まれます。Escape sequences are included. 次の例では、円記号にエスケープ シーケンス \\、文字 f に \u0066、改行に \n を使用しています。The following example uses escape sequence \\ for backslash, \u0066 for the letter f, and \n for newline.

string a = "\\\u0066\n F";
Console.WriteLine(a);
\\ Output:
\\ \f
\\  F

注意

エスケープ コード \udddd (dddd は 4 桁の数字) は、Unicode 文字 U +dddd を表します。The escape code \udddd (where dddd is a four-digit number) represents the Unicode character U+dddd. 8 桁の Unicode エスケープ コード \Udddddddd も認識できます。Eight-digit Unicode escape codes are also recognized: \Udddddddd.

verbatim 文字列リテラルの場合は、先頭に @ を付け、さらに前後に二重引用符を付けます。Verbatim string literals start with @ and are also enclosed in double quotation marks. 次に例を示します。For example:

@"good morning"  // a string literal

verbatim 文字列の場合の利点は、エスケープ シーケンスが "処理されない" ため、たとえば、完全修飾 Windows ファイル名が書きやすくなることです。The advantage of verbatim strings is that escape sequences are not processed, which makes it easy to write, for example, a fully qualified Windows file name:

@"c:\Docs\Source\a.txt"  // rather than "c:\\Docs\\Source\\a.txt"

@-quoted に続いて引用符で囲まれた文字列に二重引用符を含めるには、二重引用符を二重にします。To include a double quotation mark in an @-quoted string, double it:

@"""Ahoy!"" cried the captain." // "Ahoy!" cried the captain.

デリゲート型The delegate type

デリゲート型の宣言は、メソッド シグネチャに似ています。The declaration of a delegate type is similar to a method signature. 戻り値 1 つのほか、任意の型のパラメーターをいくつでも指定することができます。It has a return value and any number of parameters of any type:

public delegate void MessageDelegate(string message);
public delegate int AnotherDelegate(MyType m, long num);

.NET では、System.Action 型と System.Func 型により、多くの一般的なデリゲートに対するジェネリック定義が提供されます。In .NET, System.Action and System.Func types provide generic definitions for many common delegates. おそらく、新しいカスタム デリゲート型を定義する必要はありません。You likely don't need to define new custom delegate types. 代わりに、提供されたジェネリック型のインスタンス化を作成できます。Instead, you can create instantiations of the provided generic types.

delegate は、名前付きメソッドまたは匿名メソッドをカプセル化することができる参照型です。A delegate is a reference type that can be used to encapsulate a named or an anonymous method. デリゲートは C++ の関数ポインターに似ていますが、タイプ セーフであり安全です。Delegates are similar to function pointers in C++; however, delegates are type-safe and secure. デリゲートの使い方については、デリゲート汎用デリゲートに関するページを参照してください。For applications of delegates, see Delegates and Generic Delegates. デリゲートはイベントの土台となる働きをします。Delegates are the basis for Events. デリゲートは名前付きメソッドまたは匿名メソッドに関連付けることによって、インスタンス化することができます。A delegate can be instantiated by associating it either with a named or anonymous method.

デリゲートは、適合する入力パラメーターと戻り値の型を持ったメソッドまたはラムダ式でインスタンス化する必要があります。The delegate must be instantiated with a method or lambda expression that has a compatible return type and input parameters. メソッドのシグネチャでどの程度の変性が許容されるかについて詳しくは、デリゲートの変性に関するページを参照してください。For more information on the degree of variance that is allowed in the method signature, see Variance in Delegates. 匿名メソッドで使用する場合は、デリゲートとそれに関連付けるコードとを一緒に宣言します。For use with anonymous methods, the delegate and the code to be associated with it are declared together.

dynamic 型The dynamic type

dynamic 型は、変数およびそのメンバーに対する参照の使用が、コンパイル時の型チェックをバイパスすることを示します。The dynamic type indicates that use of the variable and references to its members bypass compile-time type checking. 代わりに、演算は実行時に解決されます。Instead, these operations are resolved at run time. dynamic 型により、Office オートメーション API などの COM API、IronPython ライブラリなどの動的 API、および HTML ドキュメント オブジェクト モデル (DOM: Document Object Model) へのアクセスが容易になります。The dynamic type simplifies access to COM APIs such as the Office Automation APIs, to dynamic APIs such as IronPython libraries, and to the HTML Document Object Model (DOM).

ほとんどの環境で、dynamic 型は object 型のように動作します。Type dynamic behaves like type object in most circumstances. 具体的には、null 以外の任意の式を dynamic 型に変換できます。In particular, any non-null expression can be converted to the dynamic type. dynamic 型は object と異なり、dynamic 型の式を含む演算はコンパイラによって解決または型チェックされません。The dynamic type differs from object in that operations that contain expressions of type dynamic are not resolved or type checked by the compiler. コンパイラは演算に関する情報をまとめてパッケージ化します。その情報が後で実行時に演算を評価するために使用されます。The compiler packages together information about the operation, and that information is later used to evaluate the operation at run time. このプロセスの過程で、dynamic 型の変数は object 型の変数にコンパイルされます。As part of the process, variables of type dynamic are compiled into variables of type object. そのため、dynamic 型はコンパイル時にのみ存在し、実行時には存在しません。Therefore, type dynamic exists only at compile time, not at run time.

dynamic 型の変数と object 型の変数の違いを次に示します。The following example contrasts a variable of type dynamic to a variable of type object. コンパイル時に各変数の型を確認するには、WriteLine ステートメントの dyn または obj にマウス ポインターを置きます。To verify the type of each variable at compile time, place the mouse pointer over dyn or obj in the WriteLine statements. IntelliSense が使用可能なエディターに、次のコードをコピーします。Copy the following code into an editor where IntelliSense is available. IntelliSense 機能によって、dyn には dynamicobj には object が表示されます。IntelliSense shows dynamic for dyn and object for obj.

class Program
{
    static void Main(string[] args)
    {
        dynamic dyn = 1;
        object obj = 1;

        // Rest the mouse pointer over dyn and obj to see their
        // types at compile time.
        System.Console.WriteLine(dyn.GetType());
        System.Console.WriteLine(obj.GetType());
    }
}

WriteLine ステートメントは dyn および obj の実行時の型を表示します。The WriteLine statements display the run-time types of dyn and obj. その時点では、両方が同じ整数型を持ちます。At that point, both have the same type, integer. 次の出力が生成されます。The following output is produced:

System.Int32
System.Int32

コンパイル時の dynobj の違いを確認するには、前の例の宣言と WriteLine ステートメントの間に次の 2 行を追加します。To see the difference between dyn and obj at compile time, add the following two lines between the declarations and the WriteLine statements in the previous example.

dyn = dyn + 3;
obj = obj + 3;

obj + 3 に整数およびオブジェクトを追加しようとしたことに対してコンパイル エラーが報告されます。A compiler error is reported for the attempted addition of an integer and an object in expression obj + 3. ただし、dyn + 3 に関するエラーは報告されません。However, no error is reported for dyn + 3. dyn を含む式はコンパイル時にはチェックされません。これは、dyn の型が dynamic であるためです。The expression that contains dyn is not checked at compile time because the type of dyn is dynamic.

さまざまな宣言で dynamic を使用する例を次に示します。The following example uses dynamic in several declarations. また、Main メソッドで、コンパイル時の型チェックと実行時の型チェックの違いを確認できます。The Main method also contrasts compile-time type checking with run-time type checking.

using System;

namespace DynamicExamples
{
    class Program
    {
        static void Main(string[] args)
        {
            ExampleClass ec = new ExampleClass();
            Console.WriteLine(ec.exampleMethod(10));
            Console.WriteLine(ec.exampleMethod("value"));

            // The following line causes a compiler error because exampleMethod
            // takes only one argument.
            //Console.WriteLine(ec.exampleMethod(10, 4));

            dynamic dynamic_ec = new ExampleClass();
            Console.WriteLine(dynamic_ec.exampleMethod(10));

            // Because dynamic_ec is dynamic, the following call to exampleMethod
            // with two arguments does not produce an error at compile time.
            // However, it does cause a run-time error. 
            //Console.WriteLine(dynamic_ec.exampleMethod(10, 4));
        }
    }

    class ExampleClass
    {
        static dynamic field;
        dynamic prop { get; set; }

        public dynamic exampleMethod(dynamic d)
        {
            dynamic local = "Local variable";
            int two = 2;

            if (d is int)
            {
                return local;
            }
            else
            {
                return two;
            }
        }
    }
}
// Results:
// Local variable
// 2
// Local variable

関連項目See also