Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Metodo Convert.ToUInt64 (String, Int32)

 

Data di pubblicazione: ottobre 2016

Converte la rappresentazione di stringa di un numero in una base specificata nell'intero senza segno a 64 bit equivalente.

Questa API non è conforme a CLS.

Spazio dei nomi:   System
Assembly:  mscorlib (in mscorlib.dll)

[CLSCompliantAttribute(false)]
public static ulong ToUInt64(
	string value,
	int fromBase
)

Parametri

value
Type: System.String

Stringa che contiene il numero da convertire.

fromBase
Type: System.Int32

Base del numero in value, che deve essere 2, 8, 10 o 16.

Valore restituito

Type: System.UInt64

Intero senza segno a 64 bit equivalente al numero in value oppure 0 (zero) se value è null.

Exception Condition
ArgumentException

Il valore di fromBase non è 2, 8, 10 o 16.

-oppure-

value, che rappresenta un numero senza segno non in base 10, è preceduto da un segno negativo.

ArgumentOutOfRangeException

value è String.Empty.

FormatException

value contiene un carattere che corrisponde a una cifra non valida nella base specificata da fromBase. Il messaggio di eccezione indica che non ci sono cifre da convertire se il primo carattere in value non è valido; in caso contrario, il messaggio indica che value contiene caratteri finali non validi.

OverflowException

value, che rappresenta un numero senza segno non in base 10, è preceduto da un segno negativo.

-oppure-

L'oggetto value rappresenta un numero minore di UInt64.MinValue o maggiore di UInt64.MaxValue.

Se fromBase è 16, è possibile anteporre al numero specificato per il value parametro con "0x" o "0x".

Poiché la UInt64 tipo di dati supporta solo valori senza segno il ToUInt64(String, Int32) metodo presuppone che value sia espresso utilizzando una rappresentazione binaria senza segno. In altre parole, tutti i 64 bit vengono utilizzati per rappresentare il valore numerico e il bit di segno è assente. Di conseguenza, è possibile scrivere codice in cui un valore long integer valore che non rientra nell'intervallo consentito di UInt64 tipo di dati viene convertito in un UInt64 valore senza il metodo generi un'eccezione. L'esempio seguente converte MinValue per la rappresentazione di stringa esadecimale e quindi chiama il ToUInt64(String, Int32) metodo. Anziché generare un'eccezione, il metodo visualizza il messaggio "0x8000000000000000 viene convertito in 9223372036854775808".

// 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);
}   

Quando si eseguono operazioni binarie o conversioni numeriche, è sempre responsabilità dello sviluppatore per verificare che un metodo o un operatore viene utilizzata la rappresentazione numerica appropriata per interpretare un valore specifico. Nell'esempio seguente viene illustrata una tecnica per garantire che il metodo utilizza in modo inappropriato rappresentazione binaria per interpretare un valore che utilizza la rappresentazione in complemento a due, quando si converte una stringa esadecimale a una UInt64 valore. L'esempio determina se un valore rappresenta un signed o un intero senza segno mentre converte tale valore nella relativa rappresentazione di stringa. Quando l'esempio converte il valore in un UInt64 valore, viene verificato se il valore originale era un intero con segno. In tal caso e se è impostato il bit più significativo (che indica che il valore originale è stato negativo), il metodo genera un'eccezione.

// 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.     

Nell'esempio seguente tenta di interpretare ogni elemento in una matrice di stringhe numeriche come valore esadecimale e di convertirlo in un unsigned long integer.

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

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 1.1
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Silverlight
Disponibile da 2.0
Windows Phone Silverlight
Disponibile da 7.0
Windows Phone
Disponibile da 8.1
Torna all'inizio
Mostra: