Convert.ToUInt64 Метод

Определение

Пространство имен:

System

Сборка:

System.Runtime.dll

Преобразует заданное значение в 64-битовое целое число без знака.

Перегрузки

ToUInt64(String)	Преобразует заданное строковое представление числа в эквивалентное 64-битовое целое число без знака.
ToUInt64(UInt16)	Преобразует значение заданного 16-битового целого числа без знака в эквивалентное 64-битовое целое число без знака.
ToUInt64(UInt32)	Преобразует значение заданного 32-битового целого числа без знака в эквивалентное 64-битовое целое число без знака.
ToUInt64(String, IFormatProvider)	Преобразует заданное строковое представление числа в эквивалентное 64-битовое целое число без знака, учитывая указанные сведения об особенностях форматирования, связанных с языком и региональными параметрами.
ToUInt64(Object, IFormatProvider)	Преобразует значение заданного объекта в эквивалентное 64-битовое целое число без знака, используя указанные сведения об особенностях форматирования, связанных с языком и региональными параметрами.
ToUInt64(Single)	Преобразует значение заданного числа с плавающей запятой одиночной точности в эквивалентное 64-битовое целое число без знака.
ToUInt64(String, Int32)	Преобразует строковое представление числа с указанным основанием системы счисления в эквивалентное ему 64-битовое целое число без знака.
ToUInt64(UInt64)	Возвращает заданное 64-битовое целое число без знака; фактическое преобразование не производится.
ToUInt64(SByte)	Преобразует значение заданного 8-битового целого числа со знаком в эквивалентное 64-битовое целое число без знака.
ToUInt64(Int16)	Преобразует значение заданного 16-битового целого числа со знаком в эквивалентное 64-битовое целое число без знака.
ToUInt64(Int64)	Преобразует значение заданного 64-битового целого числа со знаком в эквивалентное 64-битовое целое число без знака.
ToUInt64(Int32)	Преобразует значение заданного 32-битового целого числа со знаком в эквивалентное 64-битовое целое число без знака.
ToUInt64(Double)	Преобразует значение заданного числа с плавающей запятой двойной точности в эквивалентное 64-битовое целое число без знака.
ToUInt64(Decimal)	Преобразует значение заданного десятичного числа в эквивалентное 64-битовое целое число без знака.
ToUInt64(DateTime)	При вызове этого метода всегда возникает исключение InvalidCastException.
ToUInt64(Char)	Преобразует значение заданного символа Юникода в эквивалентное 64-битовое целое число без знака.
ToUInt64(Byte)	Преобразует значение заданного 8-битового целого числа без знака в эквивалентное 64-битовое целое число без знака.
ToUInt64(Boolean)	Преобразует заданное логическое значение в эквивалентное 64-битовое целое число без знака.
ToUInt64(Object)	Преобразует значение заданного объекта в 64-битовое целое число без знака.

ToUInt64(String)

Исходный код:

Convert.cs

Важно!

Этот API несовместим с CLS.

Преобразует заданное строковое представление числа в эквивалентное 64-битовое целое число без знака.

C#

[System.CLSCompliant(false)]
public static ulong ToUInt64 (string? value);

Параметры

value

String

Строка, содержащая преобразуемое число.

Возвращаемое значение

UInt64

64-разрядное знаковое целое число, которое эквивалентно значению параметра value, или 0 (нуль), если value имеет значение null.

Атрибуты

CLSCompliantAttribute

Исключения

FormatException

value не состоит из необязательного знака, за которым следует последовательность цифр (0–9).

OverflowException

value представляет число, которое меньше UInt64.MinValue или больше UInt64.MaxValue.

Примеры

В следующем примере элементы массива строк интерпретируются как числовые строки и пытаются преобразовать их в длинные целые числа без знака.

C#

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

