Convert.ToUInt32 Método

Definição

Namespace:

System

Assembly:

System.Runtime.dll

Converte um valor especificado em um inteiro sem sinal de 32 bits.

Sobrecargas

ToUInt32(String)	Converte a representação de cadeia de caracteres especificada de um número em um inteiro sem sinal de 32 bits equivalente.
ToUInt32(UInt64)	Converte o valor do inteiro sem sinal de 64 bits especificado em um inteiro sem sinal de 32 bits equivalente.
ToUInt32(UInt16)	Converte o valor do inteiro sem sinal de 16 bits especificado no inteiro sem sinal de 32 bits equivalente.
ToUInt32(UInt32)	Retorna o inteiro sem sinal de 32 bits especificado; nenhuma conversão real é executada.
ToUInt32(DateTime)	A chamada desse método sempre lança InvalidCastException.
ToUInt32(String, IFormatProvider)	Converte a representação de cadeia de caracteres especificada de um número em um inteiro sem sinal de 32 bits equivalente, usando as informações específicas à cultura especificadas.
ToUInt32(String, Int32)	Converte a representação de cadeia de caracteres de um número em uma base especificada em um inteiro sem sinal de 32 bits equivalente.
ToUInt32(Single)	Converte o valor do número de ponto flutuante de precisão simples especificado em um inteiro sem sinal de 32 bits equivalente.
ToUInt32(Object, IFormatProvider)	Converte o valor do objeto especificado em um inteiro sem sinal de 32 bits, usando as informações de formatação específicas da cultura especificada.
ToUInt32(SByte)	Converte o valor do inteiro com sinal de 8 bits especificado no inteiro sem sinal de 32 bits equivalente.
ToUInt32(Char)	Converte o valor do caractere Unicode especificado no inteiro sem sinal de 32 bits equivalente.
ToUInt32(Int64)	Converte o valor do inteiro com sinal de 64 bits especificado em um inteiro sem sinal de 32 bits equivalente.
ToUInt32(Int32)	Converte o valor do inteiro com sinal de 32 bits especificado em um inteiro sem sinal de 32 bits equivalente.
ToUInt32(Int16)	Converte o valor do inteiro com sinal de 16 bits especificado no inteiro sem sinal de 32 bits equivalente.
ToUInt32(Double)	Converte o valor do número de ponto flutuante de precisão dupla especificado em um inteiro sem sinal de 32 bits equivalente.
ToUInt32(Decimal)	Converte o valor do número decimal especificado em um inteiro sem sinal de 32 bits equivalente.
ToUInt32(Object)	Converte o valor do objeto especificado em um inteiro sem sinal de 32 bits.
ToUInt32(Byte)	Converte o valor do inteiro sem sinal de 8 bits especificado no inteiro sem sinal de 32 bits equivalente.
ToUInt32(Boolean)	Converte o valor booliano especificado no inteiro sem sinal de 32 bits equivalente.

ToUInt32(String)

Origem:

Convert.cs

Importante

Esta API não está em conformidade com CLS.

Converte a representação de cadeia de caracteres especificada de um número em um inteiro sem sinal de 32 bits equivalente.

C#

[System.CLSCompliant(false)]
public static uint ToUInt32 (string? value);

Parâmetros

value

String

Uma cadeia de caracteres que contém o número a ser convertido.

Retornos

UInt32

Um inteiro sem sinal de 32 bits equivalente ao número em value, ou 0 (zero), se value for null.

Atributos

CLSCompliantAttribute

Exceções

FormatException

value não consiste em um sinal opcional seguido de uma sequência de dígitos (de 0 a 9).

OverflowException

value representa um número menor que UInt32.MinValue ou maior que UInt32.MaxValue.

Exemplos

O exemplo a seguir interpreta os elementos em uma matriz de cadeias de caracteres como cadeias de caracteres numéricas e tenta convertê-los em inteiros sem sinal.

C#

string[] values = { "One", "1.34e28", "-26.87", "-18", "-6.00",
                    " 0", "137", "1601.9", Int32.MaxValue.ToString() };
uint result;

foreach (string value in values)
{
   try {
      result = Convert.ToUInt32(value);
      Console.WriteLine("Converted the {0} value '{1}' to the {2} value {3}.",
                        value.GetType().Name, value,
                        result.GetType().Name, result);
   }
   catch (OverflowException) {
      Console.WriteLine("The {0} value '{1}' is outside the range of the UInt32 type.",
                        value.GetType().Name, value);
   }
   catch (FormatException) {
      Console.WriteLine("The {0} value '{1}' is not in a recognizable format.",
                        value.GetType().Name, value);
   }
}
// The example displays the following output:
//    The String value 'One' is not in a recognizable format.
//    The String value '1.34e28' is not in a recognizable format.
//    The String value '-26.87' is not in a recognizable format.
//    The String value '-18' is outside the range of the UInt32 type.
//    The String value '-6.00' is not in a recognizable format.
//    Converted the String value ' 0' to the UInt32 value 0.
//    Converted the String value '137' to the UInt32 value 137.
//    The String value '1601.9' is not in a recognizable format.
//    Converted the String value '2147483647' to the UInt32 value 2147483647.

Comentários

Usar o ToUInt32(String) método é equivalente a passar value para o UInt32.Parse(String) método . value é interpretado usando as convenções de formatação da cultura atual.

Se preferir não manipular uma exceção se a conversão falhar, você poderá chamar o UInt32.TryParse método em vez disso. Ele retorna um valor Boolean que indica se a conversão foi bem-sucedida ou falhou.

ToUInt32(UInt64)

Origem:

Convert.cs

Importante

Esta API não está em conformidade com CLS.

Converte o valor do inteiro sem sinal de 64 bits especificado em um inteiro sem sinal de 32 bits equivalente.

C#

[System.CLSCompliant(false)]
public static uint ToUInt32 (ulong value);

