次の方法で共有

.NET での型変換

すべての値には、値に割り当てられる領域の量、使用可能な値の範囲、使用可能なメンバーなどの属性を定義する、関連付けられた型があります。 多くの値は、複数の型として表すことができます。 たとえば、値 4 は整数または浮動小数点値として表すことができます。 型変換では、古い型の値と同等の値が新しい型に作成されますが、元のオブジェクトの ID (または正確な値) は必ずしも保持されません。

.NET では、次の変換が自動的にサポートされます。

  • 派生クラスから基底クラスへの変換。 つまり、たとえば、任意のクラスまたは構造体のインスタンスを Object インスタンスに変換できます。 この変換には、キャスト演算子または変換演算子は必要ありません。

  • 基底クラスから元の派生クラスへの変換。 C# では、この変換にはキャスト演算子が必要です。 Visual Basic では、Option Strictがオンの場合は、CType演算子が必要です。

  • インターフェイスを実装する型から、そのインターフェイスを表すインターフェイス オブジェクトへの変換。 この変換には、キャスト演算子または変換演算子は必要ありません。

  • インターフェイス オブジェクトから、そのインターフェイスを実装する元の型への変換。 C# では、この変換にはキャスト演算子が必要です。 Visual Basic では、Option Strictがオンの場合は、CType演算子が必要です。

これらの自動変換に加えて、.NET には、カスタム型変換をサポートするいくつかの機能が用意されています。 これには以下が含まれます。

暗黙的な演算子を使用した暗黙的な変換

拡大変換では、ターゲット型よりも制限の厳しい範囲または制限されたメンバー リストを持つ既存の型の値から新しい値を作成する必要があります。 拡大変換ではデータが失われることはできません (ただし、精度が失われる可能性があります)。 データを失うことはできないため、コンパイラは、明示的な変換メソッドまたはキャスト演算子を使用しなくても、暗黙的または透過的に変換を処理できます。

注

暗黙的な変換を実行するコードは、変換メソッドを呼び出すか、キャスト演算子を使用できますが、暗黙的な変換をサポートするコンパイラでは、その使用は必要ありません。

たとえば、 Decimal 型は、 Byte、 Char、 Int16、 Int32、 Int64、 SByte、 UInt16、 UInt32、および UInt64 値からの暗黙的な変換をサポートします。 次の例は、 Decimal 変数に値を割り当てる場合のこれらの暗黙的な変換の一部を示しています。

  byte byteValue = 16;
  short shortValue = -1024;
  int intValue = -1034000;
  long longValue = 1152921504606846976;
  ulong ulongValue = UInt64.MaxValue;

  decimal decimalValue;

  decimalValue = byteValue;
  Console.WriteLine("After assigning a {0} value, the Decimal value is {1}.",
                    byteValue.GetType().Name, decimalValue);

  decimalValue = shortValue;
  Console.WriteLine("After assigning a {0} value, the Decimal value is {1}.",
                    shortValue.GetType().Name, decimalValue);

  decimalValue = intValue;
  Console.WriteLine("After assigning a {0} value, the Decimal value is {1}.",
                    intValue.GetType().Name, decimalValue);

  decimalValue = longValue;
  Console.WriteLine("After assigning a {0} value, the Decimal value is {1}.",
                    longValue.GetType().Name, decimalValue);

decimalValue = ulongValue;
Console.WriteLine("After assigning a {0} value, the Decimal value is {1}.",
                  ulongValue.GetType().Name, decimalValue);
// The example displays the following output:
//    After assigning a Byte value, the Decimal value is 16.
//    After assigning a Int16 value, the Decimal value is -1024.
//    After assigning a Int32 value, the Decimal value is -1034000.
//    After assigning a Int64 value, the Decimal value is 1152921504606846976.
//    After assigning a UInt64 value, the Decimal value is 18446744073709551615.

Dim byteValue As Byte = 16
Dim shortValue As Short = -1024
Dim intValue As Integer = -1034000
Dim longValue As Long = CLng(1024 ^ 6)
Dim ulongValue As ULong = ULong.MaxValue

Dim decimalValue As Decimal

decimalValue = byteValue
Console.WriteLine("After assigning a {0} value, the Decimal value is {1}.",
                  byteValue.GetType().Name, decimalValue)

decimalValue = shortValue
Console.WriteLine("After assigning a {0} value, the Decimal value is {1}.",
                  shortValue.GetType().Name, decimalValue)

decimalValue = intValue
Console.WriteLine("After assigning a {0} value, the Decimal value is {1}.",
                  intValue.GetType().Name, decimalValue)

decimalValue = longValue
Console.WriteLine("After assigning a {0} value, the Decimal value is {1}.",
                  longValue.GetType().Name, decimalValue)

decimalValue = ulongValue
Console.WriteLine("After assigning a {0} value, the Decimal value is {1}.",
                  ulongValue.GetType().Name, decimalValue)
' The example displays the following output:
'    After assigning a Byte value, the Decimal value is 16.
'    After assigning a Int16 value, the Decimal value is -1024.
'    After assigning a Int32 value, the Decimal value is -1034000.
'    After assigning a Int64 value, the Decimal value is 1152921504606846976.
'    After assigning a UInt64 value, the Decimal value is 18446744073709551615.

特定の言語コンパイラでカスタム演算子がサポートされている場合は、独自のカスタム型で暗黙的な変換を定義することもできます。 次の例では、符号と大きさの表現を使用する ByteWithSign という名前の符号付きバイト データ型の部分的な実装を示します。 Byte値とSByte値からByteWithSign値への暗黙的な変換がサポートされています。

public struct ByteWithSign
{
    private SByte signValue;
    private Byte value;

    public static implicit operator ByteWithSign(SByte value)
    {
        ByteWithSign newValue;
        newValue.signValue = (SByte)Math.Sign(value);
        newValue.value = (byte)Math.Abs(value);
        return newValue;
    }

    public static implicit operator ByteWithSign(Byte value)
    {
        ByteWithSign newValue;
        newValue.signValue = 1;
        newValue.value = value;
        return newValue;
    }

    public override string ToString()
    {
        return (signValue * value).ToString();
    }
}