foreach (string value in values)
{
   try {
      result = Convert.ToUInt64(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("{0} is outside the range of the UInt64 type.", 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.
//    -18 is outside the range of the UInt64 type.
//    The String value '-6.00' is not in a recognizable format.
//    Converted the String value ' 0' to the UInt64 value 0.
//    Converted the String value '137' to the UInt64 value 137.
//    The String value '1601.9' is not in a recognizable format.
//    Converted the String value '2147483647' to the UInt64 value 2147483647.

Комментарии

ToInt64(String) Использование метода эквивалентно передаче value в Int64.Parse(String) метод . value интерпретируется с помощью соглашений о форматировании текущего языка и региональных параметров.

Если вы предпочитаете не обрабатывать исключение в случае сбоя преобразования, вместо этого можно вызвать UInt64.TryParse метод . Он возвращает Boolean значение, указывающее, успешно ли выполнено преобразование.

ToUInt64(UInt16)

Исходный код:

Convert.cs

Важно!

Этот API несовместим с CLS.

Преобразует значение заданного 16-битового целого числа без знака в эквивалентное 64-битовое целое число без знака.

C#

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

Параметры

value

UInt16

16-разрядное целое число без знака для преобразования.

Возвращаемое значение

UInt64

64-разрядное целое число без знака, которое эквивалентно значению value.

Атрибуты

CLSCompliantAttribute

Примеры

В следующем примере каждый элемент в массиве 16-разрядных целых чисел без знака преобразуется в длинное целое число без знака.

C#

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

foreach (ushort number in numbers)
{
   try {
      result = Convert.ToUInt64(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 UInt64 type.",
                        number.GetType().Name, number);
   }
}
// The example displays the following output:
//    Converted the UInt16 value 0 to the UInt64 value 0.
//    Converted the UInt16 value 121 to the UInt64 value 121.
//    Converted the UInt16 value 340 to the UInt64 value 340.
//    Converted the UInt16 value 65535 to the UInt64 value 65535.

ToUInt64(UInt32)

Исходный код:

Convert.cs

Важно!

Этот API несовместим с CLS.

Преобразует значение заданного 32-битового целого числа без знака в эквивалентное 64-битовое целое число без знака.

C#

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

Параметры

value

UInt32

32-разрядное целое число без знака для преобразования.

Возвращаемое значение

UInt64

64-разрядное целое число без знака, которое эквивалентно значению value.

Атрибуты

CLSCompliantAttribute

Примеры

В следующем примере каждый элемент массива целых чисел без знака преобразуется в длинное целое число без знака.

C#

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

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

ToUInt64(String, IFormatProvider)

Исходный код:

Convert.cs

Важно!

Этот API несовместим с CLS.

Преобразует заданное строковое представление числа в эквивалентное 64-битовое целое число без знака, учитывая указанные сведения об особенностях форматирования, связанных с языком и региональными параметрами.

C#

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

Параметры

value

String

Строка, содержащая преобразуемое число.

provider

IFormatProvider

Объект, предоставляющий сведения о форматировании для определенного языка и региональных параметров.

Возвращаемое значение

UInt64

64-разрядное целое число без знака, которое эквивалентно значению параметра value, или 0 (нуль), если value имеет значение null.

Атрибуты

CLSCompliantAttribute

Исключения

FormatException

value не состоит из необязательного знака, за которым следует последовательность цифр (0–9).

OverflowException

value представляет число, которое меньше UInt64.MinValue или больше UInt64.MaxValue.

Примеры

В следующем примере определяется пользовательский NumberFormatInfo объект, который распознает строку "pos" как положительный знак, а строку "neg" — как отрицательный знак. Затем он пытается преобразовать каждый элемент массива числовых строк в целое число без знака. Преобразование использует как пользовательский поставщик, NumberFormatInfo так и поставщик для инвариантного языка и региональных параметров.

C#

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      // Create a NumberFormatInfo object and set several properties.
      NumberFormatInfo provider = new NumberFormatInfo();
      provider.PositiveSign = "pos ";
      provider.NegativeSign = "neg ";

      // Define an array of numeric strings.
      string[] values = { "123456789012", "+123456789012",
                          "pos 123456789012", "123456789012.",
                          "123,456,789,012", "18446744073709551615",
                          "18446744073709551616", "neg 1", "-1" };
      //  Convert the strings using the format provider.
      foreach (string value in values)
      {
         Console.Write("{0,-20}  -->  ", value);
         try {
            Console.WriteLine("{0,20}", Convert.ToUInt64(value, provider));
         }
         catch (FormatException) {
            Console.WriteLine("{0,20}", "Invalid Format");
         }
         catch (OverflowException) {
            Console.WriteLine("{0,20}", "Numeric Overflow");
         }
      }
   }
}
// The example displays the following output:
//    123456789012          -->          123456789012
//    +123456789012         -->        Invalid Format
//    pos 123456789012      -->          123456789012
//    123456789012.         -->        Invalid Format
//    123,456,789,012       -->        Invalid Format
//    18446744073709551615  -->  18446744073709551615
//    18446744073709551616  -->      Numeric Overflow
//    neg 1                 -->      Numeric Overflow
//    -1                    -->        Invalid Format

Комментарии

Возвращаемое значение является результатом вызова UInt64.Parse в value.

provider IFormatProvider— это реализация, которая получает NumberFormatInfo объект . Объект NumberFormatInfo предоставляет сведения о формате value. Если provider имеет значение null, NumberFormatInfo используется объект для текущего языка и региональных параметров.

Если вы предпочитаете не обрабатывать исключение в случае сбоя преобразования, вместо этого можно вызвать UInt64.TryParse метод . Он возвращает Boolean значение, указывающее, успешно ли выполнено преобразование.

ToUInt64(Object, IFormatProvider)

Исходный код:

Convert.cs

Важно!

Этот API несовместим с CLS.

Преобразует значение заданного объекта в эквивалентное 64-битовое целое число без знака, используя указанные сведения об особенностях форматирования, связанных с языком и региональными параметрами.

C#

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

Параметры

value

Object

Объект, реализующий интерфейс IConvertible.

provider

IFormatProvider

Объект, предоставляющий сведения о форматировании для определенного языка и региональных параметров.

Возвращаемое значение

UInt64

64-разрядное целое число без знака, эквивалентное значению value, или нуль, если value имеет значение null.

Атрибуты

CLSCompliantAttribute

Исключения

FormatException

Параметр value имеет неправильный формат.

InvalidCastException

value не реализует интерфейс IConvertible.

-или-

Преобразование не поддерживается.

OverflowException

value представляет число, которое меньше UInt64.MinValue или больше UInt64.MaxValue.

Примеры

В следующем примере определяется класс, реализующий HexStringIConvertible интерфейс и предназначенный для хранения строкового представления как 64-разрядных, так и 64-разрядных значений без знака. Класс содержит Sign свойство , указывающее знак его шестнадцатеричного значения.

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 > 16)
            throw new ArgumentException("The hexadecimal representation of a 64-bit integer cannot have more than 16 characters.");
         else if (! Regex.IsMatch(value, "([0-9,A-F]){1,8}", RegexOptions.IgnoreCase))
            throw new ArgumentException("The hexadecimal representation of a 64-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.ToInt64(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.ToUInt64(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.ToInt64(hexString, 16)));

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

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

   public decimal ToDecimal(IFormatProvider provider)
   {
      if (signBit == SignBit.Negative)
      {
         long hexValue = Int64.Parse(hexString, NumberStyles.HexNumber);
         return Convert.ToDecimal(hexValue);
      }
      else
      {
         ulong hexValue = UInt64.Parse(hexString, NumberStyles.HexNumber);
         return Convert.ToDecimal(hexValue);
      }
   }

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

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

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

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

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

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

   public ulong 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);
   }
}