Parâmetros

value

UInt64

O inteiro sem sinal de 64 bits a ser convertido.

Retornos

UInt32

Um inteiro sem sinal de 32 bits equivalente a value.

Atributos

CLSCompliantAttribute

Exceções

OverflowException

value é maior que UInt32.MaxValue.

Exemplos

O exemplo a seguir tenta converter cada elemento em uma matriz de inteiros longa sem sinal em um valor inteiro sem sinal.

C#

ulong[] numbers = { UInt64.MinValue, 121, 340, UInt64.MaxValue };
uint result;
foreach (ulong number in numbers)
{
   try {
      result = Convert.ToUInt32(number);
      Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
                        number.GetType().Name, number,
                        result.GetType().Name, result);
   }
   catch (OverflowException) {
      Console.WriteLine("The {0} value {1} is outside the range of the UInt32 type.",
                        number.GetType().Name, number);
   }
}
// The example displays the following output:
//    Converted the UInt64 value 0 to the UInt32 value 0.
//    Converted the UInt64 value 121 to the UInt32 value 121.
//    Converted the UInt64 value 340 to the UInt32 value 340.
//    The UInt64 value 18446744073709551615 is outside the range of the UInt32 type.

ToUInt32(UInt16)

Origem:

Convert.cs

Importante

Esta API não está em conformidade com CLS.

Converte o valor do inteiro sem sinal de 16 bits especificado no inteiro sem sinal de 32 bits equivalente.

C#

[System.CLSCompliant(false)]
public static uint ToUInt32 (ushort value);

Parâmetros

value

UInt16

O inteiro não assinado de 16 bits a ser convertido.

Retornos

UInt32

Um inteiro sem sinal de 32 bits equivalente a value.

Atributos

CLSCompliantAttribute

Exemplos

O exemplo a seguir converte cada elemento em uma matriz de inteiros de 16 bits sem sinal em um valor inteiro sem sinal.

C#

ushort[] numbers = { UInt16.MinValue, 121, 340, UInt16.MaxValue };
uint result;
foreach (ushort number in numbers)
{
   result = Convert.ToUInt32(number);
   Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
                     number.GetType().Name, number,
                     result.GetType().Name, result);
}
// The example displays the following output:
//    Converted the UInt16 value 0 to the UInt32 value 0.
//    Converted the UInt16 value 121 to the UInt32 value 121.
//    Converted the UInt16 value 340 to the UInt32 value 340.
//    Converted the UInt16 value 65535 to the UInt32 value 65535.

ToUInt32(UInt32)

Origem:

Convert.cs

Importante

Esta API não está em conformidade com CLS.

Retorna o inteiro sem sinal de 32 bits especificado; nenhuma conversão real é executada.

C#

[System.CLSCompliant(false)]
public static uint ToUInt32 (uint value);

Parâmetros

value

UInt32

O inteiro sem sinal de 32 bits a ser retornado.

Retornos

UInt32

value é retornado inalterado.

Atributos

CLSCompliantAttribute

ToUInt32(DateTime)

Origem:

Convert.cs

Importante

Esta API não está em conformidade com CLS.

A chamada desse método sempre lança InvalidCastException.

C#

[System.CLSCompliant(false)]
public static uint ToUInt32 (DateTime value);

Parâmetros

value

DateTime

O valor de data e tempo a ser convertido.

Retornos

UInt32

Não há suporte para esta conversão. Nenhum valor é retornado.

Atributos

CLSCompliantAttribute

Exceções

InvalidCastException

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

ToUInt32(String, IFormatProvider)

Origem:

Convert.cs

Importante

Esta API não está em conformidade com CLS.

Converte a representação de cadeia de caracteres especificada de um número em um inteiro sem sinal de 32 bits equivalente, usando as informações específicas à cultura especificadas.

C#

[System.CLSCompliant(false)]
public static uint ToUInt32 (string? value, IFormatProvider? provider);

Parâmetros

value

String

Uma cadeia de caracteres que contém o número a ser convertido.

provider

IFormatProvider

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

Retornos

UInt32

Um inteiro sem sinal de 32 bits equivalente ao número em value, ou 0 (zero), se value for null.

Atributos

CLSCompliantAttribute

Exceções

FormatException

value não consiste em um sinal opcional seguido de uma sequência de dígitos (de 0 a 9).

OverflowException

value representa um número menor que UInt32.MinValue ou maior que UInt32.MaxValue.

Exemplos

O exemplo a seguir define um objeto NumberFormatInfo personalizado que reconhece a cadeia de caracteres "pos" como o sinal positivo e a cadeia de caracteres "neg" como o sinal negativo. Em seguida, ele tenta converter cada elemento de uma matriz de cadeia de caracteres numérica em um inteiro usando esse provedor e o provedor NumberFormatInfo para a cultura invariável.

C#

using System;
using System.Globalization;

public class Class1
{
   public static void Main()
   {
      // Create a NumberFormatInfo object and set several of its
      // properties that apply to numbers.
      NumberFormatInfo provider = new NumberFormatInfo();
      provider.PositiveSign = "pos ";
      provider.NegativeSign = "neg ";

      // Define an array of numeric strings.
      string[] values = { "123456789", "+123456789", "pos 123456789",
                          "123456789.", "123,456,789",  "4294967295",
                          "4294967296", "-1", "neg 1" };

      foreach (string value in values)
      {
         Console.Write("{0,-20} -->", value);
         try {
            Console.WriteLine("{0,20}", Convert.ToUInt32(value, provider));
         }
         catch (FormatException) {
            Console.WriteLine("{0,20}", "Bad Format");
         }
         catch (OverflowException) {
            Console.WriteLine("{0,20}", "Numeric Overflow");
         }
      }
   }
}
// The example displays the following output:
//       123456789            -->           123456789
//       +123456789           -->          Bad Format
//       pos 123456789        -->           123456789
//       123456789.           -->          Bad Format
//       123,456,789          -->          Bad Format
//       4294967295           -->          4294967295
//       4294967296           -->    Numeric Overflow
//       -1                   -->          Bad Format
//       neg 1                -->    Numeric Overflow