Public Structure ImplicitByteWithSign
    Private signValue As SByte
    Private value As Byte

    Public Overloads Shared Widening Operator CType(value As SByte) As ImplicitByteWithSign
        Dim newValue As ImplicitByteWithSign
        newValue.signValue = CSByte(Math.Sign(value))
        newValue.value = CByte(Math.Abs(value))
        Return newValue
    End Operator

    Public Overloads Shared Widening Operator CType(value As Byte) As ImplicitByteWithSign
        Dim NewValue As ImplicitByteWithSign
        newValue.signValue = 1
        newValue.value = value
        Return newValue
    End Operator

    Public Overrides Function ToString() As String
        Return (signValue * value).ToString()
    End Function
End Structure

次の例に示すように、クライアント コードでは、明示的な変換を実行したりキャスト演算子を使用したりすることなく、 ByteWithSign 変数を宣言し、 Byte 値と SByte 値を割り当てることができます。

SByte sbyteValue = -120;
ByteWithSign value = sbyteValue;
Console.WriteLine(value);
value = Byte.MaxValue;
Console.WriteLine(value);
// The example displays the following output:
//       -120
//       255

Dim sbyteValue As SByte = -120
Dim value As ImplicitByteWithSign = sbyteValue
Console.WriteLine(value.ToString())
value = Byte.MaxValue
Console.WriteLine(value.ToString())
' The example displays the following output:
'       -120
'       255

明示的な演算子を使用した明示的な変換

縮小変換では、既存の型の値から新しい値を作成する必要があります。この値は、ターゲット型よりも範囲が大きいか、メンバー リストが大きくなります。 縮小変換ではデータが失われる可能性があるため、多くの場合、コンパイラでは、変換メソッドまたはキャスト演算子の呼び出しによって変換を明示的に行う必要があります。 つまり、変換は開発者コードで明示的に処理する必要があります。

注

変換を縮小するために変換方法またはキャスト演算子を要求する主な目的は、コードで処理できるように、データ損失や OverflowException の可能性を開発者に認識することです。 ただし、一部のコンパイラでは、この要件を緩和できます。 たとえば、Visual Basic では、 Option Strict がオフ (既定の設定) の場合、Visual Basic コンパイラは縮小変換を暗黙的に実行しようとします。

たとえば、次の表に示すように、 UInt32、 Int64、および UInt64 のデータ型には、 Int32 データ型を超える範囲があります。

タイプ Int32 の範囲との比較
Int64 Int64.MaxValue が Int32.MaxValueより大きく、 Int64.MinValue が Int32.MinValueより小さい (負の範囲が大きい) 場合。
UInt32 UInt32.MaxValue が Int32.MaxValue より大きい。
UInt64 UInt64.MaxValue が Int32.MaxValue より大きい。

このような縮小変換を処理するために、.NET では型で Explicit 演算子を定義できます。 その後、個々の言語コンパイラは、独自の構文を使用してこの演算子を実装するか、 Convert クラスのメンバーを呼び出して変換を実行できます。 ( Convert クラスの詳細については、このトピックで後述 する「Convert クラス 」を参照してください)。次の例は、言語機能を使用して、範囲外の可能性がある整数値から Int32 値への明示的な変換を処理する方法を示しています。

long number1 = int.MaxValue + 20L;
uint number2 = int.MaxValue - 1000;
ulong number3 = int.MaxValue;

int intNumber;

try
{
    intNumber = checked((int)number1);
    Console.WriteLine("After assigning a {0} value, the Integer value is {1}.",
                      number1.GetType().Name, intNumber);
}
catch (OverflowException)
{
    if (number1 > int.MaxValue)
        Console.WriteLine($"Conversion failed: {number1} exceeds {int.MaxValue}.");
    else
        Console.WriteLine($"Conversion failed: {number1} is less than {int.MinValue}.");
}

try
{
    intNumber = checked((int)number2);
    Console.WriteLine("After assigning a {0} value, the Integer value is {1}.",
                      number2.GetType().Name, intNumber);
}
catch (OverflowException)
{
    Console.WriteLine($"Conversion failed: {number2} exceeds {int.MaxValue}.");
}

try
{
    intNumber = checked((int)number3);
    Console.WriteLine("After assigning a {0} value, the Integer value is {1}.",
                      number3.GetType().Name, intNumber);
}
catch (OverflowException)
{
    Console.WriteLine($"Conversion failed: {number1} exceeds {int.MaxValue}.");
}

// The example displays the following output:
//    Conversion failed: 2147483667 exceeds 2147483647.
//    After assigning a UInt32 value, the Integer value is 2147482647.
//    After assigning a UInt64 value, the Integer value is 2147483647.

Dim number1 As Long = Integer.MaxValue + 20L
Dim number2 As UInteger = Integer.MaxValue - 1000
Dim number3 As ULong = Integer.MaxValue

Dim intNumber As Integer

Try
    intNumber = CInt(number1)
    Console.WriteLine("After assigning a {0} value, the Integer value is {1}.",
                        number1.GetType().Name, intNumber)
Catch e As OverflowException
    If number1 > Integer.MaxValue Then
        Console.WriteLine("Conversion failed: {0} exceeds {1}.",
                                          number1, Integer.MaxValue)
    Else
        Console.WriteLine("Conversion failed: {0} is less than {1}.\n",
                                          number1, Integer.MinValue)
    End If
End Try

Try
    intNumber = CInt(number2)
    Console.WriteLine("After assigning a {0} value, the Integer value is {1}.",
                        number2.GetType().Name, intNumber)
Catch e As OverflowException
    Console.WriteLine("Conversion failed: {0} exceeds {1}.",
                                      number2, Integer.MaxValue)
End Try

Try
    intNumber = CInt(number3)
    Console.WriteLine("After assigning a {0} value, the Integer value is {1}.",
                        number3.GetType().Name, intNumber)
Catch e As OverflowException
    Console.WriteLine("Conversion failed: {0} exceeds {1}.",
                                      number1, Integer.MaxValue)
End Try
' The example displays the following output:
'    Conversion failed: 2147483667 exceeds 2147483647.
'    After assigning a UInt32 value, the Integer value is 2147482647.
'    After assigning a UInt64 value, the Integer value is 2147483647.