В следующем примере показано, что вызов ToUInt64(Object, IFormatProvider) метода , который передает HexString объект в качестве параметра, в свою очередь вызывает IConvertible.ToUInt64 реализацию HexString класса .

C#

public class Example
{
   public static void Main()
   {
      ulong positiveValue = UInt64.MaxValue - 100000;
      long negativeValue = -1;

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

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

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

      try {
         Console.WriteLine("0x{0} converts to {1}.", negativeString.Value, Convert.ToUInt64(negativeString));
      }
      catch (OverflowException) {
         Console.WriteLine("{0} is outside the range of the UInt64 type.",
                           Int64.Parse(negativeString.Value, NumberStyles.HexNumber));
      }
   }
}
// The example displays the following output:
//       0xFFFFFFFFFFFE795F converts to 18446744073709451615.
//       -1 is outside the range of the UInt64 type.

Комментарии

Возвращаемое значение является результатом вызова IConvertible.ToUInt64 метода базового типа value.

provider позволяет пользователю указать сведения о преобразовании для конкретного языка и региональных параметров для содержимого value. Например, если value является String , который представляет число, может предоставить сведения о нотации, используемой для представления этого числа, provider с учетом языка и региональных параметров.

Базовые типы игнорируют provider; однако параметр можно использовать, если value является определяемым пользователем типом, реализующим IConvertible интерфейс .

