Convert.ChangeType Método

Definição

Namespace:

System

Assembly:

System.Runtime.dll

Retorna um objeto de um tipo especificado cujo valor é equivalente a um objeto especificado.

Sobrecargas

ChangeType(Object, Type)	Retorna um objeto do tipo especificado e cujo valor é equivalente ao objeto especificado.
ChangeType(Object, TypeCode)	Retorna um objeto do tipo especificado cujo valor é equivalente ao objeto especificado.
ChangeType(Object, Type, IFormatProvider)	Retorna um objeto do tipo especificado cujo valor é equivalente ao objeto especificado. Um parâmetro fornece informações de formatação específicas à cultura.
ChangeType(Object, TypeCode, IFormatProvider)	Retorna um objeto do tipo especificado cujo valor é equivalente ao objeto especificado. Um parâmetro fornece informações de formatação específicas à cultura.

ChangeType(Object, Type)

Origem:

Convert.cs

Retorna um objeto do tipo especificado e cujo valor é equivalente ao objeto especificado.

C#

public static object? ChangeType (object? value, Type conversionType);

Parâmetros

value

Object

Um objeto que implementa a interface IConvertible.

conversionType

Type

O tipo de objeto a ser retornado.

Retornos

Object

Um objeto cujo tipo é conversionType e cujo valor é equivalente a value.

-ou-

Uma referência nula (Nothing no Visual Basic), se value for null e conversionType não for um tipo de valor.

Exceções

InvalidCastException

Não há suporte para essa conversão.

-ou-

value é null e conversionType é um tipo de valor.

-ou-

value não implementa a interface IConvertible.

FormatException

value não está em um formato reconhecido por conversionType.

OverflowException

value representa um número fora do intervalo de conversionType.

ArgumentNullException

conversionType é null.

Exemplos

O exemplo a seguir ilustra o uso do método ChangeType.

C#

using System;

public class ChangeTypeTest {
    public static void Main() {

        Double d = -2.345;
        int i = (int)Convert.ChangeType(d, typeof(int));

        Console.WriteLine("The double value {0} when converted to an int becomes {1}", d, i);

        string s = "12/12/98";
        DateTime dt = (DateTime)Convert.ChangeType(s, typeof(DateTime));

        Console.WriteLine("The string value {0} when converted to a Date becomes {1}", s, dt);
    }
}

Comentários

ChangeType é um método de conversão de uso geral que converte o objeto especificado por value em conversionType. O parâmetro value pode ser um objeto de qualquer tipo e conversionType também pode ser um objeto Type que representa qualquer tipo base ou personalizado. Para que a conversão seja bem-sucedida, value deve implementar a interface IConvertible, pois o método simplesmente encapsula uma chamada para um método de IConvertible apropriado. O método requer que haja suporte para a conversão de value para conversionType.

Esse método usa a cultura do thread atual para a conversão.

Notas aos Chamadores