明示的な変換では、異なる言語で異なる結果が生成される可能性があり、これらの結果は、対応する Convert メソッドによって返される値とは異なる場合があります。 たとえば、 Double 値 12.63251 が Int32に変換された場合、Visual Basic CInt メソッドと .NET Convert.ToInt32(Double) メソッドの両方が Double を丸めて 13 の値を返しますが、C# (int) 演算子は Double を切り捨てて 12 の値を返します。 同様に、C# (int) 演算子はブールから整数への変換をサポートしていませんが、Visual Basic CInt メソッドは true の値を -1 に変換します。 一方、 Convert.ToInt32(Boolean) メソッドは、 true の値を 1 に変換します。

ほとんどのコンパイラでは、明示的な変換をオンまたはオフの方法で実行できます。 チェックされた変換が実行されると、変換する型の値がターゲット型の範囲外の場合、 OverflowException がスローされます。 同じ条件下でオフの変換が実行されると、変換で例外がスローされない可能性がありますが、正確な動作は未定義になり、正しくない値が発生する可能性があります。

注

C# では、 checked キーワードをキャスト演算子と共に使用するか、 /checked+ コンパイラ オプションを指定して、チェックされた変換を実行できます。 逆に、オフの変換は、キャスト演算子と共に unchecked キーワードを使用するか、 /checked- コンパイラ オプションを指定して実行できます。 既定では、明示的な変換はオフになっています。 Visual Basic では、チェックされた変換を実行するには、プロジェクトの [コンパイラの詳細設定] ダイアログ ボックスの [整数オーバーフロー チェックの削除] チェック ボックスをオフにするか、/removeintchecks-コンパイラ オプションを指定します。 逆に、オフにした変換は、プロジェクトの [コンパイラの詳細設定] ダイアログ ボックスの [整数オーバーフロー チェックの削除] チェック ボックスをオンにするか、/removeintchecks+コンパイラ オプションを指定することで実行できます。 既定では、明示的な変換がチェックされます。

次の C# の例では、 checked キーワードと unchecked キーワードを使用して、 Byte の範囲外の値が Byteに変換されたときの動作の違いを示します。 チェックされた変換では例外がスローされますが、チェックされていない変換ではByte変数にByte.MaxValueが割り当てられます。

int largeValue = Int32.MaxValue;
byte newValue;

try
{
    newValue = unchecked((byte)largeValue);
    Console.WriteLine($"Converted the {largeValue.GetType().Name} value {largeValue} to the {newValue.GetType().Name} value {newValue}.");
}
catch (OverflowException)
{
    Console.WriteLine($"{largeValue} is outside the range of the Byte data type.");
}

try
{
    newValue = checked((byte)largeValue);
    Console.WriteLine($"Converted the {largeValue.GetType().Name} value {largeValue} to the {newValue.GetType().Name} value {newValue}.");
}
catch (OverflowException)
{
    Console.WriteLine($"{largeValue} is outside the range of the Byte data type.");
}
// The example displays the following output:
//    Converted the Int32 value 2147483647 to the Byte value 255.
//    2147483647 is outside the range of the Byte data type.

特定の言語コンパイラでカスタム オーバーロード演算子がサポートされている場合は、独自のカスタム型で明示的な変換を定義することもできます。 次の例では、符号と大きさの表現を使用する ByteWithSign という名前の符号付きバイト データ型の部分的な実装を示します。 Int32値とUInt32値からByteWithSign値への明示的な変換がサポートされています。

public struct ByteWithSignE
{
    private SByte signValue;
    private Byte value;

    private const byte MaxValue = byte.MaxValue;
    private const int MinValue = -1 * byte.MaxValue;

    public static explicit operator ByteWithSignE(int value)
    {
        // Check for overflow.
        if (value > ByteWithSignE.MaxValue || value < ByteWithSignE.MinValue)
            throw new OverflowException(String.Format("'{0}' is out of range of the ByteWithSignE data type.",
                                                      value));

        ByteWithSignE newValue;
        newValue.signValue = (SByte)Math.Sign(value);
        newValue.value = (byte)Math.Abs(value);
        return newValue;
    }

    public static explicit operator ByteWithSignE(uint value)
    {
        if (value > ByteWithSignE.MaxValue)
            throw new OverflowException(String.Format("'{0}' is out of range of the ByteWithSignE data type.",
                                                      value));

        ByteWithSignE newValue;
        newValue.signValue = 1;
        newValue.value = (byte)value;
        return newValue;
    }

    public override string ToString()
    {
        return (signValue * value).ToString();
    }
}

Public Structure ByteWithSign
    Private signValue As SByte
    Private value As Byte

    Private Const MaxValue As Byte = Byte.MaxValue
    Private Const MinValue As Integer = -1 * Byte.MaxValue

    Public Overloads Shared Narrowing Operator CType(value As Integer) As ByteWithSign
        ' Check for overflow.
        If value > ByteWithSign.MaxValue Or value < ByteWithSign.MinValue Then
            Throw New OverflowException(String.Format("'{0}' is out of range of the ByteWithSign data type.", value))
        End If

        Dim newValue As ByteWithSign

        newValue.signValue = CSByte(Math.Sign(value))
        newValue.value = CByte(Math.Abs(value))
        Return newValue
    End Operator

    Public Overloads Shared Narrowing Operator CType(value As UInteger) As ByteWithSign
        If value > ByteWithSign.MaxValue Then
            Throw New OverflowException(String.Format("'{0}' is out of range of the ByteWithSign data type.", value))
        End If

        Dim NewValue As ByteWithSign

        newValue.signValue = 1
        newValue.value = CByte(value)
        Return newValue
    End Operator

    Public Overrides Function ToString() As String
        Return (signValue * value).ToString()
    End Function
End Structure

次の例に示すように、クライアント コードでは、 ByteWithSign 変数を宣言し、割り当てにキャスト演算子または変換メソッドが含まれている場合は、 Int32 値と UInt32 値を割り当てることができます。

ByteWithSignE value;

try
{
    int intValue = -120;
    value = (ByteWithSignE)intValue;
    Console.WriteLine(value);
}
catch (OverflowException e)
{
    Console.WriteLine(e.Message);
}

try
{
    uint uintValue = 1024;
    value = (ByteWithSignE)uintValue;
    Console.WriteLine(value);
}
catch (OverflowException e)
{
    Console.WriteLine(e.Message);
}
// The example displays the following output:
//       -120
//       '1024' is out of range of the ByteWithSignE data type.

Dim value As ByteWithSign

Try
    Dim intValue As Integer = -120
    value = CType(intValue, ByteWithSign)
    Console.WriteLine(value)
Catch e As OverflowException
    Console.WriteLine(e.Message)