ToUInt64(Single)

Исходный код:

Convert.cs

Важно!

Этот API несовместим с CLS.

Преобразует значение заданного числа с плавающей запятой одиночной точности в эквивалентное 64-битовое целое число без знака.

C#

[System.CLSCompliant(false)]
public static ulong ToUInt64 (float value);

Параметры

value

Single

Число с плавающей запятой одиночной точности, которое нужно преобразовать.

Возвращаемое значение

UInt64

Значение value, округленное до ближайшего 64-разрядного целого числа без знака. Если value имеет среднее значение между двумя целыми числами, будет возвращено четное число; так, значение 4,5 преобразуется в 4, а 5,5 — в 6.

Атрибуты

CLSCompliantAttribute

Исключения

OverflowException

value значение меньше нуля или больше UInt64.MaxValue.

Примеры

В следующем примере предпринимается попытка преобразовать каждый элемент в массиве значений Single в целое число без знака. Выходные данные показывают, что дробные значения округляются перед выполнением преобразования.

C#

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

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

См. также раздел

• Single
• Round

ToUInt64(String, Int32)

Исходный код:

Convert.cs

Важно!

Этот API несовместим с CLS.

Преобразует строковое представление числа с указанным основанием системы счисления в эквивалентное ему 64-битовое целое число без знака.

C#

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

Параметры

value

String

Строка, содержащая преобразуемое число.

fromBase

Int32

Основание системы счисления, используемой для представления числа, заданного в параметре value, равное 2, 8, 10 или 16.

Возвращаемое значение

UInt64

64-разрядное целое число без знака, которое эквивалентно значению параметра value, или 0 (нуль), если value имеет значение null.

Атрибуты

CLSCompliantAttribute

Исключения

ArgumentException

fromBase не равно 2, 8, 10 или 16.

-или-

Значениеvalue, представляющее недесятичное число без знака, использовано со знаком минус.

ArgumentOutOfRangeException

value имеет значение Empty.

FormatException

value содержит символ, который не является допустимой цифрой в основании, заданном параметром fromBase. Сообщение об исключении указывает, что отсутствуют цифры для преобразования, если первый символ в value недопустим; в противном случае сообщение указывает, что value содержит недопустимые конечные символы.

OverflowException

Значениеvalue, представляющее недесятичное число без знака, использовано со знаком минус.

-или-

value представляет число, которое меньше UInt64.MinValue или больше UInt64.MaxValue.

Примеры

В следующем примере предпринимается попытка интерпретировать каждый элемент в массиве числовых строк как шестнадцатеричное значение и преобразовать его в целое число без знака.

C#

using System;

public class Example
{
   public static void Main()
   {
      string[] hexStrings = { "8000000000000000", "0FFFFFFFFFFFFFFF",
                              "F000000000000000", "00A3000000000000",
                              "D", "-13", "9AC61", "GAD",
                              "FFFFFFFFFFFFFFFFF" };

      foreach (string hexString in hexStrings)
      {
         Console.Write("{0,-18}  -->  ", hexString);
         try {
            ulong number = Convert.ToUInt64(hexString, 16);
            Console.WriteLine("{0,26:N0}", number);
         }
         catch (FormatException) {
            Console.WriteLine("{0,26}", "Bad Format");
         }
         catch (OverflowException) {
            Console.WriteLine("{0,26}", "Numeric Overflow");
         }
         catch (ArgumentException) {
            Console.WriteLine("{0,26}", "Invalid in Base 16");
         }
      }
   }
}
// The example displays the following output:
//    8000000000000000    -->   9,223,372,036,854,775,808
//    0FFFFFFFFFFFFFFF    -->   1,152,921,504,606,846,975
//    F000000000000000    -->  17,293,822,569,102,704,640
//    00A3000000000000    -->      45,880,421,203,836,928
//    D                   -->                          13
//    -13                 -->          Invalid in Base 16
//    9AC61               -->                     633,953
//    GAD                 -->                  Bad Format
//    FFFFFFFFFFFFFFFFF   -->            Numeric Overflow