Comentários

O valor retornado é o resultado da invocação UInt32.Parse em value.

provider é uma IFormatProvider instância que obtém um NumberFormatInfo objeto . O objeto NumberFormatInfo fornece informações específicas da cultura sobre o formato de value. Caso provider seja null, NumberFormatInfo da cultura atual é usado.

Se preferir não manipular uma exceção se a conversão falhar, você poderá chamar o UInt32.TryParse método em vez disso. Ele retorna um valor Boolean que indica se a conversão foi bem-sucedida ou falhou.

ToUInt32(String, Int32)

Origem:

Convert.cs

Importante

Esta API não está em conformidade com CLS.

Converte a representação de cadeia de caracteres de um número em uma base especificada em um inteiro sem sinal de 32 bits equivalente.

C#

[System.CLSCompliant(false)]
public static uint ToUInt32 (string? value, int fromBase);

Parâmetros

value

String

Uma cadeia de caracteres que contém o número a ser convertido.

fromBase

Int32

A base do número em value, que deve ser 2, 8, 10 ou 16.

Retornos

UInt32

Um inteiro sem sinal de 32 bits equivalente ao número em value, ou 0 (zero), se value for null.

Atributos

CLSCompliantAttribute

Exceções

ArgumentException

fromBase não é 2, 8, 10 ou 16.

- ou -

value, que representa um número não assinado de base não 10, é prefixado com um sinal negativo.

ArgumentOutOfRangeException

value é Empty.

FormatException

value contém um caractere que não é um dígito válido na base especificada por fromBase. A mensagem de exceção indica que não há dígitos a serem convertidos caso o primeiro caractere em value seja inválido; do contrário, a mensagem indica que value contém caracteres à direita inválidos.

OverflowException

value, que representa um número não assinado de base não 10, é prefixado com um sinal negativo.

- ou -

value representa um número menor que UInt32.MinValue ou maior que UInt32.MaxValue.

Exemplos

O exemplo a seguir tenta interpretar cada elemento em uma matriz de cadeias de caracteres numéricas como um valor hexadecimal e convertê-lo em um inteiro sem sinal.

C#

using System;

public class Example
{
   public static void Main()
   {
      string[] hexStrings = { "80000000", "0FFFFFFF", "F0000000", "00A3000", "D",
                              "-13", "9AC61", "GAD", "FFFFFFFFFF" };

      foreach (string hexString in hexStrings)
      {
         Console.Write("{0,-12}  -->  ", hexString);
         try {
            uint number = Convert.ToUInt32(hexString, 16);
            Console.WriteLine("{0,18:N0}", number);
         }
         catch (FormatException) {
            Console.WriteLine("{0,18}", "Bad Format");
         }
         catch (OverflowException)
         {
            Console.WriteLine("{0,18}", "Numeric Overflow");
         }
         catch (ArgumentException) {
            Console.WriteLine("{0,18}", "Invalid in Base 16");
         }
      }
   }
}
// The example displays the following output:
//       80000000      -->       2,147,483,648
//       0FFFFFFF      -->         268,435,455
//       F0000000      -->       4,026,531,840
//       00A3000       -->             667,648
//       D             -->                  13
//       -13           -->  Invalid in Base 16
//       9AC61         -->             633,953
//       GAD           -->          Bad Format
//       FFFFFFFFFF    -->    Numeric Overflow

Comentários

Caso fromBase seja 16, é possível prefixar o número especificado pelo parâmetro value com "0x" ou "0X".

Como o UInt32 tipo de dados dá suporte apenas a valores não assinados, o ToUInt32(String, Int32) método pressupõe que value seja expresso usando uma representação binária não assinada. Em outras palavras, todos os 32 bits são usados para representar o valor numérico e um bit de sinal está ausente. Como resultado, é possível escrever um código no qual um valor inteiro com sinal que está fora do intervalo do tipo de UInt32 dados é convertido em um UInt32 valor sem que o método gere uma exceção. O exemplo a seguir converte em sua representação de cadeia de caracteres MinValue hexadecimal e, em seguida, chama o ToUInt32(String, Int32) método . Em vez de gerar uma exceção, o método exibe a mensagem "0x80000000 converte em 2147483648".

C#

// Create a hexadecimal value out of range of the UInt32 type.
string value = Convert.ToString(Int32.MinValue, 16);
// Convert it back to a number.
try
{
   UInt32 number = Convert.ToUInt32(value, 16);
   Console.WriteLine("0x{0} converts to {1}.", value, number);
}
catch (OverflowException)
{
   Console.WriteLine("Unable to convert '0x{0}' to an unsigned integer.",
                     value);
}

Durante a realização de operações binárias ou conversões numéricas, sempre é responsabilidade do desenvolvedor verificar se um método ou operador está usando a representação numérica apropriada para interpretar um valor específico. O exemplo a seguir ilustra uma técnica para garantir que o método não use inadequadamente a representação binária para interpretar um valor que usa a representação complementar de dois ao converter uma cadeia de caracteres hexadecimal em um UInt32 valor. O exemplo determina se um valor representa um inteiro assinado ou não assinado enquanto converte esse valor na representação da cadeia de caracteres. Quando o exemplo converte o valor em um UInt32 valor, ele verifica se o valor original era um inteiro com sinal. Nesse caso, e se seu bit de ordem alta for definido (o que indica que o valor original foi negativo), o método gerará uma exceção.

C#