End Try

Try
    Dim uintValue As UInteger = 1024
    value = CType(uintValue, ByteWithSign)
    Console.WriteLine(value)
Catch e As OverflowException
    Console.WriteLine(e.Message)
End Try
' The example displays the following output:
'       -120
'       '1024' is out of range of the ByteWithSign data type.

IConvertible インターフェイス

.NET は、任意の型から共通言語ランタイムの基本型への変換をサポートするために、 IConvertible インターフェイスを提供します。 実装型は、次の情報を提供するために必要です。

  • 実装する型の TypeCode を返すメソッド。

  • 実装型を各共通言語ランタイム基本型 (Boolean、 Byte、 DateTime、 Decimal、 Doubleなど) に変換するメソッド。

  • 実装型のインスタンスを別の指定された型に変換する一般化された変換メソッド。 サポートされていない変換では、 InvalidCastExceptionがスローされます。

各共通言語ランタイムの基本型 (つまり、 Boolean、 Byte、 Char、 DateTime、 Decimal、 Double、 Int16、 Int32、 Int64、 SByte、 Single、 String、 UInt16、 UInt32、および UInt64)、および DBNull 型と Enum 型は、 IConvertible インターフェイスを実装します。 ただし、これらは明示的なインターフェイス実装です。変換メソッドは、次の例に示すように、 IConvertible インターフェイス変数を介してのみ呼び出すことができます。 次の使用例は、 Int32 値を等価の Char 値に変換します。

int codePoint = 1067;
IConvertible iConv = codePoint;
char ch = iConv.ToChar(null);
Console.WriteLine($"Converted {codePoint} to {ch}.");

Dim codePoint As Integer = 1067
Dim iConv As IConvertible = codePoint
Dim ch As Char = iConv.ToChar(Nothing)
Console.WriteLine("Converted {0} to {1}.", codePoint, ch)

実装型ではなく、そのインターフェイスで変換メソッドを呼び出す必要があります。これにより、明示的なインターフェイスの実装は比較的コストがかかります。 代わりに、 Convert クラスの適切なメンバーを呼び出して、共通言語ランタイムの基本型間で変換することをお勧めします。 詳細については、次のセクション「 Convert クラス」を参照してください。

注

.NET によって提供される IConvertible インターフェイスと Convert クラスに加えて、個々の言語で変換を実行する方法も提供される場合があります。 たとえば、C# ではキャスト演算子が使用されます。Visual Basic では、 CType、 CInt、 DirectCastなどのコンパイラによって実装された変換関数が使用されます。

ほとんどの場合、 IConvertible インターフェイスは、.NET の基本型間の変換をサポートするように設計されています。 ただし、インターフェイスをカスタム型で実装して、その型から他のカスタム型への変換をサポートすることもできます。 詳細については、このトピックで後述する 「ChangeType メソッドを使用したカスタム変換 」セクションを参照してください。

Convert クラス

各基本型の IConvertible インターフェイス実装を呼び出して型変換を実行できますが、基本型から別の基本型に変換するには、 System.Convert クラスのメソッドを呼び出す方法をお勧めします。 さらに、 Convert.ChangeType(Object, Type, IFormatProvider) メソッドを使用して、指定したカスタム型から別の型に変換できます。

基本型間の変換

Convert クラスは、基本型間の変換を実行する言語に依存しない方法を提供し、共通言語ランタイムを対象とするすべての言語で使用できます。 拡大変換と縮小変換の両方のメソッドの完全なセットを提供し、サポートされていない変換 (DateTime値から整数値への変換など) のInvalidCastExceptionをスローします。 縮小変換はチェック コンテキストで実行され、変換が失敗した場合は OverflowException がスローされます。

Von Bedeutung

Convert クラスには各基本型との間で変換するメソッドが含まれているため、各基本型のIConvertible明示的なインターフェイス実装を呼び出す必要がなくなります。

次の例は、 System.Convert クラスを使用して、.NET 基本型間で複数の拡大変換と縮小変換を実行する方法を示しています。

// Convert an Int32 value to a Decimal (a widening conversion).
int integralValue = 12534;
decimal decimalValue = Convert.ToDecimal(integralValue);
Console.WriteLine($"Converted the {integralValue.GetType().Name} value {integralValue} to " +
                                  "the {decimalValue.GetType().Name} value {decimalValue:N2}.");
// Convert a Byte value to an Int32 value (a widening conversion).
byte byteValue = Byte.MaxValue;
int integralValue2 = Convert.ToInt32(byteValue);
Console.WriteLine($"Converted the {byteValue.GetType().Name} value {byteValue} to " +
                                  "the {integralValue2.GetType().Name} value {integralValue2:G}.");

// Convert a Double value to an Int32 value (a narrowing conversion).
double doubleValue = 16.32513e12;
try
{
    long longValue = Convert.ToInt64(doubleValue);
    Console.WriteLine($"Converted the {doubleValue.GetType().Name} value {doubleValue:E} to " +
                                      "the {longValue.GetType().Name} value {longValue:N0}.");
}
catch (OverflowException)
{
    Console.WriteLine($"Unable to convert the {doubleValue.GetType().Name:E} value {doubleValue}.");
}

// Convert a signed byte to a byte (a narrowing conversion).
sbyte sbyteValue = -16;
try
{
    byte byteValue2 = Convert.ToByte(sbyteValue);
    Console.WriteLine($"Converted the {sbyteValue.GetType().Name} value {sbyteValue} to " +
                                      "the {byteValue2.GetType().Name} value {byteValue2:G}.");
}
catch (OverflowException)
{
    Console.WriteLine($"Unable to convert the {sbyteValue.GetType().Name} value {sbyteValue}.");
}
// The example displays the following output:
//       Converted the Int32 value 12534 to the Decimal value 12,534.00.
//       Converted the Byte value 255 to the Int32 value 255.
//       Converted the Double value 1.632513E+013 to the Int64 value 16,325,130,000,000.
//       Unable to convert the SByte value -16.

' Convert an Int32 value to a Decimal (a widening conversion).
Dim integralValue As Integer = 12534
Dim decimalValue As Decimal = Convert.ToDecimal(integralValue)
Console.WriteLine("Converted the {0} value {1} to the {2} value {3:N2}.",
                  integralValue.GetType().Name,
                  integralValue,
                  decimalValue.GetType().Name,
                  decimalValue)

' Convert a Byte value to an Int32 value (a widening conversion).
Dim byteValue As Byte = Byte.MaxValue
Dim integralValue2 As Integer = Convert.ToInt32(byteValue)
Console.WriteLine("Converted the {0} value {1} to " +
                                  "the {2} value {3:G}.",
                                  byteValue.GetType().Name,
                                  byteValue,
                                  integralValue2.GetType().Name,
                                  integralValue2)

' Convert a Double value to an Int32 value (a narrowing conversion).
Dim doubleValue As Double = 16.32513e12
Try
    Dim longValue As Long = Convert.ToInt64(doubleValue)
    Console.WriteLine("Converted the {0} value {1:E} to " +
                                      "the {2} value {3:N0}.",
                                      doubleValue.GetType().Name,
                                      doubleValue,
                                      longValue.GetType().Name,
                                      longValue)
Catch e As OverflowException
    Console.WriteLine("Unable to convert the {0:E} value {1}.",
                                      doubleValue.GetType().Name, doubleValue)
End Try

' Convert a signed byte to a byte (a narrowing conversion).     
Dim sbyteValue As SByte = -16
Try
    Dim byteValue2 As Byte = Convert.ToByte(sbyteValue)
    Console.WriteLine("Converted the {0} value {1} to " +
                                      "the {2} value {3:G}.",
                                      sbyteValue.GetType().Name,
                                      sbyteValue,
                                      byteValue2.GetType().Name,
                                      byteValue2)
Catch e As OverflowException
    Console.WriteLine("Unable to convert the {0} value {1}.",
                                      sbyteValue.GetType().Name, sbyteValue)
End Try
' The example displays the following output:
'       Converted the Int32 value 12534 to the Decimal value 12,534.00.
'       Converted the Byte value 255 to the Int32 value 255.
'       Converted the Double value 1.632513E+013 to the Int64 value 16,325,130,000,000.
'       Unable to convert the SByte value -16.

場合によっては、特に浮動小数点値との間で変換するときに、 OverflowExceptionがスローされない場合でも、変換に精度の損失が伴う場合があります。 次の例は、この精度の損失を示しています。 最初のケースでは、 Decimal 値が Doubleに変換されるときに、有効桁数が短くなります (有効桁数が少なくなります)。 2 番目のケースでは、変換を完了するために、 Double 値が 42.72 から 43 に丸められます。

double doubleValue;

// Convert a Double to a Decimal.
decimal decimalValue = 13956810.96702888123451471211m;
doubleValue = Convert.ToDouble(decimalValue);
Console.WriteLine($"{decimalValue} converted to {doubleValue}.");

doubleValue = 42.72;
try
{
    int integerValue = Convert.ToInt32(doubleValue);
    Console.WriteLine($"{doubleValue} converted to {integerValue}.");
}
catch (OverflowException)
{
    Console.WriteLine($"Unable to convert {doubleValue} to an integer.");
}
// The example displays the following output:
//       13956810.96702888123451471211 converted to 13956810.9670289.
//       42.72 converted to 43.

Dim doubleValue As Double

' Convert a Double to a Decimal.
Dim decimalValue As Decimal = 13956810.96702888123451471211d
doubleValue = Convert.ToDouble(decimalValue)
Console.WriteLine("{0} converted to {1}.", decimalValue, doubleValue)

doubleValue = 42.72
Try
    Dim integerValue As Integer = Convert.ToInt32(doubleValue)
    Console.WriteLine("{0} converted to {1}.",
                                      doubleValue, integerValue)
Catch e As OverflowException
    Console.WriteLine("Unable to convert {0} to an integer.",
                                      doubleValue)
End Try
' The example displays the following output:
'       13956810.96702888123451471211 converted to 13956810.9670289.
'       42.72 converted to 43.

Convert クラスでサポートされている拡大変換と縮小変換の両方を一覧表示するテーブルについては、「型変換テーブル」を参照してください。

ChangeType メソッドを使用したカスタム変換

各基本型への変換をサポートするだけでなく、 Convert クラスを使用して、カスタム型を 1 つ以上の定義済みの型に変換できます。 この変換は、Convert.ChangeType(Object, Type, IFormatProvider) メソッドによって実行され、value パラメーターの IConvertible.ToType メソッドの呼び出しがラップされます。 つまり、 value パラメーターで表されるオブジェクトは、 IConvertible インターフェイスの実装を提供する必要があります。

注

Convert.ChangeType(Object, Type)メソッドと Convert.ChangeType(Object, Type, IFormatProvider) メソッドでは、Type オブジェクトを使用してvalueの変換先の型を指定するため、コンパイル時に型が不明なオブジェクトへの動的な変換を実行するために使用できます。 ただし、valueのIConvertible実装では、この変換を引き続きサポートする必要があることに注意してください。

次の例は、TemperatureCelsius オブジェクトをTemperatureFahrenheit オブジェクトに変換できるようにする、IConvertible インターフェイスの実装の可能性を示しています。 この例では、IConvertible インターフェイスを実装し、Object.ToString メソッドをオーバーライドする基底クラス (Temperature) を定義します。 派生 TemperatureCelsius クラスと TemperatureFahrenheit クラスはそれぞれ、基底クラスの ToType メソッドと ToString メソッドをオーバーライドします。

using System;

public abstract class Temperature : IConvertible
{
    protected decimal temp;

    public Temperature(decimal temperature)
    {
        this.temp = temperature;
    }

    public decimal Value
    {
        get { return this.temp; }
        set { this.temp = value; }
    }

    public override string ToString()
    {
        return temp.ToString(null as IFormatProvider) + "º";
    }

    // IConvertible implementations.
    public TypeCode GetTypeCode()
    {
        return TypeCode.Object;
    }

    public bool ToBoolean(IFormatProvider provider)
    {
        throw new InvalidCastException(String.Format("Temperature-to-Boolean conversion is not supported."));
    }

    public byte ToByte(IFormatProvider provider)
    {
        if (temp < Byte.MinValue || temp > Byte.MaxValue)
            throw new OverflowException(String.Format("{0} is out of range of the Byte data type.", temp));
        else
            return (byte)temp;
    }

    public char ToChar(IFormatProvider provider)
    {
        throw new InvalidCastException("Temperature-to-Char conversion is not supported.");
    }