Комментарии

Если fromBase имеет значение 16, можно добавить в префикс числа, указанного value параметром , "0x" или "0X".

UInt64 Так как тип данных поддерживает только неподписанные значения, ToUInt64(String, Int32) метод предполагает, что value выражается с помощью двоичного представления без знака. Другими словами, все 64 бита используются для представления числовых значений, а бит знака отсутствует. В результате можно написать код, в котором целочисленное значение со знаком, которое выходит за пределы диапазона UInt64 типа данных, преобразуется в UInt64 значение без вызова исключения методом. В следующем примере выполняется преобразование MinValue в шестнадцатеричное строковое представление, а затем вызывается ToUInt64(String, Int32) метод . Вместо создания исключения метод отображает сообщение "0x8000000000000000 преобразуется в 9223372036854775808".

C#

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

При выполнении двоичных операций или числовых преобразований разработчик всегда несет ответственность за проверку того, использует ли метод или оператор соответствующее числовое представление для интерпретации определенного значения. В следующем примере показан один из способов обеспечения того, чтобы метод не использовал неправильное двоичное представление для интерпретации значения, использующего представление двух дополнений при преобразовании шестнадцатеричной строки в UInt64 значение. В примере определяется, представляет ли значение целое число со знаком или без знака при преобразовании этого значения в строковое представление. При преобразовании значения UInt64 в значение в примере проверяется, является ли исходное значение целым числом со знаком. Если это так, и если задан его бит высокого порядка (что указывает на то, что исходное значение было отрицательным), метод создает исключение.

C#

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

ToUInt64(UInt64)

Исходный код:

Convert.cs

Важно!

Этот API несовместим с CLS.

Возвращает заданное 64-битовое целое число без знака; фактическое преобразование не производится.

C#

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

Параметры

value

UInt64

Возвращаемое 64-разрядное целое число без знака.

Возвращаемое значение

UInt64

value возвращается без изменений.

Атрибуты

CLSCompliantAttribute

ToUInt64(SByte)

Исходный код:

Convert.cs

Важно!

Этот API несовместим с CLS.

Преобразует значение заданного 8-битового целого числа со знаком в эквивалентное 64-битовое целое число без знака.

C#

[System.CLSCompliant(false)]
public static ulong ToUInt64 (sbyte value);

Параметры

value

SByte

8-разрядное целое число со знаком для преобразования.

Возвращаемое значение

UInt64

64-разрядное целое число без знака, которое эквивалентно значению value.

Атрибуты

CLSCompliantAttribute

Исключения

OverflowException

Значение параметра value меньше нуля.

Примеры

В следующем примере показано, как преобразовать каждый элемент массива байтов со знаком в целое число без знака.

C#

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

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

ToUInt64(Int16)

Исходный код:

Convert.cs

Важно!

Этот API несовместим с CLS.

Преобразует значение заданного 16-битового целого числа со знаком в эквивалентное 64-битовое целое число без знака.

C#

[System.CLSCompliant(false)]
public static ulong ToUInt64 (short value);

Параметры

value

Int16

16-разрядное целое число со знаком для преобразования.

Возвращаемое значение

UInt64

64-разрядное целое число без знака, которое эквивалентно значению value.

Атрибуты

CLSCompliantAttribute

Исключения

OverflowException

Значение параметра value меньше нуля.

Примеры

В следующем примере предпринимается попытка преобразовать каждый элемент в массиве 16-разрядных целых чисел в длинное целое число без знака.

C#

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

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

ToUInt64(Int64)

Исходный код:

Convert.cs

Важно!

Этот API несовместим с CLS.

Преобразует значение заданного 64-битового целого числа со знаком в эквивалентное 64-битовое целое число без знака.

C#

[System.CLSCompliant(false)]
public static ulong ToUInt64 (long value);

Параметры

value

Int64

64-разрядное целое число со знаком для преобразования.

Возвращаемое значение

UInt64

64-разрядное целое число без знака, которое эквивалентно значению value.

Атрибуты

CLSCompliantAttribute

Исключения

OverflowException

Значение параметра value меньше нуля.

Примеры

В следующем примере показано, как преобразовать каждый элемент в массиве длинных целых чисел в целое число без знака.

C#

long[] numbers = { Int64.MinValue, -19432, -18, 0, 121, 340, Int64.MaxValue };
ulong result;
foreach (long number in numbers)
{
   try {
      result = Convert.ToUInt64(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 UInt64 type.",
                        number.GetType().Name, number);
   }
}
// The example displays the following output:
//    The Int64 value -9223372036854775808 is outside the range of the UInt64 type.
//    The Int64 value -19432 is outside the range of the UInt64 type.
//    The Int64 value -18 is outside the range of the UInt64 type.
//    Converted the Int64 value 0 to the UInt64 value 0.
//    Converted the Int64 value 121 to the UInt64 value 121.
//    Converted the Int64 value 340 to the UInt64 value 340.
//    Converted the Int64 value 9223372036854775807 to a UInt64 value 9223372036854775807.

ToUInt64(Int32)

Исходный код:

Convert.cs

Важно!

Этот API несовместим с CLS.

Преобразует значение заданного 32-битового целого числа со знаком в эквивалентное 64-битовое целое число без знака.

C#

[System.CLSCompliant(false)]
public static ulong ToUInt64 (int value);

Параметры

value

Int32

32-разрядное целое число со знаком для преобразования.

Возвращаемое значение

UInt64

64-разрядное целое число без знака, которое эквивалентно значению value.

Атрибуты

CLSCompliantAttribute

Исключения

OverflowException

Значение параметра value меньше нуля.

Примеры

В следующем примере предпринимается попытка преобразовать каждый элемент в массиве целых чисел в целое число без знака.

C#

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

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

ToUInt64(Double)

Исходный код:

Convert.cs

Важно!

Этот API несовместим с CLS.

Преобразует значение заданного числа с плавающей запятой двойной точности в эквивалентное 64-битовое целое число без знака.

C#

[System.CLSCompliant(false)]
public static ulong ToUInt64 (double value);

Параметры

value

Double

Число с плавающей запятой двойной точности, которое нужно преобразовать.

Возвращаемое значение

UInt64

Значение value, округленное до ближайшего 64-разрядного целого числа без знака. Если value имеет среднее значение между двумя целыми числами, будет возвращено четное число; так, значение 4,5 преобразуется в 4, а 5,5 — в 6.

Атрибуты

CLSCompliantAttribute

Исключения

OverflowException

value значение меньше нуля или больше UInt64.MaxValue.

Примеры

В следующем примере предпринимается попытка преобразовать каждый элемент в массиве значений Double в целое число без знака.

C#

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

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

См. также раздел

• Double
• Round

ToUInt64(Decimal)

Исходный код:

Convert.cs

Важно!

Этот API несовместим с CLS.

Преобразует значение заданного десятичного числа в эквивалентное 64-битовое целое число без знака.

C#

[System.CLSCompliant(false)]
public static ulong ToUInt64 (decimal value);

Параметры

value

Decimal

Десятичное число для преобразования.

Возвращаемое значение

UInt64

Значение value, округленное до ближайшего 64-разрядного целого числа без знака. Если value имеет среднее значение между двумя целыми числами, будет возвращено четное число; так, значение 4,5 преобразуется в 4, а 5,5 — в 6.

Атрибуты

CLSCompliantAttribute

Исключения

OverflowException

value значение меньше нуля или больше UInt64.MaxValue.

Примеры

В следующем примере предпринимается попытка преобразовать каждый элемент в массиве значений Decimal в целое число без знака.

C#

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

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

См. также раздел

• Round

ToUInt64(DateTime)

Исходный код:

Convert.cs

Важно!

Этот API несовместим с CLS.

При вызове этого метода всегда возникает исключение InvalidCastException.

C#

[System.CLSCompliant(false)]
public static ulong ToUInt64 (DateTime value);

Параметры

value

DateTime

Значение даты и времени для преобразования.

Возвращаемое значение

UInt64

Это преобразование не поддерживается. Возвращаемое значение отсутствует.

Атрибуты

CLSCompliantAttribute

Исключения

InvalidCastException

Это преобразование не поддерживается.

ToUInt64(Char)

Исходный код:

Convert.cs

Важно!

Этот API несовместим с CLS.

Преобразует значение заданного символа Юникода в эквивалентное 64-битовое целое число без знака.

C#

[System.CLSCompliant(false)]
public static ulong ToUInt64 (char value);

Параметры

value

Char

Знак Юникода, который необходимо преобразовать.

Возвращаемое значение

UInt64

64-разрядное целое число без знака, которое эквивалентно значению value.

Атрибуты

CLSCompliantAttribute

Примеры

В следующем примере каждый элемент в массиве символов преобразуется в длинное целое число без знака.

C#

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

foreach (char ch in chars)
{
   result = Convert.ToUInt64(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 UInt64 value 97.
//    Converted the Char value 'z' to the UInt64 value 122.
//    Converted the Char value '' to the UInt64 value 7.
//    Converted the Char value '?' to the UInt64 value 1023.
//    Converted the Char value '?' to the UInt64 value 32767.
//    Converted the Char value '?' to the UInt64 value 65534.

ToUInt64(Byte)

Исходный код:

Convert.cs

Важно!

Этот API несовместим с CLS.

Преобразует значение заданного 8-битового целого числа без знака в эквивалентное 64-битовое целое число без знака.

C#

[System.CLSCompliant(false)]
public static ulong ToUInt64 (byte value);

Параметры

value

Byte

8-разрядное целое число без знака для преобразования.

Возвращаемое значение

UInt64

64-разрядное знаковое целое число, которое эквивалентно значению value.

Атрибуты

CLSCompliantAttribute

Примеры

В следующем примере каждый элемент в массиве байтов преобразуется в длинное целое число без знака.

C#

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

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

ToUInt64(Boolean)

Исходный код:

Convert.cs

Важно!

Этот API несовместим с CLS.

Преобразует заданное логическое значение в эквивалентное 64-битовое целое число без знака.

C#

[System.CLSCompliant(false)]
public static ulong ToUInt64 (bool value);

Параметры

value

Boolean

Логическое значение, которое необходимо преобразовать.

Возвращаемое значение

UInt64

Число 1, если value имеет значение true; в противном случае — 0.

Атрибуты

CLSCompliantAttribute

Примеры

В следующем примере логические значения и false преобразуются true в длинные целые числа без знака.

C#

bool falseFlag = false;
bool trueFlag = true;

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

ToUInt64(Object)

Исходный код:

Convert.cs

Важно!

Этот API несовместим с CLS.

Преобразует значение заданного объекта в 64-битовое целое число без знака.

C#

[System.CLSCompliant(false)]
public static ulong ToUInt64 (object? value);

Параметры

value

Object

Объект, реализующий интерфейс IConvertible, или значение null.

Возвращаемое значение

UInt64

64-разрядное целое число без знака, эквивалентное значению value, или нуль, если value имеет значение null.

Атрибуты

CLSCompliantAttribute

Исключения

FormatException

Параметр value имеет неправильный формат.

InvalidCastException

value не реализует интерфейс IConvertible.

-или-

Преобразование не поддерживается.

OverflowException

value представляет число, которое меньше UInt64.MinValue или больше UInt64.MaxValue.

Примеры

В следующем примере предпринимается попытка преобразовать каждый элемент в массиве объектов в целое число без знака.

C#

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

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

Комментарии

Возвращаемое значение является результатом вызова IConvertible.ToUInt64 метода базового типа value.