// Create a negative hexadecimal value out of range of the UInt32 type.
int sourceNumber = Int32.MinValue;
bool isSigned = Math.Sign((int)sourceNumber.GetType().GetField("MinValue").GetValue(null)) == -1;
string value = Convert.ToString(sourceNumber, 16);
UInt32 targetNumber;
try
{
   targetNumber = Convert.ToUInt32(value, 16);
   if (isSigned && ((targetNumber & 0x80000000) != 0))
      throw new OverflowException();
   else
      Console.WriteLine("0x{0} converts to {1}.", value, targetNumber);
}
catch (OverflowException)
{
   Console.WriteLine("Unable to convert '0x{0}' to an unsigned integer.",
                     value);
}
// Displays the following to the console:
//    Unable to convert '0x80000000' to an unsigned integer.

ToUInt32(Single)

Origem:

Convert.cs

Importante

Esta API não está em conformidade com CLS.

Converte o valor do número de ponto flutuante de precisão simples especificado em um inteiro sem sinal de 32 bits equivalente.

C#

[System.CLSCompliant(false)]
public static uint ToUInt32 (float value);

Parâmetros

value

Single

O número de ponto flutuante de precisão simples a ser convertido.

Retornos

UInt32

value, arredondado para o próximo inteiro sem sinal de 32 bits. Caso value esteja entre dois números inteiros, o número par é retornado; ou seja, 4,5 é convertido em 4 e 5,5 é convertido em 6.

Atributos

CLSCompliantAttribute

Exceções

OverflowException

value é menor que zero ou maior que UInt32.MaxValue.

Exemplos

O exemplo a seguir tenta converter cada elemento em uma matriz de Single valores em um inteiro sem sinal.

C#

float[] values= { Single.MinValue, -1.38e10f, -1023.299f, -12.98f,
                  0f, 9.113e-16f, 103.919f, 17834.191f, Single.MaxValue };
uint result;

foreach (float value in values)
{
   try {
      result = Convert.ToUInt32(value);
      Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
                        value.GetType().Name, value,
                        result.GetType().Name, result);
   }
   catch (OverflowException) {
      Console.WriteLine("The {0} value {1} is outside the range of the UInt32 type.",
                        value.GetType().Name, value);
   }
}
// The example displays the following output:
//    The Single value -3.402823E+38 is outside the range of the UInt32 type.
//    The Single value -1.38E+10 is outside the range of the UInt32 type.
//    The Single value -1023.299 is outside the range of the UInt32 type.
//    The Single value -12.98 is outside the range of the UInt32 type.
//    Converted the Single value 0 to the UInt32 value 0.
//    Converted the Single value 9.113E-16 to the UInt32 value 0.
//    Converted the Single value 103.919 to the UInt32 value 104.
//    Converted the Single value 17834.19 to the UInt32 value 17834.
//    The Single value 3.402823E+38 is outside the range of the UInt32 type.

Confira também

• Single
• Round

ToUInt32(Object, IFormatProvider)

Origem:

Convert.cs

Importante

Esta API não está em conformidade com CLS.

Converte o valor do objeto especificado em um inteiro sem sinal de 32 bits, usando as informações de formatação específicas da cultura especificada.

C#

[System.CLSCompliant(false)]
public static uint ToUInt32 (object? value, IFormatProvider? provider);

Parâmetros

value

Object

Um objeto que implementa a interface do IConvertible.

provider

IFormatProvider

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

Retornos

UInt32

Um inteiro sem sinal de 32 bits equivalente a value ou zero caso value seja null.

Atributos

CLSCompliantAttribute

Exceções

FormatException

value não está em um formato adequado.

InvalidCastException

value não implementa a interface IConvertible.

- ou -

A conversão não é suportada.

OverflowException

value representa um número menor que UInt32.MinValue ou maior que UInt32.MaxValue.

Exemplos

O exemplo a seguir define uma HexString classe que implementa a IConvertible interface e que foi projetada para manter a representação de cadeia de caracteres de valores assinados de 32 bits e sem sinal de 32 bits. A classe inclui uma Sign propriedade que indica o sinal de seu valor hexadecimal.

C#

using System;
using System.Globalization;
using System.Text.RegularExpressions;

public enum SignBit { Negative=-1, Zero=0, Positive=1 };

public struct HexString : IConvertible
{
   private SignBit signBit;
   private string hexString;

   public SignBit Sign
   {
      set { signBit = value; }
      get { return signBit; }
   }

   public string Value
   {
      set {
         if (value.Trim().Length > 8)
            throw new ArgumentException("The string representation of a 32-bit integer cannot have more than 8 characters.");
         else if (! Regex.IsMatch(value, "([0-9,A-F]){1,8}", RegexOptions.IgnoreCase))
            throw new ArgumentException("The hexadecimal representation of a 32-bit integer contains invalid characters.");
         else
            hexString = value;
      }
      get { return hexString; }
   }

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

   public bool ToBoolean(IFormatProvider provider)
   {
      return signBit != SignBit.Zero;
   }

   public byte ToByte(IFormatProvider provider)
   {
      if (signBit == SignBit.Negative)
         throw new OverflowException(String.Format("{0} is out of range of the Byte type.", Convert.ToInt32(hexString, 16)));
      else
         try {
            return Byte.Parse(hexString, NumberStyles.HexNumber);
         }
         catch (OverflowException e) {
            throw new OverflowException(String.Format("{0} is out of range of the Byte type.", Convert.ToUInt32(hexString, 16)), e);
         }
   }

   public char ToChar(IFormatProvider provider)
   {
      if (signBit == SignBit.Negative)
         throw new OverflowException(String.Format("{0} is out of range of the Char type.", Convert.ToInt32(hexString, 16)));

      try {
         ushort codePoint = UInt16.Parse(this.hexString, NumberStyles.HexNumber);
         return Convert.ToChar(codePoint);
      }
      catch (OverflowException e) {
         throw new OverflowException(String.Format("{0} is out of range of the Char type.", Convert.ToUInt32(hexString, 16)), e);
      }
   }

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

   public decimal ToDecimal(IFormatProvider provider)
   {
      if (signBit == SignBit.Negative)
      {
         int hexValue = Int32.Parse(hexString, NumberStyles.HexNumber);
         return Convert.ToDecimal(hexValue);
      }
      else
      {
         uint hexValue = UInt32.Parse(hexString, NumberStyles.HexNumber);
         return Convert.ToDecimal(hexValue);
      }
   }

   public double ToDouble(IFormatProvider provider)
   {
      if (signBit == SignBit.Negative)
         return Convert.ToDouble(Int32.Parse(hexString, NumberStyles.HexNumber));
      else
         return Convert.ToDouble(UInt32.Parse(hexString, NumberStyles.HexNumber));
   }

   public short ToInt16(IFormatProvider provider)
   {
      if (signBit == SignBit.Negative)
         try {
            return Convert.ToInt16(Int32.Parse(hexString, NumberStyles.HexNumber));
         }
         catch (OverflowException e) {
            throw new OverflowException(String.Format("{0} is out of range of the Int16 type.", Convert.ToInt32(hexString, 16)), e);
         }
      else
         try {
            return Convert.ToInt16(UInt32.Parse(hexString, NumberStyles.HexNumber));
         }
         catch (OverflowException e) {
            throw new OverflowException(String.Format("{0} is out of range of the Int16 type.", Convert.ToUInt32(hexString, 16)), e);
         }
   }

   public int ToInt32(IFormatProvider provider)
   {
      if (signBit == SignBit.Negative)
         return Int32.Parse(hexString, NumberStyles.HexNumber);
      else
         try {
            return Convert.ToInt32(UInt32.Parse(hexString, NumberStyles.HexNumber));
         }
         catch (OverflowException e) {
            throw new OverflowException(String.Format("{0} is out of range of the Int32 type.", Convert.ToUInt32(hexString, 16)), e);
         }
   }

   public long ToInt64(IFormatProvider provider)
   {
      if (signBit == SignBit.Negative)
         return Convert.ToInt64(Int32.Parse(hexString, NumberStyles.HexNumber));
      else
         return Int64.Parse(hexString, NumberStyles.HexNumber);
   }

   public sbyte ToSByte(IFormatProvider provider)
   {
      if (signBit == SignBit.Negative)
         try {
            return Convert.ToSByte(Int32.Parse(hexString, NumberStyles.HexNumber));
         }
         catch (OverflowException e) {
            throw new OverflowException(String.Format("{0} is outside the range of the SByte type.",
                                                      Int32.Parse(hexString, NumberStyles.HexNumber), e));
         }
      else
         try {
            return Convert.ToSByte(UInt32.Parse(hexString, NumberStyles.HexNumber));
         }
         catch (OverflowException e) {
            throw new OverflowException(String.Format("{0} is outside the range of the SByte type.",
                                                    UInt32.Parse(hexString, NumberStyles.HexNumber)), e);
         }
   }

   public float ToSingle(IFormatProvider provider)
   {
      if (signBit == SignBit.Negative)
         return Convert.ToSingle(Int32.Parse(hexString, NumberStyles.HexNumber));
      else
         return Convert.ToSingle(UInt32.Parse(hexString, NumberStyles.HexNumber));
   }

   public string ToString(IFormatProvider provider)
   {
      return "0x" + this.hexString;
   }

   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(HexString).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(null);
         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 (signBit == SignBit.Negative)
         throw new OverflowException(String.Format("{0} is outside the range of the UInt16 type.",
                                                   Int32.Parse(hexString, NumberStyles.HexNumber)));
      else
         try {
            return Convert.ToUInt16(UInt32.Parse(hexString, NumberStyles.HexNumber));
         }
         catch (OverflowException e) {
            throw new OverflowException(String.Format("{0} is out of range of the UInt16 type.", Convert.ToUInt32(hexString, 16)), e);
         }
   }

   public uint ToUInt32(IFormatProvider provider)
   {
      if (signBit == SignBit.Negative)
         throw new OverflowException(String.Format("{0} is outside the range of the UInt32 type.",
                                                   Int32.Parse(hexString, NumberStyles.HexNumber)));
      else
         return Convert.ToUInt32(hexString, 16);
   }

   public ulong ToUInt64(IFormatProvider provider)
   {
      if (signBit == SignBit.Negative)
         throw new OverflowException(String.Format("{0} is outside the range of the UInt64 type.",
                                                   Int32.Parse(hexString, NumberStyles.HexNumber)));
      else
         return Convert.ToUInt64(hexString, 16);
   }
}

O exemplo a seguir mostra que uma chamada para o ToUInt32(Object, IFormatProvider) método que passa um HexString objeto como um parâmetro, por sua vez, chama a IConvertible.ToUInt32 implementação da HexString classe .

C#

public class Example
{
   public static void Main()
   {
      uint positiveValue = 320000000;
      int negativeValue = -1;

      HexString positiveString = new HexString();
      positiveString.Sign = (SignBit) Math.Sign(positiveValue);
      positiveString.Value = positiveValue.ToString("X4");

      HexString negativeString = new HexString();
      negativeString.Sign = (SignBit) Math.Sign(negativeValue);
      negativeString.Value = negativeValue.ToString("X4");

      try {
         Console.WriteLine("0x{0} converts to {1}.", positiveString.Value, Convert.ToUInt32(positiveString));
      }
      catch (OverflowException) {
         Console.WriteLine("{0} is outside the range of the UInt32 type.",
                           Int32.Parse(positiveString.Value, NumberStyles.HexNumber));
      }

      try {
         Console.WriteLine("0x{0} converts to {1}.", negativeString.Value, Convert.ToUInt32(negativeString));
      }
      catch (OverflowException) {
         Console.WriteLine("{0} is outside the range of the UInt32 type.",
                           Int32.Parse(negativeString.Value, NumberStyles.HexNumber));
      }
   }
}
// The example dosplays the following output:
//       0x1312D000 converts to 320000000.
//       -1 is outside the range of the UInt32 type.

Comentários

O valor retornado é o resultado da invocação do IConvertible.ToUInt32 método do tipo subjacente de value.

provider permite que o usuário especifique informações de conversão específicas da cultura sobre o conteúdo de value. Por exemplo, se value fosse um String que representa um número, provider poderia fornecer informações específicas de cultura sobre a notação usada para representar esse número.

Os tipos de base ignoram provider; no entanto, o parâmetro pode ser usado caso value seja um tipo definido pelo usuário que implementa a interface IConvertible.

ToUInt32(SByte)

Origem:

Convert.cs

Importante

Esta API não está em conformidade com CLS.

Converte o valor do inteiro com sinal de 8 bits especificado no inteiro sem sinal de 32 bits equivalente.

C#

[System.CLSCompliant(false)]
public static uint ToUInt32 (sbyte value);

Parâmetros

value

SByte

O inteiro com sinal de 8 bits a ser convertido.

Retornos

UInt32

Um inteiro sem sinal de 32 bits equivalente a value.

Atributos

CLSCompliantAttribute

Exceções

OverflowException

value é menor que zero.

Exemplos

O exemplo a seguir tenta converter cada elemento em uma matriz de bytes com sinal em um inteiro sem sinal.

C#

sbyte[] numbers = { SByte.MinValue, -1, 0, 10, SByte.MaxValue };
uint result;

foreach (sbyte number in numbers)
{
   try {
      result = Convert.ToUInt32(number);
      Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
                        number.GetType().Name, number,
                        result.GetType().Name, result);
   }
   catch (OverflowException) {
      Console.WriteLine("The {0} value {1} is outside the range of the UInt32 type.",
                        number.GetType().Name, number);
   }
}
// The example displays the following output:
//    The SByte value -128 is outside the range of the UInt32 type.
//    The SByte value -1 is outside the range of the UInt32 type.
//    Converted the SByte value 0 to the UInt32 value 0.
//    Converted the SByte value 10 to the UInt32 value 10.
//    Converted the SByte value 127 to the UInt32 value 127.

ToUInt32(Char)

Origem:

Convert.cs

Importante

Esta API não está em conformidade com CLS.

Converte o valor do caractere Unicode especificado no inteiro sem sinal de 32 bits equivalente.

C#

[System.CLSCompliant(false)]
public static uint ToUInt32 (char value);

Parâmetros

value

Char

O caractere Unicode a ser convertido.

Retornos

UInt32

Um inteiro sem sinal de 32 bits equivalente a value.

Atributos

CLSCompliantAttribute

Exemplos

O exemplo a seguir converte cada elemento em uma matriz de caracteres em um inteiro sem sinal.

C#

char[] chars = { 'a', 'z', '\u0007', '\u03FF',
                 '\u7FFF', '\uFFFE' };
uint result;

foreach (char ch in chars)
{
   result = Convert.ToUInt32(ch);
   Console.WriteLine("Converted the {0} value '{1}' to the {2} value {3}.",
                     ch.GetType().Name, ch,
                     result.GetType().Name, result);
}
// The example displays the following output:
//    Converted the Char value 'a' to the UInt32 value 97.
//    Converted the Char value 'z' to the UInt32 value 122.
//    Converted the Char value '' to the UInt32 value 7.
//    Converted the Char value 'Ͽ' to the UInt32 value 1023.
//    Converted the Char value '翿' to the UInt32 value 32767.
//    Converted the Char value '' to the UInt32 value 65534.

ToUInt32(Int64)

Origem:

Convert.cs

Importante

Esta API não está em conformidade com CLS.

Converte o valor do inteiro com sinal de 64 bits especificado em um inteiro sem sinal de 32 bits equivalente.

C#

[System.CLSCompliant(false)]
public static uint ToUInt32 (long value);

Parâmetros

value

Int64

O inteiro com sinal de 64 bits a ser convertido.

Retornos

UInt32

Um inteiro sem sinal de 32 bits equivalente a value.

Atributos

CLSCompliantAttribute

Exceções

OverflowException

value é menor que zero ou maior que UInt32.MaxValue.

Exemplos

O exemplo a seguir tenta converter cada elemento em uma matriz de inteiros longos em um inteiro sem sinal.

C#

long[] numbers = { Int64.MinValue, -1, 0, 121, 340, Int64.MaxValue };
uint result;
foreach (long number in numbers)
{
   try {
      result = Convert.ToUInt32(number);
      Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
                        number.GetType().Name, number,
                        result.GetType().Name, result);
   }
   catch (OverflowException) {
      Console.WriteLine("The {0} value {1} is outside the range of the UInt32 type.",
                        number.GetType().Name, number);
   }
}
// The example displays the following output:
//    The Int64 value -9223372036854775808 is outside the range of the UInt32 type.
//    The Int64 value -1 is outside the range of the UInt32 type.
//    Converted the Int64 value 0 to the UInt32 value 0.
//    Converted the Int64 value 121 to the UInt32 value 121.
//    Converted the Int64 value 340 to the UInt32 value 340.
//    The Int64 value 9223372036854775807 is outside the range of the UInt32 type.

ToUInt32(Int32)

Origem:

Convert.cs

Importante

Esta API não está em conformidade com CLS.

Converte o valor do inteiro com sinal de 32 bits especificado em um inteiro sem sinal de 32 bits equivalente.

C#

[System.CLSCompliant(false)]
public static uint ToUInt32 (int value);

Parâmetros

value

Int32

O inteiro com sinal de 32 bits a converter.

Retornos

UInt32

Um inteiro sem sinal de 32 bits equivalente a value.

Atributos

CLSCompliantAttribute

Exceções

OverflowException

value é menor que zero.

Exemplos

O exemplo a seguir tenta converter cada elemento em uma matriz de inteiros em um inteiro sem sinal.

C#

int[] numbers = { Int32.MinValue, -1203, 0, 121, 1340, Int32.MaxValue };
uint result;
foreach (int number in numbers)
{
   try {
      result = Convert.ToUInt32(number);
      Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
                        number.GetType().Name, number,
                        result.GetType().Name, result);
   }
   catch (OverflowException) {
      Console.WriteLine("The {0} value {1} is outside the range of the UInt32 type.",
                        number.GetType().Name, number);
   }
}
// The example displays the following output:
//    The Int32 value -2147483648 is outside the range of the UInt32 type.
//    The Int32 value -1203 is outside the range of the UInt32 type.
//    Converted the Int32 value 0 to the UInt32 value 0.
//    Converted the Int32 value 121 to the UInt32 value 121.
//    Converted the Int32 value 1340 to the UInt32 value 1340.
//    Converted the Int32 value 2147483647 to the UInt32 value 2147483647.

ToUInt32(Int16)

Origem:

Convert.cs

Importante

Esta API não está em conformidade com CLS.

Converte o valor do inteiro com sinal de 16 bits especificado no inteiro sem sinal de 32 bits equivalente.

C#

[System.CLSCompliant(false)]
public static uint ToUInt32 (short value);

Parâmetros

value

Int16

O inteiro assinado de 16 bits a ser convertido.

Retornos

UInt32

Um inteiro sem sinal de 32 bits equivalente a value.

Atributos

CLSCompliantAttribute

Exceções

OverflowException

value é menor que zero.

Exemplos

O exemplo a seguir tenta converter cada elemento em uma matriz de inteiros de 16 bits em um inteiro sem sinal.

C#

short[] numbers= { Int16.MinValue, -1, 0, 121, 340, Int16.MaxValue };
uint result;

foreach (short number in numbers)
{
   try {
      result = Convert.ToUInt32(number);
      Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
                           number.GetType().Name, number,
                           result.GetType().Name, result);
   }
   catch (OverflowException) {
      Console.WriteLine("The {0} value {1} is outside the range of the UInt32 type.",
                        number.GetType().Name, number);
   }
}
// The example displays the following output:
//    The Int16 value -32768 is outside the range of the UInt32 type.
//    The Int16 value -1 is outside the range of the UInt32 type.
//    Converted the Int16 value 0 to the UInt32 value 0.
//    Converted the Int16 value 121 to the UInt32 value 121.
//    Converted the Int16 value 340 to the UInt32 value 340.
//    Converted the Int16 value 32767 to the UInt32 value 32767.

ToUInt32(Double)

Origem:

Convert.cs

Importante

Esta API não está em conformidade com CLS.

Converte o valor do número de ponto flutuante de precisão dupla especificado em um inteiro sem sinal de 32 bits equivalente.

C#

[System.CLSCompliant(false)]
public static uint ToUInt32 (double value);

Parâmetros

value

Double

O número de ponto flutuante de precisão dupla a ser convertido.

Retornos

UInt32

value, arredondado para o próximo inteiro sem sinal de 32 bits. Caso value esteja entre dois números inteiros, o número par é retornado; ou seja, 4,5 é convertido em 4 e 5,5 é convertido em 6.

Atributos

CLSCompliantAttribute

Exceções

OverflowException

value é menor que zero ou maior que UInt32.MaxValue.

Exemplos

O exemplo a seguir tenta converter cada elemento em uma matriz de Double valores em um inteiro sem sinal.

C#

double[] values= { Double.MinValue, -1.38e10, -1023.299, -12.98,
                   0, 9.113e-16, 103.919, 17834.191, Double.MaxValue };
uint result;

foreach (double value in values)
{
   try {
      result = Convert.ToUInt32(value);
      Console.WriteLine("Converted the {0} value '{1}' to the {2} value {3}.",
                        value.GetType().Name, value,
                        result.GetType().Name, result);
   }
   catch (OverflowException) {
      Console.WriteLine("The {0} value {1} is outside the range of the UInt32 type.",
                        value.GetType().Name, value);
   }
}
// The example displays the following output:
//    The Double value -1.79769313486232E+308 is outside the range of the UInt32 type.
//    The Double value -13800000000 is outside the range of the UInt32 type.
//    The Double value -1023.299 is outside the range of the UInt32 type.
//    The Double value -12.98 is outside the range of the UInt32 type.
//    Converted the Double value '0' to the UInt32 value 0.
//    Converted the Double value '9.113E-16' to the UInt32 value 0.
//    Converted the Double value '103.919' to the UInt32 value 104.
//    Converted the Double value '17834.191' to the UInt32 value 17834.
//    The Double value 1.79769313486232E+308 is outside the range of the UInt32 type.

Confira também

• Double
• Round

ToUInt32(Decimal)

Origem:

Convert.cs

Importante

Esta API não está em conformidade com CLS.

Converte o valor do número decimal especificado em um inteiro sem sinal de 32 bits equivalente.

C#

[System.CLSCompliant(false)]
public static uint ToUInt32 (decimal value);

Parâmetros

value

Decimal

O número decimal a ser convertido.

Retornos

UInt32

value, arredondado para o próximo inteiro sem sinal de 32 bits. Caso value esteja entre dois números inteiros, o número par é retornado; ou seja, 4,5 é convertido em 4 e 5,5 é convertido em 6.

Atributos

CLSCompliantAttribute

Exceções

OverflowException

value é menor que zero ou maior que UInt32.MaxValue.

Exemplos

O exemplo a seguir tenta converter cada elemento em uma matriz de Decimal valores em um inteiro sem sinal.

C#

decimal[] values= { Decimal.MinValue, -1034.23m, -12m, 0m, 147m,
                    199.55m, 9214.16m, Decimal.MaxValue };
uint result;

