Ler em inglês

Compartilhar via

Convert.ToUInt16 Método

  • Referência

Definição

Namespace:
System
Assembly:
System.Runtime.Extensions.dll
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

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

Sobrecargas

ToUInt16(String)

Converte a representação de cadeia de caracteres especificada de um número em um inteiro sem sinal de 16 bits equivalente.
ToUInt16(UInt16)

Retorna o inteiro sem sinal de 16 bits especificado; nenhuma conversão real é executada.
ToUInt16(UInt32)

Converte o valor do inteiro sem sinal de 32 bits especificado em um inteiro sem sinal de 16 bits equivalente.
ToUInt16(String, Int32)

Converte a representação de cadeia de caracteres de um número em uma base especificada em um inteiro sem sinal de 16 bits equivalente.
ToUInt16(Object, IFormatProvider)

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

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

Converte o valor do número de ponto flutuante de precisão simples especificado em um inteiro sem sinal de 16 bits equivalente.
ToUInt16(UInt64)

Converte o valor do inteiro sem sinal de 64 bits especificado em um inteiro sem sinal de 16 bits equivalente.
ToUInt16(SByte)

Converte o valor do inteiro com sinal de 8 bits especificado no inteiro sem sinal de 16 bits equivalente.
ToUInt16(Char)

Converte o valor do caractere Unicode especificado no inteiro sem sinal de 16 bits equivalente.
ToUInt16(Int64)

Converte o valor do inteiro com sinal de 64 bits especificado em um inteiro sem sinal de 16 bits equivalente.
ToUInt16(Int32)

Converte o valor do inteiro com sinal de 32 bits especificado em um inteiro sem sinal de 16 bits equivalente.
ToUInt16(Int16)

Converte o valor do inteiro com sinal de 16 bits especificado no inteiro sem sinal de 16 bits equivalente.
ToUInt16(Decimal)

Converte o valor do número decimal especificado em um inteiro sem sinal de 16 bits equivalente.
ToUInt16(DateTime)

A chamada desse método sempre lança InvalidCastException.
ToUInt16(Byte)

Converte o valor do inteiro sem sinal de 8 bits especificado no inteiro sem sinal de 16 bits equivalente.
ToUInt16(Boolean)

Converte o valor booliano especificado no inteiro sem sinal de 16 bits equivalente.
ToUInt16(Object)

Converte o valor do objeto especificado em um inteiro sem sinal de 16 bits.
ToUInt16(Double)

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

ToUInt16(String)

Origem:
Convert.cs
Origem:
Convert.cs
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 16 bits equivalente.

[System.CLSCompliant(false)]
public static ushort ToUInt16 (string value);
[System.CLSCompliant(false)]
public static ushort ToUInt16 (string? value);

Parâmetros

value
String

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

Retornos

UInt16

Um inteiro sem sinal de 16 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 UInt16.MinValue ou maior que UInt16.MaxValue.

Exemplos

O exemplo a seguir tenta converter cada elemento em uma matriz de cadeia de caracteres numérica em um inteiro sem sinal de 16 bits.

string[] values = { "1603", "1,603", "one", "1.6e03", "1.2e-02",
                    "-1326", "1074122" };
ushort result;

foreach (string value in values)
{
   try {
      result = Convert.ToUInt16(value);
      Console.WriteLine("Converted the {0} value '{1}' to the {2} value {3}.",
                        value.GetType().Name, value,
                        result.GetType().Name, result);
   }
   catch (FormatException) {
      Console.WriteLine("The {0} value {1} is not in a recognizable format.",
                        value.GetType().Name, value);
   }
   catch (OverflowException) {
      Console.WriteLine("{0} is outside the range of the UInt16 type.", value);
   }
}
// The example displays the following output:
//    Converted the String value '1603' to the UInt16 value 1603.
//    The String value 1,603 is not in a recognizable format.
//    The String value one is not in a recognizable format.
//    The String value 1.6e03 is not in a recognizable format.
//    The String value 1.2e-02 is not in a recognizable format.
//    -1326 is outside the range of the UInt16 type.
//    1074122 is outside the range of the UInt16 type.

Comentários

Usar o ToUInt16(String) método é equivalente a passar value para o UInt16.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 UInt16.TryParse método em vez disso. Ele retorna um valor Boolean que indica se a conversão foi bem-sucedida ou falhou.

Aplica-se a

ToUInt16(UInt16)

Origem:
Convert.cs
Origem:
Convert.cs
Origem:
Convert.cs

Importante

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

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

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

Parâmetros

value
UInt16

O inteiro sem sinal de 16 bits a ser retornado.

Retornos

UInt16

value é retornado inalterado.

Atributos
CLSCompliantAttribute

Aplica-se a

ToUInt16(UInt32)

Origem:
Convert.cs
Origem:
Convert.cs
Origem:
Convert.cs

Importante

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

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

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

Parâmetros

value
UInt32

O inteiro sem sinal de 32 bits a ser convertido.

Retornos

UInt16

Um inteiro não assinado de 16 bits equivalente a value.

Atributos
CLSCompliantAttribute

Exceções

OverflowException

value é maior que UInt16.MaxValue.

Exemplos

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

uint[] numbers = { UInt32.MinValue, 121, 340, UInt32.MaxValue };
ushort result;

foreach (uint number in numbers)
{
   try {
      result = Convert.ToUInt16(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 UInt16 type.",
                        number.GetType().Name, number);
   }
}
// The example displays the following output:
//    Converted the UInt32 value '0' to the UInt16 value 0.
//    Converted the UInt32 value '121' to the UInt16 value 121.
//    Converted the UInt32 value '340' to the UInt16 value 340.
//    The UInt32 value 4294967295 is outside the range of the UInt16 type.

Aplica-se a

ToUInt16(String, Int32)

Origem:
Convert.cs
Origem:
Convert.cs
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 16 bits equivalente.

[System.CLSCompliant(false)]
public static ushort ToUInt16 (string value, int fromBase);
[System.CLSCompliant(false)]
public static ushort ToUInt16 (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

UInt16

Um inteiro sem sinal de 16 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 UInt16.MinValue ou maior que UInt16.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 de 16 bits sem sinal.

using System;

public class Example
{
   public static void Main()
   {
      string[] hexStrings = { "8000", "0FFF", "f000", "00A30", "D", "-13",
                              "9AC61", "GAD" };
      foreach (string hexString in hexStrings)
      {
         try {
            ushort number = Convert.ToUInt16(hexString, 16);
            Console.WriteLine("Converted '{0}' to {1:N0}.", hexString, number);
         }
         catch (FormatException) {
            Console.WriteLine("'{0}' is not in the correct format for a hexadecimal number.",
                              hexString);
         }
         catch (OverflowException) {
            Console.WriteLine("'{0}' is outside the range of an Int16.", hexString);
         }
         catch (ArgumentException) {
            Console.WriteLine("'{0}' is invalid in base 16.", hexString);
         }
      }
   }
}
// The example displays the following output:
//    Converted '8000' to 32,768.
//    Converted '0FFF' to 4,095.
//    Converted 'f000' to 61,440.
//    Converted '00A30' to 2,608.
//    Converted 'D' to 13.
//    '-13' is invalid in base 16.
//    '9AC61' is outside the range of an Int16.
//    'GAD' is not in the correct format for a hexadecimal number.

Comentários

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

Como o UInt16 tipo de dados dá suporte apenas a valores não assinados, o ToUInt16(String, Int32) método pressupõe que value seja expresso usando uma representação binária não assinada. Em outras palavras, todos os 16 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 UInt16 dados é convertido em um UInt16 valor sem que o método gere uma exceção. O exemplo a seguir converte em sua representação de cadeia de caracteres Int16.MinValue hexadecimal e chama o ToUInt16(String, Int32) método . Em vez de gerar uma exceção, o método exibe a mensagem "0x8000 converte em 32768".

// Create a hexadecimal value out of range of the UInt16 type.
string value = Convert.ToString(Int16.MinValue, 16);
// Convert it back to a number.
try
{
   UInt16 number = Convert.ToUInt16(value, 16);
   Console.WriteLine("0x{0} converts to {1}.", value, number);
}
catch (OverflowException)
{
   Console.WriteLine("Unable to convert '0x{0}' to an unsigned short 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 UInt16 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 UInt16 valor, ele verifica se o valor original era um inteiro com sinal. Nesse caso, e se seu bit de alta ordem estiver definido (o que indica que o valor original foi negativo), o método gerará uma exceção.

// Create a negative hexadecimal value out of range of the UInt16 type.
short sourceNumber = Int16.MinValue;
bool isSigned = Math.Sign((short)sourceNumber.GetType().GetField("MinValue").GetValue(null)) == -1;
string value = Convert.ToString(sourceNumber, 16);
UInt16 targetNumber;
try
{
   targetNumber = Convert.ToUInt16(value, 16);
   if (isSigned && ((targetNumber & 0x8000) != 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 short integer.", value);
}
// Displays the following to the console:
//    Unable to convert '0x8000' to an unsigned short integer.

Aplica-se a

ToUInt16(Object, IFormatProvider)

Origem:
Convert.cs
Origem:
Convert.cs
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 16 bits, usando as informações de formatação específicas da cultura especificada.

[System.CLSCompliant(false)]
public static ushort ToUInt16 (object value, IFormatProvider provider);
[System.CLSCompliant(false)]
public static ushort ToUInt16 (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

UInt16

Um inteiro sem sinal de 16 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 UInt16.MinValue ou maior que UInt16.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 16 bits e sem sinal de 16 bits. A classe inclui uma Sign propriedade que indica o sinal de seu valor hexadecimal.

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 > 4)
            throw new ArgumentException("The string representation of a 160bit integer cannot have more than four characters.");
         else if (! Regex.IsMatch(value, "([0-9,A-F]){1,4}", RegexOptions.IgnoreCase))
            throw new ArgumentException("The hexadecimal representation of a 16-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.ToInt16(hexString, 16)));
      else
         try {
            return Convert.ToByte(UInt16.Parse(hexString, NumberStyles.HexNumber));
         }
         catch (OverflowException e) {
            throw new OverflowException(String.Format("{0} is out of range of the UInt16 type.", Convert.ToUInt16(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.ToInt16(hexString, 16)));
      }

      UInt16 codePoint = UInt16.Parse(this.hexString, NumberStyles.HexNumber);
      return Convert.ToChar(codePoint);
   }

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

   public decimal ToDecimal(IFormatProvider provider)
   {
      if (signBit == SignBit.Negative)
      {
         short hexValue = Int16.Parse(hexString, NumberStyles.HexNumber);
         return Convert.ToDecimal(hexValue);
      }
      else
      {
         ushort hexValue = UInt16.Parse(hexString, NumberStyles.HexNumber);
         return Convert.ToDecimal(hexValue);
      }
   }

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

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

   public int ToInt32(IFormatProvider provider)
   {
      if (signBit == SignBit.Negative)
         return Convert.ToInt32(Int16.Parse(hexString, NumberStyles.HexNumber));
      else
         return Convert.ToInt32(UInt16.Parse(hexString, NumberStyles.HexNumber));
   }

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

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

   public float ToSingle(IFormatProvider provider)
   {
      if (signBit == SignBit.Negative)
         return Convert.ToSingle(Int16.Parse(hexString, NumberStyles.HexNumber));
      else
         return Convert.ToSingle(UInt16.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 UInt16 ToUInt16(IFormatProvider provider)
   {
      if (signBit == SignBit.Negative)
         throw new OverflowException(String.Format("{0} is outside the range of the UInt16 type.",
                                                   Int16.Parse(hexString, NumberStyles.HexNumber)));
      else
         return UInt16.Parse(hexString, NumberStyles.HexNumber);
   }

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

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

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

public class Example
{
   public static void Main()
   {
      ushort positiveValue = 32000;
      short negativeValue = -1;

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

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

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

      try {
         Console.WriteLine("0x{0} converts to {1}.", negativeString.Value, Convert.ToUInt16(negativeString));
      }
      catch (OverflowException) {
         Console.WriteLine("{0} is outside the range of the UInt16 type.",
                           Int16.Parse(negativeString.Value, NumberStyles.HexNumber));
      }
   }
}
// The example displays the following output:
//       0x7D00 converts to 32000.
//       -1 is outside the range of the UInt16 type.

Comentários

O valor retornado é o resultado da invocação do IConvertible.ToUInt16 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.

Aplica-se a

ToUInt16(String, IFormatProvider)

Origem:
Convert.cs
Origem:
Convert.cs
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 16 bits equivalente, usando as informações específicas à cultura especificadas.

[System.CLSCompliant(false)]
public static ushort ToUInt16 (string value, IFormatProvider provider);
[System.CLSCompliant(false)]
public static ushort ToUInt16 (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

UInt16

Um inteiro sem sinal de 16 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 UInt16.MinValue ou maior que UInt16.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.

using System;
using System.Globalization;

public class Example
{
   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 strings to convert to UInt16 values.
      string[] values= { "34567", "+34567", "pos 34567", "34567.",
                         "34567.", "65535", "65535", "65535" };

      foreach (string value in values)
      {
         Console.Write("{0,-12:}  -->  ", value);
         try {
            Console.WriteLine("{0,17}", Convert.ToUInt16(value, provider));
         }
         catch (FormatException e) {
            Console.WriteLine("{0,17}", e.GetType().Name);
         }
      }
   }
}
// The example displays the following output:
//       34567         -->              34567
//       +34567        -->    FormatException
//       pos 34567     -->              34567
//       34567.        -->    FormatException
//       34567.        -->    FormatException
//       65535         -->              65535
//       65535         -->              65535
//       65535         -->              65535

Comentários

O valor retornado é o resultado da invocação UInt16.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 UInt16.TryParse método em vez disso. Ele retorna um valor Boolean que indica se a conversão foi bem-sucedida ou falhou.

Aplica-se a

ToUInt16(Single)

Origem:
Convert.cs
Origem:
Convert.cs
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 16 bits equivalente.

[System.CLSCompliant(false)]
public static ushort ToUInt16 (float value);

Parâmetros

value
Single

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

Retornos

UInt16

value, arredondado para o próximo inteiro sem sinal de 16 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 UInt16.MaxValue.

Exemplos

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

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

foreach (float number in numbers)
{
   try {
      result = Convert.ToUInt16(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("{0} is outside the range of the UInt16 type.", number);
   }
}
// The example displays the following output:
//    -3.402823E+38 is outside the range of the UInt16 type.
//    -1.38E+10 is outside the range of the UInt16 type.
//    -1023.299 is outside the range of the UInt16 type.
//    -12.98 is outside the range of the UInt16 type.
//    Converted the Single value '0' to the UInt16 value 0.
//    Converted the Single value '9.113E-16' to the UInt16 value 0.
//    Converted the Single value '103.919' to the UInt16 value 104.
//    Converted the Single value '17834.19' to the UInt16 value 17834.
//    3.402823E+38 is outside the range of the UInt16 type.

Confira também

Aplica-se a

ToUInt16(UInt64)

Origem:
Convert.cs
Origem:
Convert.cs
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 16 bits equivalente.

[System.CLSCompliant(false)]
public static ushort ToUInt16 (ulong value);

Parâmetros

value
UInt64

O inteiro sem sinal de 64 bits a ser convertido.

Retornos

UInt16

Um inteiro não assinado de 16 bits equivalente a value.

Atributos
CLSCompliantAttribute

Exceções

OverflowException

value é maior que UInt16.MaxValue.

Exemplos

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

ulong[] numbers = { UInt64.MinValue, 121, 340, UInt64.MaxValue };
ushort result;

foreach (ulong number in numbers)
{
   try {
      result = Convert.ToUInt16(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 UInt16 type.",
                        number.GetType().Name, number);
   }
}
// The example displays the following output:
//    Converted the UInt64 value '0' to the UInt16 value 0.
//    Converted the UInt64 value '121' to the UInt16 value 121.
//    Converted the UInt64 value '340' to the UInt16 value 340.
//    The UInt64 value 18446744073709551615 is outside the range of the UInt16 type.

Aplica-se a

ToUInt16(SByte)

Origem:
Convert.cs
Origem:
Convert.cs
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 16 bits equivalente.

[System.CLSCompliant(false)]
public static ushort ToUInt16 (sbyte value);

Parâmetros

value
SByte

O inteiro com sinal de 8 bits a ser convertido.

Retornos

UInt16

Um inteiro não assinado de 16 bits equivalente a value.

Atributos
CLSCompliantAttribute

Exceções

OverflowException

value é menor que zero.

Exemplos

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

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

foreach (sbyte number in numbers)
{
   try {
      result = Convert.ToUInt16(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("{0} is outside the range of the UInt16 type.", number);
   }
}
// The example displays the following output:
//    -128 is outside the range of the UInt16 type.
//    -1 is outside the range of the UInt16 type.
//    Converted the SByte value '0' to the UInt16 value 0.
//    Converted the SByte value '10' to the UInt16 value 10.
//    Converted the SByte value '127' to the UInt16 value 127.

Aplica-se a

ToUInt16(Char)

Origem:
Convert.cs
Origem:
Convert.cs
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 16 bits equivalente.

[System.CLSCompliant(false)]
public static ushort ToUInt16 (char value);

Parâmetros

value
Char

O caractere Unicode a ser convertido.

Retornos

UInt16

O inteiro sem sinal de 16 bits equivalente a value.

Atributos
CLSCompliantAttribute

Exemplos

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

char[] chars = { 'a', 'z', '\x0007', '\x03FF',
                 '\x7FFF', '\xFFFE' };
ushort result;

foreach (char ch in chars)
{
   try {
      result = Convert.ToUInt16(ch);
      Console.WriteLine("Converted the {0} value '{1}' to the {2} value {3}.",
                        ch.GetType().Name, ch,
                        result.GetType().Name, result);
   }
   catch (OverflowException) {
      Console.WriteLine("Unable to convert u+{0} to a UInt16.",
                        ((int)ch).ToString("X4"));
   }
}
// The example displays the following output:
//    Converted the Char value 'a' to the UInt16 value 97.
//    Converted the Char value 'z' to the UInt16 value 122.
//    Converted the Char value '' to the UInt16 value 7.
//    Converted the Char value '?' to the UInt16 value 1023.
//    Converted the Char value '?' to the UInt16 value 32767.
//    Converted the Char value '?' to the UInt16 value 65534.

Aplica-se a

ToUInt16(Int64)

Origem:
Convert.cs
Origem:
Convert.cs
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 16 bits equivalente.

[System.CLSCompliant(false)]
public static ushort ToUInt16 (long value);

Parâmetros

value
Int64

O inteiro com sinal de 64 bits a ser convertido.

Retornos

UInt16

Um inteiro não assinado de 16 bits equivalente a value.

Atributos
CLSCompliantAttribute

Exceções

OverflowException

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

Exemplos

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

long[] numbers = { Int64.MinValue, -1, 0, 121, 340, Int64.MaxValue };
ushort result;

foreach (long number in numbers)
{
   try {
      result = Convert.ToUInt16(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 UInt16 type.",
                        number.GetType().Name, number);
   }
}
// The example displays the following output:
//    The Int64 value -9223372036854775808 is outside the range of the UInt16 type.
//    The Int64 value -1 is outside the range of the UInt16 type.
//    Converted the Int64 value '0' to the UInt16 value 0.
//    Converted the Int64 value '121' to the UInt16 value 121.
//    Converted the Int64 value '340' to the UInt16 value 340.
//    The Int64 value 9223372036854775807 is outside the range of the UInt16 type.

Aplica-se a

ToUInt16(Int32)

Origem:
Convert.cs
Origem:
Convert.cs
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 16 bits equivalente.

[System.CLSCompliant(false)]
public static ushort ToUInt16 (int value);

Parâmetros

value
Int32

O inteiro com sinal de 32 bits a converter.

Retornos

UInt16

Um inteiro não assinado de 16 bits equivalente a value.

Atributos
CLSCompliantAttribute

Exceções

OverflowException

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

Exemplos

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

int[] numbers = { Int32.MinValue, -1, 0, 121, 340, Int32.MaxValue };
ushort result;

foreach (int number in numbers)
{
   try {
      result = Convert.ToUInt16(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 UInt16 type.",
                        number.GetType().Name, number);
   }
}
// The example displays the following output:
//    The Int32 value -2147483648 is outside the range of the UInt16 type.
//    The Int32 value -1 is outside the range of the UInt16 type.
//    Converted the Int32 value '0' to the UInt16 value 0.
//    Converted the Int32 value '121' to the UInt16 value 121.
//    Converted the Int32 value '340' to the UInt16 value 340.
//    The Int32 value 2147483647 is outside the range of the UInt16 type.

Aplica-se a

ToUInt16(Int16)

Origem:
Convert.cs
Origem:
Convert.cs
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 16 bits equivalente.

[System.CLSCompliant(false)]
public static ushort ToUInt16 (short value);

Parâmetros

value
Int16

O inteiro assinado de 16 bits a ser convertido.

Retornos

UInt16

Um inteiro não assinado de 16 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 de 16 bits.

short[] numbers = { Int16.MinValue, -132, 0, 121, 16103, Int16.MaxValue  };
ushort result;

foreach (short number in numbers)
{
   try {
      result = Convert.ToUInt16(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 UInt16 type.",
                        number.GetType().Name, number);
   }
}
// The example displays the following output:
//    The Int16 value -32768 is outside the range of the UInt16 type.
//    The Int16 value -132 is outside the range of the UInt16 type.
//    Converted the Int16 value '0' to the UInt16 value 0.
//    Converted the Int16 value '121' to the UInt16 value 121.
//    Converted the Int16 value '16103' to the UInt16 value 16103.
//    Converted the Int16 value '32767' to the UInt16 value 32767.

Aplica-se a

ToUInt16(Decimal)

Origem:
Convert.cs
Origem:
Convert.cs
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 16 bits equivalente.

[System.CLSCompliant(false)]
public static ushort ToUInt16 (decimal value);

Parâmetros

value
Decimal

O número decimal a ser convertido.

Retornos

UInt16

value, arredondado para o próximo inteiro sem sinal de 16 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 UInt16.MaxValue.

Exemplos

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

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

foreach (decimal number in numbers)
{
   try {
      result = Convert.ToUInt16(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("{0} is outside the range of the UInt16 type.",
                        number);
   }
}
// The example displays the following output:
//    -79228162514264337593543950335 is outside the range of the UInt16 type.
//    -1034.23 is outside the range of the UInt16 type.
//    -12 is outside the range of the UInt16 type.
//    Converted the Decimal value '0' to the UInt16 value 0.
//    Converted the Decimal value '147' to the UInt16 value 147.
//    Converted the Decimal value '9214.16' to the UInt16 value 9214.
//    79228162514264337593543950335 is outside the range of the UInt16 type.

Confira também

Aplica-se a

ToUInt16(DateTime)

Origem:
Convert.cs
Origem:
Convert.cs
Origem:
Convert.cs

Importante

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

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

[System.CLSCompliant(false)]
public static ushort ToUInt16 (DateTime value);

Parâmetros

value
DateTime

O valor de data e tempo a ser convertido.

Retornos

UInt16

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

Atributos
CLSCompliantAttribute

Exceções

InvalidCastException

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

Aplica-se a

ToUInt16(Byte)

Origem:
Convert.cs
Origem:
Convert.cs
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 16 bits equivalente.

[System.CLSCompliant(false)]
public static ushort ToUInt16 (byte value);

Parâmetros

value
Byte

O inteiro sem sinal de 8 bits a ser convertido.

Retornos

UInt16

Um inteiro não assinado de 16 bits equivalente a value.

Atributos
CLSCompliantAttribute

Exemplos

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

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

foreach (byte byteValue in bytes)
{
   result = Convert.ToUInt16(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 UInt16 value 0.
//       Converted the Byte value '14' to the UInt16 value 14.
//       Converted the Byte value '122' to the UInt16 value 122.
//       Converted the Byte value '255' to the UInt16 value 255.

Aplica-se a

ToUInt16(Boolean)

Origem:
Convert.cs
Origem:
Convert.cs
Origem:
Convert.cs

Importante

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

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

[System.CLSCompliant(false)]
public static ushort ToUInt16 (bool value);

Parâmetros

value
Boolean

O valor booliano a ser convertido.

Retornos

UInt16

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

Atributos
CLSCompliantAttribute

Exemplos

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

bool falseFlag = false;
bool trueFlag = true;

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

Aplica-se a

ToUInt16(Object)

Origem:
Convert.cs
Origem:
Convert.cs
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 16 bits.

[System.CLSCompliant(false)]
public static ushort ToUInt16 (object value);
[System.CLSCompliant(false)]
public static ushort ToUInt16 (object? value);

Parâmetros

value
Object

Um objeto que implementa a interface IConvertible ou null.

Retornos

UInt16

Um inteiro sem sinal de 16 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 UInt16.MinValue ou maior que UInt16.MaxValue.

Exemplos

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

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

foreach (object value in values)
{
   try {
      result = Convert.ToUInt16(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 UInt16 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 UInt16 exists for the {0} value {1}.",
                        value.GetType().Name, value);
   }
}
// The example displays the following output:
//    Converted the Boolean value 'True' to the UInt16 value 1.
//    The Int32 value -12 is outside the range of the UInt16 type.
//    Converted the Int32 value '163' to the UInt16 value 163.
//    Converted the Int32 value '935' to the UInt16 value 935.
//    Converted the Char value 'x' to the UInt16 value 120.
//    No conversion to a UInt16 exists for the DateTime value 5/12/2009 12:00:00 AM.
//    Converted the String value '104' to the UInt16 value 104.
//    The String value 103.0 is not in a recognizable format.
//    The String value -1 is outside the range of the UInt16 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 UInt16 value 100.

Comentários

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

Aplica-se a

ToUInt16(Double)

Origem:
Convert.cs
Origem:
Convert.cs
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 16 bits equivalente.

[System.CLSCompliant(false)]
public static ushort ToUInt16 (double value);

Parâmetros

value
Double

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

Retornos

UInt16

value, arredondado para o próximo inteiro sem sinal de 16 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 UInt16.MaxValue.

Exemplos

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

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

foreach (double number in numbers)
{
   try {
      result = Convert.ToUInt16(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("{0} is outside the range of the UInt16 type.", number);
   }
}
// The example displays the following output:
//    -1.79769313486232E+308 is outside the range of the UInt16 type.
//    -13800000000 is outside the range of the UInt16 type.
//    -1023.299 is outside the range of the UInt16 type.
//    -12.98 is outside the range of the UInt16 type.
//    Converted the Double value '0' to the UInt16 value 0.
//    Converted the Double value '9.113E-16' to the UInt16 value 0.
//    Converted the Double value '103.919' to the UInt16 value 104.
//    Converted the Double value '17834.191' to the UInt16 value 17834.
//    1.79769313486232E+308 is outside the range of the UInt16 type.

Confira também

Aplica-se a