    public DateTime ToDateTime(IFormatProvider provider)
    {
        throw new InvalidCastException("Temperature-to-DateTime conversion is not supported.");
    }

    public decimal ToDecimal(IFormatProvider provider)
    {
        return temp;
    }

    public double ToDouble(IFormatProvider provider)
    {
        return (double)temp;
    }

    public short ToInt16(IFormatProvider provider)
    {
        if (temp < Int16.MinValue || temp > Int16.MaxValue)
            throw new OverflowException(String.Format("{0} is out of range of the Int16 data type.", temp));
        else
            return (short)Math.Round(temp);
    }

    public int ToInt32(IFormatProvider provider)
    {
        if (temp < Int32.MinValue || temp > Int32.MaxValue)
            throw new OverflowException(String.Format("{0} is out of range of the Int32 data type.", temp));
        else
            return (int)Math.Round(temp);
    }

    public long ToInt64(IFormatProvider provider)
    {
        if (temp < Int64.MinValue || temp > Int64.MaxValue)
            throw new OverflowException(String.Format("{0} is out of range of the Int64 data type.", temp));
        else
            return (long)Math.Round(temp);
    }

    public sbyte ToSByte(IFormatProvider provider)
    {
        if (temp < SByte.MinValue || temp > SByte.MaxValue)
            throw new OverflowException(String.Format("{0} is out of range of the SByte data type.", temp));
        else
            return (sbyte)temp;
    }

    public float ToSingle(IFormatProvider provider)
    {
        return (float)temp;
    }

    public virtual string ToString(IFormatProvider provider)
    {
        return temp.ToString(provider) + "°";
    }

    // If conversionType is implemented by another IConvertible method, call it.
    public virtual object ToType(Type conversionType, IFormatProvider provider)
    {
        switch (Type.GetTypeCode(conversionType))
        {
            case TypeCode.Boolean:
                return this.ToBoolean(provider);
            case TypeCode.Byte:
                return this.ToByte(provider);
            case TypeCode.Char:
                return this.ToChar(provider);
            case TypeCode.DateTime:
                return this.ToDateTime(provider);
            case TypeCode.Decimal:
                return this.ToDecimal(provider);
            case TypeCode.Double:
                return this.ToDouble(provider);
            case TypeCode.Empty:
                throw new NullReferenceException("The target type is null.");
            case TypeCode.Int16:
                return this.ToInt16(provider);
            case TypeCode.Int32:
                return this.ToInt32(provider);
            case TypeCode.Int64:
                return this.ToInt64(provider);
            case TypeCode.Object:
                // Leave conversion of non-base types to derived classes.
                throw new InvalidCastException(String.Format("Cannot convert from Temperature to {0}.",
                                               conversionType.Name));
            case TypeCode.SByte:
                return this.ToSByte(provider);
            case TypeCode.Single:
                return this.ToSingle(provider);
            case TypeCode.String:
                IConvertible iconv = this;
                return iconv.ToString(provider);
            case TypeCode.UInt16:
                return this.ToUInt16(provider);
            case TypeCode.UInt32:
                return this.ToUInt32(provider);
            case TypeCode.UInt64:
                return this.ToUInt64(provider);
            default:
                throw new InvalidCastException("Conversion not supported.");
        }
    }

    public ushort ToUInt16(IFormatProvider provider)
    {
        if (temp < UInt16.MinValue || temp > UInt16.MaxValue)
            throw new OverflowException(String.Format("{0} is out of range of the UInt16 data type.", temp));
        else
            return (ushort)Math.Round(temp);
    }

    public uint ToUInt32(IFormatProvider provider)
    {
        if (temp < UInt32.MinValue || temp > UInt32.MaxValue)
            throw new OverflowException(String.Format("{0} is out of range of the UInt32 data type.", temp));
        else
            return (uint)Math.Round(temp);
    }

    public ulong ToUInt64(IFormatProvider provider)
    {
        if (temp < UInt64.MinValue || temp > UInt64.MaxValue)
            throw new OverflowException(String.Format("{0} is out of range of the UInt64 data type.", temp));
        else
            return (ulong)Math.Round(temp);
    }
}

public class TemperatureCelsius : Temperature, IConvertible
{
    public TemperatureCelsius(decimal value) : base(value)
    {
    }

    // Override ToString methods.
    public override string ToString()
    {
        return this.ToString(null);
    }

    public override string ToString(IFormatProvider provider)
    {
        return temp.ToString(provider) + "°C";
    }

    // If conversionType is a implemented by another IConvertible method, call it.
    public override object ToType(Type conversionType, IFormatProvider provider)
    {
        // For non-objects, call base method.
        if (Type.GetTypeCode(conversionType) != TypeCode.Object)
        {
            return base.ToType(conversionType, provider);
        }
        else
        {
            if (conversionType.Equals(typeof(TemperatureCelsius)))
                return this;
            else if (conversionType.Equals(typeof(TemperatureFahrenheit)))
                return new TemperatureFahrenheit((decimal)this.temp * 9 / 5 + 32);
            else
                throw new InvalidCastException(String.Format("Cannot convert from Temperature to {0}.",
                                               conversionType.Name));
        }
    }
}

public class TemperatureFahrenheit : Temperature, IConvertible
{
    public TemperatureFahrenheit(decimal value) : base(value)
    {
    }

    // Override ToString methods.
    public override string ToString()
    {
        return this.ToString(null);
    }

    public override string ToString(IFormatProvider provider)
    {
        return temp.ToString(provider) + "°F";
    }

    public override object ToType(Type conversionType, IFormatProvider provider)
    {
        // For non-objects, call base method.
        if (Type.GetTypeCode(conversionType) != TypeCode.Object)
        {
            return base.ToType(conversionType, provider);
        }
        else
        {
            // Handle conversion between derived classes.
            if (conversionType.Equals(typeof(TemperatureFahrenheit)))
                return this;
            else if (conversionType.Equals(typeof(TemperatureCelsius)))
                return new TemperatureCelsius((decimal)(this.temp - 32) * 5 / 9);
            // Unspecified object type: throw an InvalidCastException.
            else
                throw new InvalidCastException(String.Format("Cannot convert from Temperature to {0}.",
                                               conversionType.Name));
        }
    }
}