O método ChangeType(Object, Type) pode converter um valor de enumeração em outro tipo. No entanto, ele não pode converter outro tipo em um valor de enumeração, mesmo que o tipo de origem seja o tipo subjacente da enumeração. Para converter um tipo em um valor de enumeração, use um operador de conversão (em C#) ou uma função de conversão (no Visual Basic). O exemplo a seguir ilustra a conversão de e para um valor de enumeração Continent.

C#

using System;

public enum Continent
{
   Africa, Antarctica, Asia, Australia, Europe,
   NorthAmerica, SouthAmerica
};

public class Example
{
   public static void Main()
   {
      // Convert a Continent to a Double.
      Continent cont = Continent.NorthAmerica;
      Console.WriteLine("{0:N2}",
                        Convert.ChangeType(cont, typeof(Double)));

      // Convert a Double to a Continent.
      Double number = 6.0;
      try {
         Console.WriteLine("{0}",
                           Convert.ChangeType(number, typeof(Continent)));
      }
      catch (InvalidCastException) {
         Console.WriteLine("Cannot convert a Double to a Continent");
      }

      Console.WriteLine("{0}", (Continent) number);
   }
}
// The example displays the following output:
//       5.00
//       Cannot convert a Double to a Continent
//       SouthAmerica

O método ChangeType(Object, Type) pode converter um tipo anulável em outro tipo. No entanto, ele não pode converter outro tipo em um valor de um tipo anulável, mesmo que conversionType seja o tipo subjacente do Nullable<T>. Para executar a conversão, você pode usar um operador de conversão (em C#) ou uma função de conversão (no Visual Basic). O exemplo a seguir ilustra a conversão de e para um tipo anulável.

C#

using System;

public class Example
{
   public static void Main()
   {
      int? intValue1 = 12893;
      double dValue1 = (double) Convert.ChangeType(intValue1, typeof(Double));
      Console.WriteLine("{0} ({1})--> {2} ({3})", intValue1, intValue1.GetType().Name,
                        dValue1, dValue1.GetType().Name);

      float fValue1 = 16.3478f;
      int? intValue2 = (int) fValue1;
      Console.WriteLine("{0} ({1})--> {2} ({3})", fValue1, fValue1.GetType().Name,
                        intValue2, intValue2.GetType().Name);
   }
}
// The example displays the following output:
//    12893 (Int32)--> 12893 (Double)
//    16.3478 (Single)--> 16 (Int32)

ChangeType(Object, TypeCode)

Origem:

Convert.cs

Retorna um objeto do tipo especificado cujo valor é equivalente ao objeto especificado.

C#

public static object? ChangeType (object? value, TypeCode typeCode);

Parâmetros

value

Object

Um objeto que implementa a interface IConvertible.

typeCode

TypeCode

O tipo de objeto a ser retornado.

Retornos

Object

Um objeto cujo tipo subjacente é typeCode e cujo valor é equivalente a value.

-ou-

Uma referência nula (Nothing no Visual Basic), se value for null e typeCode for Empty, Stringou Object.

Exceções

InvalidCastException

Não há suporte para essa conversão.

-ou-

value é null e typeCode especifica um tipo de valor.

-ou-

value não implementa a interface IConvertible.

FormatException

value não está em um formato reconhecido pelo tipo typeCode.

OverflowException

value representa um número fora do intervalo do tipo typeCode.

ArgumentException

typeCode é inválido.

Exemplos

O exemplo a seguir ilustra como usar o método ChangeType(Object, TypeCode) para alterar um Object para o tipo especificado pelo parâmetro TypeCode, se possível.

C#

using System;

public class ChangeTypeTest {
    public static void Main() {

        Double d = -2.345;
        int i = (int)Convert.ChangeType(d, TypeCode.Int32);

        Console.WriteLine("The Double {0} when converted to an Int32 is {1}", d, i);

        string s = "12/12/2009";
        DateTime dt = (DateTime)Convert.ChangeType(s, typeof(DateTime));

        Console.WriteLine("The String {0} when converted to a Date is {1}", s, dt);
    }
}
// The example displays the following output:
//    The Double -2.345 when converted to an Int32 is -2
//    The String 12/12/2009 when converted to a Date is 12/12/2009 12:00:00 AM

Comentários

ChangeType(Object, TypeCode) é um método de conversão de uso geral que converte o objeto especificado por value em um tipo predefinido especificado por typeCode. O parâmetro value pode ser um objeto de qualquer tipo. Para que a conversão seja bem-sucedida, value deve implementar a interface IConvertible, pois o método simplesmente encapsula uma chamada para um método de IConvertible apropriado. O método também requer que haja suporte para a conversão de value para typeCode.

O método ChangeType(Object, TypeCode) não dá suporte à conversão de value em um tipo personalizado. Para executar essa conversão, chame o método ChangeType(Object, Type).

ChangeType(Object, Type, IFormatProvider)

Origem:

Convert.cs

Retorna um objeto do tipo especificado cujo valor é equivalente ao objeto especificado. Um parâmetro fornece informações de formatação específicas à cultura.

C#

public static object? ChangeType (object? value, Type conversionType, IFormatProvider? provider);

Parâmetros

value

Object

Um objeto que implementa a interface IConvertible.

conversionType

Type

O tipo de objeto a ser retornado.

provider

IFormatProvider

Um objeto que fornece informações de formatação específicas da cultura.

Retornos

Object

Um objeto cujo tipo é conversionType e cujo valor é equivalente a value.

-ou-

value, se a Type de value e conversionType forem iguais.

-ou-

Uma referência nula (Nothing no Visual Basic), se value for null e conversionType não for um tipo de valor.

Exceções

InvalidCastException

Não há suporte para essa conversão.

-ou-

value é null e conversionType é um tipo de valor.

-ou-

value não implementa a interface IConvertible.

FormatException

value não está em um formato para conversionType reconhecido por provider.

OverflowException

value representa um número fora do intervalo de conversionType.

ArgumentNullException

conversionType é null.

Exemplos

O exemplo a seguir define uma classe Temperature que implementa a interface IConvertible.

C#

using System;
using System.Globalization;

public class Temperature : IConvertible
{
   private decimal m_Temp;

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

   public decimal Celsius
   {
      get { return this.m_Temp; }
   }

   public decimal Kelvin
   {
      get { return this.m_Temp + 273.15m; }
   }

   public decimal Fahrenheit
   {
      get { return Math.Round((decimal) (this.m_Temp * 9 / 5 + 32), 2); }
   }

   public override string ToString()
   {
      return m_Temp.ToString("N2") + "°C";
   }

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

   public bool ToBoolean(IFormatProvider provider)
   {
      if (m_Temp == 0)
         return false;
      else
         return true;
   }

   public byte ToByte(IFormatProvider provider)
   {
      if (m_Temp < Byte.MinValue || m_Temp > Byte.MaxValue)
         throw new OverflowException(String.Format("{0} is out of range of the Byte type.",
                                                   this.m_Temp));
      else
         return Decimal.ToByte(this.m_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 this.m_Temp;
   }

   public double ToDouble(IFormatProvider provider)
   {
      return Decimal.ToDouble(this.m_Temp);
   }

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

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

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

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

   public float ToSingle(IFormatProvider provider)
   {
      return Decimal.ToSingle(this.m_Temp);
   }

   public string ToString(IFormatProvider provider)
   {
      return m_Temp.ToString("N2", provider) + "°C";
   }

   public object ToType(Type conversionType, IFormatProvider provider)
   {
      switch (Type.GetTypeCode(conversionType))
      {
         case TypeCode.Boolean:
            return this.ToBoolean(null);
         case TypeCode.Byte:
            return this.ToByte(null);
         case TypeCode.Char:
            return this.ToChar(null);
         case TypeCode.DateTime:
            return this.ToDateTime(null);
         case TypeCode.Decimal:
            return this.ToDecimal(null);
         case TypeCode.Double:
            return this.ToDouble(null);
         case TypeCode.Int16:
            return this.ToInt16(null);
         case TypeCode.Int32:
            return this.ToInt32(null);
         case TypeCode.Int64:
            return this.ToInt64(null);
         case TypeCode.Object:
            if (typeof(Temperature).Equals(conversionType))
               return this;
            else
               throw new InvalidCastException(String.Format("Conversion to a {0} is not supported.",
                                                            conversionType.Name));
         case TypeCode.SByte:
            return this.ToSByte(null);
         case TypeCode.Single:
            return this.ToSingle(null);
         case TypeCode.String:
            return this.ToString(provider);
         case TypeCode.UInt16:
            return this.ToUInt16(null);
         case TypeCode.UInt32:
            return this.ToUInt32(null);
         case TypeCode.UInt64:
            return this.ToUInt64(null);
         default:
            throw new InvalidCastException(String.Format("Conversion to {0} is not supported.", conversionType.Name));
      }
   }

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

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

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

O exemplo a seguir cria uma instância da classe Temperature e chama o método ChangeType(Object, Type, IFormatProvider) para convertê-lo nos tipos numéricos básicos compatíveis com o .NET e em um String. Ele ilustra que o método ChangeType encapsula uma chamada para a implementação de IConvertible do tipo de origem.

C#

public class Example
{
   public static void Main()
   {
      Temperature cool = new Temperature(5);
      Type[] targetTypes = { typeof(SByte), typeof(Int16), typeof(Int32),
                             typeof(Int64), typeof(Byte), typeof(UInt16),
                             typeof(UInt32), typeof(UInt64), typeof(Decimal),
                             typeof(Single), typeof(Double), typeof(String) };
      CultureInfo provider = new CultureInfo("fr-FR");

      foreach (Type targetType in targetTypes)
      {
         try {
            object value = Convert.ChangeType(cool, targetType, provider);
            Console.WriteLine("Converted {0} {1} to {2} {3}.",
                              cool.GetType().Name, cool.ToString(),
                              targetType.Name, value);
         }
         catch (InvalidCastException) {
            Console.WriteLine("Unsupported {0} --> {1} conversion.",
                              cool.GetType().Name, targetType.Name);
         }
         catch (OverflowException) {
            Console.WriteLine("{0} is out of range of the {1} type.",
                              cool, targetType.Name);
         }
      }
   }
}
// The example dosplays the following output:
//       Converted Temperature 5.00°C to SByte 5.
//       Converted Temperature 5.00°C to Int16 5.
//       Converted Temperature 5.00°C to Int32 5.
//       Converted Temperature 5.00°C to Int64 5.
//       Converted Temperature 5.00°C to Byte 5.
//       Converted Temperature 5.00°C to UInt16 5.
//       Converted Temperature 5.00°C to UInt32 5.
//       Converted Temperature 5.00°C to UInt64 5.
//       Converted Temperature 5.00°C to Decimal 5.
//       Converted Temperature 5.00°C to Single 5.
//       Converted Temperature 5.00°C to Double 5.
//       Converted Temperature 5.00°C to String 5,00°C.

Comentários

ChangeType é um método de conversão de uso geral que converte o objeto especificado por value em conversionType. O parâmetro value pode ser um objeto de qualquer tipo e conversionType também pode ser um objeto Type que representa qualquer tipo base ou personalizado. Para que a conversão seja bem-sucedida, value deve implementar a interface IConvertible, pois o método simplesmente encapsula uma chamada para um método de IConvertible apropriado. O método requer que haja suporte para a conversão de value para conversionType.

O parâmetro provider é uma implementação IFormatProvider que fornece informações de formatação para a conversão. Se e como esse parâmetro é usado depende da implementação de IConvertible subjacente. Se value for um tipo de dados base, provider será usado apenas para as seguintes conversões:

• Conversão de um número para uma cadeia de caracteres ou de uma cadeia de caracteres para um número. provider deve ser um objeto CultureInfo, um objeto NumberFormatInfo ou uma implementação de IFormatProvider personalizada que retorna um objeto NumberFormatInfo. No entanto, como o método ChangeType(Object, TypeCode, IFormatProvider) executa a conversão usando o especificador de formato "G" padrão, o parâmetro provider não terá efeito se value ou o tipo de destino for um inteiro sem sinal. Se provider for null, o objeto CultureInfo que representa a cultura atual será usado.

• Conversão de um valor DateTime em uma cadeia de caracteres ou de uma cadeia de caracteres para um valor DateTime. provider deve ser um objeto CultureInfo ou DateTimeFormatInfo. Se provider for null, o objeto CultureInfo que representa a cultura atual será usado.

Se value for um tipo definido pelo aplicativo, sua implementação IConvertible poderá usar o parâmetro provider.

Notas aos Chamadores

O método ChangeType(Object, Type, IFormatProvider) pode converter um valor de enumeração em outro tipo. No entanto, ele não pode converter outro tipo em um valor de enumeração, mesmo que o tipo de origem seja o tipo subjacente da enumeração. Para converter um tipo em um valor de enumeração, use um operador de conversão (em C#) ou uma função de conversão (no Visual Basic). O exemplo a seguir ilustra a conversão de e para um valor de enumeração Continent.

C#

using System;

public enum Continent
{
   Africa, Antarctica, Asia, Australia, Europe,
   NorthAmerica, SouthAmerica
};

public class Example
{
   public static void Main()
   {
      // Convert a Continent to a Double.
      Continent cont = Continent.NorthAmerica;
      Console.WriteLine("{0:N2}",
                        Convert.ChangeType(cont, typeof(Double)));

      // Convert a Double to a Continent.
      Double number = 6.0;
      try {
         Console.WriteLine("{0}",
                           Convert.ChangeType(number, typeof(Continent)));
      }
      catch (InvalidCastException) {
         Console.WriteLine("Cannot convert a Double to a Continent");
      }

      Console.WriteLine("{0}", (Continent) number);
   }
}
// The example displays the following output:
//       5.00
//       Cannot convert a Double to a Continent
//       SouthAmerica

O método ChangeType(Object, Type, IFormatProvider) pode converter um tipo anulável em outro tipo. No entanto, ele não pode converter outro tipo em um valor de um tipo anulável, mesmo que conversionType seja o tipo subjacente do Nullable<T>. Para executar a conversão, você pode usar um operador de conversão (em C#) ou uma função de conversão (no Visual Basic). O exemplo a seguir ilustra a conversão de e para um tipo anulável.

C#

using System;

public class Example
{
   public static void Main()
   {
      int? intValue1 = 12893;
      double dValue1 = (double) Convert.ChangeType(intValue1, typeof(Double), null);
      Console.WriteLine("{0} ({1})--> {2} ({3})", intValue1, intValue1.GetType().Name,
                        dValue1, dValue1.GetType().Name);

      float fValue1 = 16.3478f;
      int? intValue2 = (int) fValue1;
      Console.WriteLine("{0} ({1})--> {2} ({3})", fValue1, fValue1.GetType().Name,
                        intValue2, intValue2.GetType().Name);
   }
}
// The example displays the following output:
//    12893 (Int32)--> 12893 (Double)
//    16.3478 (Single)--> 16 (Int32)

ChangeType(Object, TypeCode, IFormatProvider)

Origem:

Convert.cs

Retorna um objeto do tipo especificado cujo valor é equivalente ao objeto especificado. Um parâmetro fornece informações de formatação específicas à cultura.

C#

public static object? ChangeType (object? value, TypeCode typeCode, IFormatProvider? provider);

Parâmetros

value

Object

Um objeto que implementa a interface IConvertible.

typeCode

TypeCode

O tipo de objeto a ser retornado.

provider

IFormatProvider

Um objeto que fornece informações de formatação específicas da cultura.

Retornos

Object

Um objeto cujo tipo subjacente é typeCode e cujo valor é equivalente a value.

-ou-

Uma referência nula (Nothing no Visual Basic), se value for null e typeCode for Empty, Stringou Object.

Exceções

InvalidCastException

Não há suporte para essa conversão.

-ou-

value é null e typeCode especifica um tipo de valor.

-ou-

value não implementa a interface IConvertible.

FormatException

value não está em um formato para o tipo de typeCode reconhecido por provider.

OverflowException

value representa um número fora do intervalo do tipo typeCode.

ArgumentException

typeCode é inválido.

Exemplos

O exemplo a seguir define um provedor de formato personalizado chamado InterceptProvider que indica quando seu método GetFormat é chamado e retorna um NumberFormatInfo para a cultura fr-FR e um objeto DateTimeFormatInfo para a cultura en-US. Esse provedor de formato é usado em todas as chamadas para o método ChangeType(Object, TypeCode, IFormatProvider). Em seguida, o exemplo cria uma matriz com um Double e um valor DateTime e faz chamadas repetidas para ChangeType(Object, TypeCode, IFormatProvider) com cada valor e cada membro da enumeração TypeCode. O exemplo ilustra quando o método usa o parâmetro IFormatProvider e também ilustra o uso do parâmetro provider para executar a formatação sensível à cultura.

C#

using System;
using System.Globalization;

public class InterceptProvider : IFormatProvider
{
   public object GetFormat(Type formatType)
   {
      if (formatType == typeof(NumberFormatInfo)) {
         Console.WriteLine("   Returning a fr-FR numeric format provider.");
         return new System.Globalization.CultureInfo("fr-FR").NumberFormat;
      }
      else if (formatType == typeof(DateTimeFormatInfo)) {
         Console.WriteLine("   Returning an en-US date/time format provider.");
         return new System.Globalization.CultureInfo("en-US").DateTimeFormat;
      }
      else {
         Console.WriteLine("   Requesting a format provider of {0}.", formatType.Name);
         return null;
      }
   }
}

public class Example
{
   public static void Main()
   {
      object[] values = { 103.5d, new DateTime(2010, 12, 26, 14, 34, 0) };
      IFormatProvider provider = new InterceptProvider();

      // Convert value to each of the types represented in TypeCode enum.
      foreach (object value in values)
      {
         // Iterate types in TypeCode enum.
         foreach (TypeCode enumType in ((TypeCode[]) Enum.GetValues(typeof(TypeCode))))
         {
            if (enumType == TypeCode.DBNull || enumType == TypeCode.Empty) continue;

            try {
               Console.WriteLine("{0} ({1}) --> {2} ({3}).",
                                 value, value.GetType().Name,
                                 Convert.ChangeType(value, enumType, provider),
                                 enumType.ToString());
            }
            catch (InvalidCastException) {
               Console.WriteLine("Cannot convert a {0} to a {1}",
                                 value.GetType().Name, enumType.ToString());
            }
            catch (OverflowException) {
               Console.WriteLine("Overflow: {0} is out of the range of a {1}",
                                 value, enumType.ToString());
            }
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//    103.5 (Double) --> 103.5 (Object).
//    103.5 (Double) --> True (Boolean).
//    Cannot convert a Double to a Char
//    103.5 (Double) --> 104 (SByte).
//    103.5 (Double) --> 104 (Byte).
//    103.5 (Double) --> 104 (Int16).
//    103.5 (Double) --> 104 (UInt16).
//    103.5 (Double) --> 104 (Int32).
//    103.5 (Double) --> 104 (UInt32).
//    103.5 (Double) --> 104 (Int64).
//    103.5 (Double) --> 104 (UInt64).
//    103.5 (Double) --> 103.5 (Single).
//    103.5 (Double) --> 103.5 (Double).
//    103.5 (Double) --> 103.5 (Decimal).
//    Cannot convert a Double to a DateTime
//       Returning a fr-FR numeric format provider.
//    103.5 (Double) --> 103,5 (String).
//
//    12/26/2010 2:34:00 PM (DateTime) --> 12/26/2010 2:34:00 PM (Object).
//    Cannot convert a DateTime to a Boolean
//    Cannot convert a DateTime to a Char
//    Cannot convert a DateTime to a SByte
//    Cannot convert a DateTime to a Byte
//    Cannot convert a DateTime to a Int16
//    Cannot convert a DateTime to a UInt16
//    Cannot convert a DateTime to a Int32
//    Cannot convert a DateTime to a UInt32
//    Cannot convert a DateTime to a Int64
//    Cannot convert a DateTime to a UInt64
//    Cannot convert a DateTime to a Single
//    Cannot convert a DateTime to a Double
//    Cannot convert a DateTime to a Decimal
//    12/26/2010 2:34:00 PM (DateTime) --> 12/26/2010 2:34:00 PM (DateTime).
//       Returning an en-US date/time format provider.
//    12/26/2010 2:34:00 PM (DateTime) --> 12/26/2010 2:34:00 PM (String).

Comentários

ChangeType(Object, TypeCode, IFormatProvider) é um método de conversão de uso geral que converte o objeto especificado por value em um tipo predefinido especificado por typeCode. O parâmetro value pode ser um objeto de qualquer tipo. Para que a conversão seja bem-sucedida, value deve implementar a interface IConvertible, pois o método simplesmente encapsula uma chamada para um método de IConvertible apropriado. O método também requer que haja suporte para a conversão de value para typeCode.

O método ChangeType(Object, TypeCode, IFormatProvider) não dá suporte à conversão de value em um tipo personalizado. Para executar essa conversão, chame o método ChangeType(Object, Type, IFormatProvider).

O parâmetro provider é uma implementação IFormatProvider que fornece informações de formatação para a conversão. Se e como esse parâmetro é usado depende da implementação de IConvertible subjacente. Se value for um tipo de dados base, provider será usado apenas para as conversões a seguir. Se um argumento nullIFormatProvider for passado para esses métodos, o objeto CultureInfo que representa a cultura atual será usado.

• Conversão de um número para uma cadeia de caracteres ou de uma cadeia de caracteres para um número. provider deve ser um objeto CultureInfo, um objeto NumberFormatInfo ou uma implementação de IFormatProvider personalizada que retorna um objeto NumberFormatInfo. No entanto, como o método ChangeType(Object, TypeCode, IFormatProvider) executa a conversão usando o especificador de formato "G" padrão, o parâmetro provider não terá efeito se value ou o tipo de destino for um inteiro sem sinal.

• Conversão de um valor DateTime em uma cadeia de caracteres ou de uma cadeia de caracteres para um valor DateTime. provider deve ser um objeto CultureInfo ou DateTimeFormatInfo.

Se value for um tipo definido pelo aplicativo, sua implementação IConvertible poderá usar o parâmetro provider.