foreach (decimal value in values)
{
   try {
      result = Convert.ToUInt32(value);
      Console.WriteLine("Converted the {0} value '{1}' to the {2} value {3}.",
                        value.GetType().Name, value,
                        result.GetType().Name, result);
   }
   catch (OverflowException) {
      Console.WriteLine("The {0} value {1} is outside the range of the UInt32 type.",
                        value.GetType().Name, value);
   }
}
// The example displays the following output:
//    The Decimal value -79228162514264337593543950335 is outside the range of the UInt32 type.
//    The Decimal value -1034.23 is outside the range of the UInt32 type.
//    The Decimal value -12 is outside the range of the UInt32 type.
//    Converted the Decimal value '0' to the UInt32 value 0.
//    Converted the Decimal value '147' to the UInt32 value 147.
//    Converted the Decimal value '199.55' to the UInt32 value 200.
//    Converted the Decimal value '9214.16' to the UInt32 value 9214.
//    The Decimal value 79228162514264337593543950335 is outside the range of the UInt32 type.

Confira também

• Round

ToUInt32(Object)

Origem:

Convert.cs

Importante

Esta API não está em conformidade com CLS.

Converte o valor do objeto especificado em um inteiro sem sinal de 32 bits.

C#

[System.CLSCompliant(false)]
public static uint ToUInt32 (object? value);

Parâmetros

value

Object

Um objeto que implementa a interface IConvertible ou null.

Retornos

UInt32

Um inteiro sem sinal de 32 bits equivalente a value ou 0 (zero), se value for null.

Atributos

CLSCompliantAttribute

Exceções

FormatException

value não está em um formato adequado.

InvalidCastException

value não implementa a interface IConvertible.

- ou -

A conversão não é suportada.

OverflowException

value representa um número menor que UInt32.MinValue ou maior que UInt32.MaxValue.

Exemplos

O exemplo a seguir tenta converter cada elemento em uma matriz de objetos em um inteiro sem sinal.

C#

object[] values = { true, -12, 163, 935, 'x', new DateTime(2009, 5, 12),
                    "104", "103.0", "-1",
                    "1.00e2", "One", 1.00e2, 16.3e42};
uint result;

foreach (object value in values)
{
   try {
      result = Convert.ToUInt32(value);
      Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
                        value.GetType().Name, value,
                        result.GetType().Name, result);
   }
   catch (OverflowException) {
      Console.WriteLine("The {0} value '{1}' is outside the range of the UInt32 type.",
                        value.GetType().Name, value);
   }
   catch (FormatException) {
      Console.WriteLine("The {0} value {1} is not in a recognizable format.",
                        value.GetType().Name, value);
   }
   catch (InvalidCastException) {
      Console.WriteLine("No conversion to a UInt32 exists for the {0} value '{1}'.",
                        value.GetType().Name, value);
   }
}
// The example displays the following output:
//    Converted the Boolean value True to the UInt32 value 1.
//    The Int32 value '-12' is outside the range of the UInt32 type.
//    Converted the Int32 value 163 to the UInt32 value 163.
//    Converted the Int32 value 935 to the UInt32 value 935.
//    Converted the Char value x to the UInt32 value 120.
//    No conversion to a UInt32 exists for the DateTime value '5/12/2009 12:00:00 AM'.
//    Converted the String value 104 to the UInt32 value 104.
//    The String value 103.0 is not in a recognizable format.
//    The String value '-1' is outside the range of the UInt32 type.
//    The String value 1.00e2 is not in a recognizable format.
//    The String value One is not in a recognizable format.
//    Converted the Double value 100 to the UInt32 value 100.
//    The Double value '1.63E+43' is outside the range of the UInt32 type.

Comentários

O valor retornado é o resultado da invocação do IConvertible.ToUInt32 método do tipo subjacente de value.

ToUInt32(Byte)

Origem:

Convert.cs

Importante

Esta API não está em conformidade com CLS.

Converte o valor do inteiro sem sinal de 8 bits especificado no inteiro sem sinal de 32 bits equivalente.

C#

[System.CLSCompliant(false)]
public static uint ToUInt32 (byte value);

Parâmetros

value

Byte

O inteiro sem sinal de 8 bits a ser convertido.

Retornos

UInt32

Um inteiro sem sinal de 32 bits equivalente a value.

Atributos

CLSCompliantAttribute

Exemplos

O exemplo a seguir converte cada elemento em uma matriz de bytes em um inteiro sem sinal.

C#

byte[] bytes = { Byte.MinValue, 14, 122, Byte.MaxValue};
uint result;

foreach (byte byteValue in bytes)
{
   result = Convert.ToUInt32(byteValue);
   Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
                     byteValue.GetType().Name, byteValue,
                     result.GetType().Name, result);
}
// The example displays the following output:
//    Converted the Byte value 0 to the UInt32 value 0.
//    Converted the Byte value 14 to the UInt32 value 14.
//    Converted the Byte value 122 to the UInt32 value 122.
//    Converted the Byte value 255 to the UInt32 value 255.

ToUInt32(Boolean)

Origem:

Convert.cs

Importante

Esta API não está em conformidade com CLS.

Converte o valor booliano especificado no inteiro sem sinal de 32 bits equivalente.

C#

[System.CLSCompliant(false)]
public static uint ToUInt32 (bool value);

Parâmetros

value

Boolean

O valor booliano a ser convertido.

Retornos

UInt32

O número 1 caso value seja true; do contrário, 0.

Atributos

CLSCompliantAttribute

Exemplos

O exemplo a seguir converte os valores boolianos true e false em inteiros sem sinal.

C#

bool falseFlag = false;
bool trueFlag = true;

Console.WriteLine("{0} converts to {1}.", falseFlag,
                  Convert.ToUInt32(falseFlag));
Console.WriteLine("{0} converts to {1}.", trueFlag,
                  Convert.ToUInt32(trueFlag));
// The example displays the following output:
//       False converts to 0.
//       True converts to 1.