Public MustInherit Class Temperature
    Implements IConvertible

    Protected temp As Decimal

    Public Sub New(temperature As Decimal)
        Me.temp = temperature
    End Sub

    Public Property Value As Decimal
        Get
            Return Me.temp
        End Get
        Set
            Me.temp = Value
        End Set
    End Property

    Public Overrides Function ToString() As String
        Return temp.ToString() & "º"
    End Function

    ' IConvertible implementations.
    Public Function GetTypeCode() As TypeCode Implements IConvertible.GetTypeCode
        Return TypeCode.Object
    End Function

    Public Function ToBoolean(provider As IFormatProvider) As Boolean Implements IConvertible.ToBoolean
        Throw New InvalidCastException(String.Format("Temperature-to-Boolean conversion is not supported."))
    End Function

    Public Function ToByte(provider As IFormatProvider) As Byte Implements IConvertible.ToByte
        If temp < Byte.MinValue Or temp > Byte.MaxValue Then
            Throw New OverflowException(String.Format("{0} is out of range of the Byte data type.", temp))
        Else
            Return CByte(temp)
        End If
    End Function

    Public Function ToChar(provider As IFormatProvider) As Char Implements IConvertible.ToChar
        Throw New InvalidCastException("Temperature-to-Char conversion is not supported.")
    End Function

    Public Function ToDateTime(provider As IFormatProvider) As DateTime Implements IConvertible.ToDateTime
        Throw New InvalidCastException("Temperature-to-DateTime conversion is not supported.")
    End Function

    Public Function ToDecimal(provider As IFormatProvider) As Decimal Implements IConvertible.ToDecimal
        Return temp
    End Function

    Public Function ToDouble(provider As IFormatProvider) As Double Implements IConvertible.ToDouble
        Return CDbl(temp)
    End Function

    Public Function ToInt16(provider As IFormatProvider) As Int16 Implements IConvertible.ToInt16
        If temp < Int16.MinValue Or temp > Int16.MaxValue Then
            Throw New OverflowException(String.Format("{0} is out of range of the Int16 data type.", temp))
        End If
        Return CShort(Math.Round(temp))
    End Function

    Public Function ToInt32(provider As IFormatProvider) As Int32 Implements IConvertible.ToInt32
        If temp < Int32.MinValue Or temp > Int32.MaxValue Then
            Throw New OverflowException(String.Format("{0} is out of range of the Int32 data type.", temp))
        End If
        Return CInt(Math.Round(temp))
    End Function

    Public Function ToInt64(provider As IFormatProvider) As Int64 Implements IConvertible.ToInt64
        If temp < Int64.MinValue Or temp > Int64.MaxValue Then
            Throw New OverflowException(String.Format("{0} is out of range of the Int64 data type.", temp))
        End If
        Return CLng(Math.Round(temp))
    End Function

    Public Function ToSByte(provider As IFormatProvider) As SByte Implements IConvertible.ToSByte
        If temp < SByte.MinValue Or temp > SByte.MaxValue Then
            Throw New OverflowException(String.Format("{0} is out of range of the SByte data type.", temp))
        Else
            Return CSByte(temp)
        End If
    End Function

    Public Function ToSingle(provider As IFormatProvider) As Single Implements IConvertible.ToSingle
        Return CSng(temp)
    End Function

    Public Overridable Overloads Function ToString(provider As IFormatProvider) As String Implements IConvertible.ToString
        Return temp.ToString(provider) & " °C"
    End Function

    ' If conversionType is a implemented by another IConvertible method, call it.
    Public Overridable Function ToType(conversionType As Type, provider As IFormatProvider) As Object Implements IConvertible.ToType
        Select Case Type.GetTypeCode(conversionType)
            Case TypeCode.Boolean
                Return Me.ToBoolean(provider)
            Case TypeCode.Byte
                Return Me.ToByte(provider)
            Case TypeCode.Char
                Return Me.ToChar(provider)
            Case TypeCode.DateTime
                Return Me.ToDateTime(provider)
            Case TypeCode.Decimal
                Return Me.ToDecimal(provider)
            Case TypeCode.Double
                Return Me.ToDouble(provider)
            Case TypeCode.Empty
                Throw New NullReferenceException("The target type is null.")
            Case TypeCode.Int16
                Return Me.ToInt16(provider)
            Case TypeCode.Int32
                Return Me.ToInt32(provider)
            Case TypeCode.Int64
                Return Me.ToInt64(provider)
            Case TypeCode.Object
                ' Leave conversion of non-base types to derived classes.
                Throw New InvalidCastException(String.Format("Cannot convert from Temperature to {0}.", _
                                               conversionType.Name))
            Case TypeCode.SByte
                Return Me.ToSByte(provider)
            Case TypeCode.Single
                Return Me.ToSingle(provider)
            Case TypeCode.String
                Return Me.ToString(provider)
            Case TypeCode.UInt16
                Return Me.ToUInt16(provider)
            Case TypeCode.UInt32
                Return Me.ToUInt32(provider)
            Case TypeCode.UInt64
                Return Me.ToUInt64(provider)
            Case Else
                Throw New InvalidCastException("Conversion not supported.")
        End Select
    End Function

    Public Function ToUInt16(provider As IFormatProvider) As UInt16 Implements IConvertible.ToUInt16
        If temp < UInt16.MinValue Or temp > UInt16.MaxValue Then
            Throw New OverflowException(String.Format("{0} is out of range of the UInt16 data type.", temp))
        End If
        Return CUShort(Math.Round(temp))
    End Function

    Public Function ToUInt32(provider As IFormatProvider) As UInt32 Implements IConvertible.ToUInt32
        If temp < UInt32.MinValue Or temp > UInt32.MaxValue Then
            Throw New OverflowException(String.Format("{0} is out of range of the UInt32 data type.", temp))
        End If
        Return CUInt(Math.Round(temp))
    End Function

    Public Function ToUInt64(provider As IFormatProvider) As UInt64 Implements IConvertible.ToUInt64
        If temp < UInt64.MinValue Or temp > UInt64.MaxValue Then
            Throw New OverflowException(String.Format("{0} is out of range of the UInt64 data type.", temp))
        End If
        Return CULng(Math.Round(temp))
    End Function
End Class

Public Class TemperatureCelsius : Inherits Temperature : Implements IConvertible
    Public Sub New(value As Decimal)
        MyBase.New(value)
    End Sub

    ' Override ToString methods.
    Public Overrides Function ToString() As String
        Return Me.ToString(Nothing)
    End Function

    Public Overrides Function ToString(provider As IFormatProvider) As String
        Return temp.ToString(provider) + "°C"
    End Function

    ' If conversionType is a implemented by another IConvertible method, call it.
    Public Overrides Function ToType(conversionType As Type, provider As IFormatProvider) As Object
        ' For non-objects, call base method.
        If Type.GetTypeCode(conversionType) <> TypeCode.Object Then
            Return MyBase.ToType(conversionType, provider)
        Else
            If conversionType.Equals(GetType(TemperatureCelsius)) Then
                Return Me
            ElseIf conversionType.Equals(GetType(TemperatureFahrenheit))
                Return New TemperatureFahrenheit(CDec(Me.temp * 9 / 5 + 32))
                ' Unspecified object type: throw an InvalidCastException.
            Else
                Throw New InvalidCastException(String.Format("Cannot convert from Temperature to {0}.", _
                                               conversionType.Name))
            End If
        End If
    End Function
End Class

Public Class TemperatureFahrenheit : Inherits Temperature : Implements IConvertible
    Public Sub New(value As Decimal)
        MyBase.New(value)
    End Sub

    ' Override ToString methods.
    Public Overrides Function ToString() As String
        Return Me.ToString(Nothing)
    End Function

    Public Overrides Function ToString(provider As IFormatProvider) As String
        Return temp.ToString(provider) + "°F"
    End Function

    Public Overrides Function ToType(conversionType As Type, provider As IFormatProvider) As Object
        ' For non-objects, call base method.
        If Type.GetTypeCode(conversionType) <> TypeCode.Object Then
            Return MyBase.ToType(conversionType, provider)
        Else
            ' Handle conversion between derived classes.
            If conversionType.Equals(GetType(TemperatureFahrenheit)) Then
                Return Me
            ElseIf conversionType.Equals(GetType(TemperatureCelsius))
                Return New TemperatureCelsius(CDec((MyBase.temp - 32) * 5 / 9))
                ' Unspecified object type: throw an InvalidCastException.
            Else
                Throw New InvalidCastException(String.Format("Cannot convert from Temperature to {0}.", _
                                               conversionType.Name))
            End If
        End If
    End Function
End Class

次の例では、これらの IConvertible 実装を呼び出して、 TemperatureCelsius オブジェクトを TemperatureFahrenheit オブジェクトに変換します。その逆も同様です。

TemperatureCelsius tempC1 = new TemperatureCelsius(0);
TemperatureFahrenheit tempF1 = (TemperatureFahrenheit)Convert.ChangeType(tempC1, typeof(TemperatureFahrenheit), null);
Console.WriteLine($"{tempC1} equals {tempF1}.");
TemperatureCelsius tempC2 = (TemperatureCelsius)Convert.ChangeType(tempC1, typeof(TemperatureCelsius), null);
Console.WriteLine($"{tempC1} equals {tempC2}.");
TemperatureFahrenheit tempF2 = new TemperatureFahrenheit(212);
TemperatureCelsius tempC3 = (TemperatureCelsius)Convert.ChangeType(tempF2, typeof(TemperatureCelsius), null);
Console.WriteLine($"{tempF2} equals {tempC3}.");
TemperatureFahrenheit tempF3 = (TemperatureFahrenheit)Convert.ChangeType(tempF2, typeof(TemperatureFahrenheit), null);
Console.WriteLine($"{tempF2} equals {tempF3}.");
// The example displays the following output:
//       0°C equals 32°F.
//       0°C equals 0°C.
//       212°F equals 100°C.
//       212°F equals 212°F.

Dim tempC1 As New TemperatureCelsius(0)
Dim tempF1 As TemperatureFahrenheit = CType(Convert.ChangeType(tempC1, GetType(TemperatureFahrenheit), Nothing), TemperatureFahrenheit)
Console.WriteLine("{0} equals {1}.", tempC1, tempF1)
Dim tempC2 As TemperatureCelsius = CType(Convert.ChangeType(tempC1, GetType(TemperatureCelsius), Nothing), TemperatureCelsius)
Console.WriteLine("{0} equals {1}.", tempC1, tempC2)
Dim tempF2 As New TemperatureFahrenheit(212)
Dim tempC3 As TEmperatureCelsius = CType(Convert.ChangeType(tempF2, GEtType(TemperatureCelsius), Nothing), TemperatureCelsius)
Console.WriteLine("{0} equals {1}.", tempF2, tempC3)
Dim tempF3 As TemperatureFahrenheit = CType(Convert.ChangeType(tempF2, GetType(TemperatureFahrenheit), Nothing), TemperatureFahrenheit)
Console.WriteLine("{0} equals {1}.", tempF2, tempF3)
' The example displays the following output:
'       0°C equals 32°F.
'       0°C equals 0°C.
'       212°F equals 100°C.
'       212°F equals 212°F.

TypeConverter クラス

.NET では、 System.ComponentModel.TypeConverter クラスを拡張し、 System.ComponentModel.TypeConverterAttribute 属性を使用して型コンバーターを型に関連付けることで、カスタム型の型コンバーターを定義することもできます。 次の表では、このアプローチとカスタム型の IConvertible インターフェイスの実装の違いを示します。

注

デザイン時のサポートは、カスタム型に対して型コンバーターが定義されている場合にのみ提供できます。

TypeConverter を使用した変換 IConvertible を使用した変換
TypeConverterとは別のクラスを派生させることで、カスタム型に対して実装されます。 この派生クラスは、 TypeConverterAttribute 属性を適用することによって、カスタム型に関連付けられます。 変換を実行するカスタム型によって実装されます。 型のユーザーは、型に対して IConvertible 変換メソッドを呼び出します。
デザイン時と実行時の両方で使用できます。 実行時にのみ使用できます。
リフレクションを使用します。そのため、 IConvertibleによって有効になる変換よりも低速です。 リフレクションは使用しません。
カスタム型から他のデータ型への双方向型変換、および他のデータ型からカスタム型への双方向型変換を許可します。 たとえば、MyTypeに対して定義されたTypeConverterを使用すると、MyTypeからStringへの変換、およびStringからMyTypeへの変換が可能になります。 カスタム型から他のデータ型への変換を許可しますが、他のデータ型からカスタム型への変換は許可しません。

型コンバーターを使用して変換を実行する方法の詳細については、 System.ComponentModel.TypeConverterを参照してください。

こちらも参照ください