Int64 Structure

Définition

Représente un entier signé 64 bits.

public value class long : IComparable, IComparable<long>, IConvertible, IEquatable<long>, IFormattable
public value class long : IComparable, IComparable<long>, IConvertible, IEquatable<long>, ISpanFormattable
public value class long : IComparable, IConvertible, IFormattable
public value class long : IComparable, IComparable<long>, IEquatable<long>, IFormattable
public struct Int64 : IComparable, IComparable<long>, IConvertible, IEquatable<long>, IFormattable
public struct Int64 : IComparable, IComparable<long>, IConvertible, IEquatable<long>, ISpanFormattable
[System.Serializable]
public struct Int64 : IComparable, IConvertible, IFormattable
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct Int64 : IComparable, IComparable<long>, IConvertible, IEquatable<long>, IFormattable
public struct Int64 : IComparable, IComparable<long>, IEquatable<long>, IFormattable
type int64 = struct
    interface IConvertible
    interface IFormattable
type int64 = struct
    interface IConvertible
    interface ISpanFormattable
    interface IFormattable
[<System.Serializable>]
type int64 = struct
    interface IFormattable
    interface IConvertible
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type int64 = struct
    interface IFormattable
    interface IConvertible
type int64 = struct
    interface IFormattable
Public Structure Int64
Implements IComparable, IComparable(Of Long), IConvertible, IEquatable(Of Long), IFormattable
Public Structure Int64
Implements IComparable, IComparable(Of Long), IConvertible, IEquatable(Of Long), ISpanFormattable
Public Structure Int64
Implements IComparable, IConvertible, IFormattable
Public Structure Int64
Implements IComparable, IComparable(Of Long), IEquatable(Of Long), IFormattable
Héritage
Attributs
Implémente

Remarques

Int64 est un type de valeur immuable qui représente des entiers signés avec des valeurs comprises entre un 9223372036854775808 négatif (qui est représenté par la Int64.MinValue constante) et un 9 223 372 036 854 775 807 positif (qui est représenté par la Int64.MaxValue constante. le .NET Framework comprend également un type valeur entier 64 bits non signé, UInt64 , qui représente des valeurs comprises entre 0 et 18446744073709551615.

Instanciation d’une valeur Int64

Vous pouvez instancier une Int64 valeur de plusieurs façons :

  • Vous pouvez déclarer une Int64 variable et lui assigner une valeur entière littérale comprise dans la plage du Int64 type de données. L’exemple suivant déclare deux Int64 variables et leur assigne des valeurs de cette façon.

    long number1 = -64301728;
    long number2 = 255486129307;
    
    Dim number1 As Long = -64301728
    Dim number2 As Long = 255486129307
    
  • Vous pouvez assigner la valeur d’un type intégral dont la plage est un sous-ensemble du Int64 type. Il s’agit d’une conversion étendue qui ne nécessite pas d’opérateur de cast en C# ou de méthode de conversion dans Visual Basic.

    sbyte value1 = 124;
    short value2 = 1618;
    int value3 = Int32.MaxValue;
    
    long number1 = value1;
    long number2 = value2;
    long number3 = value3;
    
    Dim value1 As SByte = 124
    Dim value2 As Int16 = 1618
    Dim value3 As Int32 = Int32.MaxValue
    
    Dim number1 As Long = value1
    Dim number2 As Long = value2
    Dim number3 As Long = value3
    
  • Vous pouvez assigner la valeur d’un type numérique dont la plage dépasse celle du Int64 type. il s’agit d’une conversion restrictive. il requiert donc un opérateur de cast en C# et une méthode de conversion dans Visual Basic si Option Strict est activé. Si la valeur numérique est une Single Double valeur, ou Decimal qui comprend un composant fractionnaire, la gestion de sa partie fractionnaire dépend du compilateur effectuant la conversion. L’exemple suivant effectue des conversions restrictives pour assigner plusieurs valeurs numériques à des Int64 variables.

    ulong ulNumber = 163245617943825;
    try {
       long number1 = (long) ulNumber;
       Console.WriteLine(number1);
    }
    catch (OverflowException) {
       Console.WriteLine("{0} is out of range of an Int64.", ulNumber);
    }
    
    double dbl2 = 35901.997;
    try {
       long number2 = (long) dbl2;
       Console.WriteLine(number2);
    }
    catch (OverflowException) {
       Console.WriteLine("{0} is out of range of an Int64.", dbl2);
    }
    
    BigInteger bigNumber = (BigInteger) 1.63201978555e30;
    try {
       long number3 = (long) bigNumber;
       Console.WriteLine(number3);
    }
    catch (OverflowException) {
       Console.WriteLine("{0} is out of range of an Int64.", bigNumber);
    }
    // The example displays the following output:
    //    163245617943825
    //    35902
    //    1,632,019,785,549,999,969,612,091,883,520 is out of range of an Int64.
    
    Dim ulNumber As ULong = 163245617943825
    Try
       Dim number1 As Long = CLng(ulNumber)
       Console.WriteLine(number1)
    Catch e As OverflowException
       Console.WriteLine("{0} is out of range of an Int64.", ulNumber)
    End Try
    
    Dim dbl2 As Double = 35901.997
    Try
       Dim number2 As Long = CLng(dbl2)
       Console.WriteLine(number2)
    Catch e As OverflowException
       Console.WriteLine("{0} is out of range of an Int64.", dbl2)
    End Try
       
    Dim bigNumber As BigInteger = 1.63201978555e30
    Try
       Dim number3 As Long = CLng(bigNumber)
       Console.WriteLine(number3)
    Catch e As OverflowException
       Console.WriteLine("{0:N0} is out of range of an Int64.", bigNumber)
    End Try    
    ' The example displays the following output:
    '    163245617943825
    '    35902
    '    1,632,019,785,549,999,969,612,091,883,520 is out of range of an Int64.
    
  • Vous pouvez appeler une méthode de la Convert classe pour convertir n’importe quel type pris en charge en une Int64 valeur. Cela est possible parce que Int64 prend en charge l' IConvertible interface. L’exemple suivant illustre la conversion d’un tableau de Decimal valeurs en Int64 valeurs.

    decimal[] values= { Decimal.MinValue, -1034.23m, -12m, 0m, 147m,
                        199.55m, 9214.16m, Decimal.MaxValue };
    long result;
    
    foreach (decimal value in values)
    {
       try {
          result = Convert.ToInt64(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 Int64 type.",
                            value);
       }
    }
    // The example displays the following output:
    //    -79228162514264337593543950335 is outside the range of the Int64 type.
    //    Converted the Decimal value '-1034.23' to the Int64 value -1034.
    //    Converted the Decimal value '-12' to the Int64 value -12.
    //    Converted the Decimal value '0' to the Int64 value 0.
    //    Converted the Decimal value '147' to the Int64 value 147.
    //    Converted the Decimal value '199.55' to the Int64 value 200.
    //    Converted the Decimal value '9214.16' to the Int64 value 9214.
    //    79228162514264337593543950335 is outside the range of the Int64 type.
    
    Dim values() As Decimal = { Decimal.MinValue, -1034.23d, -12d, 0d, 147d, _
                                199.55d, 9214.16d, Decimal.MaxValue }
    Dim result As Long
    
    For Each value As Decimal In values
       Try
          result = Convert.ToInt64(value)
          Console.WriteLine("Converted the {0} value '{1}' to the {2} value {3}.", _
                            value.GetType().Name, value, _
                            result.GetType().Name, result)
       Catch e As OverflowException
          Console.WriteLine("{0} is outside the range of the Int64 type.", _
                            value)
       End Try
    Next
    ' The example displays the following output:
    '    -79228162514264337593543950335 is outside the range of the Int64 type.
    '    Converted the Decimal value '-1034.23' to the Int64 value -1034.
    '    Converted the Decimal value '-12' to the Int64 value -12.
    '    Converted the Decimal value '0' to the Int64 value 0.
    '    Converted the Decimal value '147' to the Int64 value 147.
    '    Converted the Decimal value '199.55' to the Int64 value 200.
    '    Converted the Decimal value '9214.16' to the Int64 value 9214.
    '    79228162514264337593543950335 is outside the range of the Int64 type.
    
  • Vous pouvez appeler la Parse TryParse méthode ou pour convertir la représentation sous forme de chaîne d’une Int64 valeur en Int64 . La chaîne peut contenir des chiffres décimaux ou hexadécimaux. L’exemple suivant illustre l’opération d’analyse à l’aide d’une chaîne décimale et d’une chaîne hexadécimale.

    string string1 = "244681903147";
    try {
       long number1 = Int64.Parse(string1);
       Console.WriteLine(number1);
    }
    catch (OverflowException) {
       Console.WriteLine("'{0}' is out of range of a 64-bit integer.", string1);
    }
    catch (FormatException) {
       Console.WriteLine("The format of '{0}' is invalid.", string1);
    }
    
    string string2 = "F9A3CFF0A";
    try {
       long number2 = Int64.Parse(string2,
                                  System.Globalization.NumberStyles.HexNumber);
       Console.WriteLine(number2);
    }
    catch (OverflowException) {
       Console.WriteLine("'{0}' is out of range of a 64-bit integer.", string2);
    }
    catch (FormatException) {
       Console.WriteLine("The format of '{0}' is invalid.", string2);
    }
    // The example displays the following output:
    //    244681903147
    //    67012198154
    
    Dim string1 As String = "244681903147"
    Try
       Dim number1 As Long = Int64.Parse(string1)
       Console.WriteLine(number1)
    Catch e As OverflowException
       Console.WriteLine("'{0}' is out of range of a 64-bit integer.", string1)
    Catch e As FormatException
       Console.WriteLine("The format of '{0}' is invalid.", string1)
    End Try
    
    Dim string2 As String = "F9A3CFF0A"
    Try
       Dim number2 As Long = Int64.Parse(string2,
                                System.Globalization.NumberStyles.HexNumber)
       Console.WriteLine(number2)
    Catch e As OverflowException
       Console.WriteLine("'{0}' is out of range of a 64-bit integer.", string2)
    Catch e As FormatException
       Console.WriteLine("The format of '{0}' is invalid.", string2)
    End Try
    ' The example displays the following output:
    '    244681903147
    '    67012198154
    

Exécution d’opérations sur des valeurs Int64

Le Int64 type prend en charge les opérations mathématiques standard, telles que l’addition, la soustraction, la Division, la multiplication, la négation et la négation unaire. À l’instar des autres types intégraux, le Int64 type prend également en charge les opérateurs de bits AND ,,, de OR XOR décalage vers la gauche et de décalage vers la droite.

Vous pouvez utiliser les opérateurs numériques standard pour comparer deux Int64 valeurs, ou vous pouvez appeler la CompareTo Equals méthode ou.

Vous pouvez également appeler les membres de la Math classe pour effectuer une large gamme d’opérations numériques, notamment obtenir la valeur absolue d’un nombre, calculer le quotient et le reste de la Division intégrale, déterminer la valeur maximale ou minimale de deux entiers longs, obtenir le signe d’un nombre et arrondir un nombre.

Représentant un Int64 comme chaîne

Le Int64 type assure la prise en charge complète des chaînes de format numériques standard et personnalisées. (Pour plus d’informations, consultez mise en forme des types, chaînes de format numériques standardet chaînes de format numériques personnalisées.)

Pour mettre en forme une Int64 valeur sous la forme d’une chaîne intégrale sans zéro non significatif, vous pouvez appeler la méthode sans paramètre ToString() . À l’aide du spécificateur de format "D", vous pouvez également inclure un nombre spécifié de zéros non significatifs dans la représentation sous forme de chaîne. À l’aide du spécificateur de format "N", vous pouvez inclure des séparateurs de groupes et spécifier le nombre de chiffres décimaux à afficher dans la représentation sous forme de chaîne du nombre. À l’aide du spécificateur de format "X", vous pouvez représenter une Int64 valeur sous la forme d’une chaîne hexadécimale. L’exemple suivant met en forme les éléments d’un tableau de Int64 valeurs de quatre manières.

long[] numbers = { -1403, 0, 169, 1483104 };
foreach (var number in numbers) {
   // Display value using default formatting.
   Console.Write("{0,-8}  -->   ", number.ToString());
   // Display value with 3 digits and leading zeros.
   Console.Write("{0,8:D3}", number);
   // Display value with 1 decimal digit.
   Console.Write("{0,13:N1}", number);
   // Display value as hexadecimal.
   Console.Write("{0,18:X2}", number);
   // Display value with eight hexadecimal digits.
   Console.WriteLine("{0,18:X8}", number);
}
// The example displays the following output:
//    -1403     -->      -1403     -1,403.0  FFFFFFFFFFFFFA85  FFFFFFFFFFFFFA85
//    0         -->        000          0.0                00          00000000
//    169       -->        169        169.0                A9          000000A9
//    1483104   -->    1483104  1,483,104.0            16A160          0016A160
Dim numbers() As Long = { -1403, 0, 169, 1483104 }
For Each number In numbers
   ' Display value using default formatting.
   Console.Write("{0,-8}  -->   ", number.ToString())
   ' Display value with 3 digits and leading zeros.
   Console.Write("{0,8:D3}", number)
   ' Display value with 1 decimal digit.
   Console.Write("{0,13:N1}", number) 
   ' Display value as hexadecimal.
   Console.Write("{0,18:X2}", number)
   ' Display value with eight hexadecimal digits.
   Console.WriteLine("{0,18:X8}", number)
Next   
' The example displays the following output:
'    -1403     -->      -1403     -1,403.0  FFFFFFFFFFFFFA85  FFFFFFFFFFFFFA85
'    0         -->        000          0.0                00          00000000
'    169       -->        169        169.0                A9          000000A9
'    1483104   -->    1483104  1,483,104.0            16A160          0016A160

Vous pouvez également mettre en forme une Int64 valeur sous la forme d’une chaîne binaire, octale, décimale ou hexadécimale en appelant la ToString(Int64, Int32) méthode et en fournissant la base comme deuxième paramètre de la méthode. L’exemple suivant appelle cette méthode pour afficher les représentations binaires, octales et hexadécimales d’un tableau de valeurs entières.

long[] numbers = { -146, 11043, 2781913 };
foreach (var number in numbers) {
   Console.WriteLine("{0} (Base 10):", number);
   Console.WriteLine("   Binary:  {0}", Convert.ToString(number, 2));
   Console.WriteLine("   Octal:   {0}", Convert.ToString(number, 8));
   Console.WriteLine("   Hex:     {0}\n", Convert.ToString(number, 16));
}
// The example displays the following output:
//    -146 (Base 10):
//       Binary:  1111111111111111111111111111111111111111111111111111111101101110
//       Octal:   1777777777777777777556
//       Hex:     ffffffffffffff6e
//
//    11043 (Base 10):
//       Binary:  10101100100011
//       Octal:   25443
//       Hex:     2b23
//
//    2781913 (Base 10):
//       Binary:  1010100111001011011001
//       Octal:   12471331
//       Hex:     2a72d9
Dim numbers() As Long = { -146, 11043, 2781913 }
For Each number In numbers
   Console.WriteLine("{0} (Base 10):", number)
   Console.WriteLine("   Binary:  {0}", Convert.ToString(number, 2))
   Console.WriteLine("   Octal:   {0}", Convert.ToString(number, 8))
   Console.WriteLine("   Hex:     {0}", Convert.ToString(number, 16))
   Console.WriteLine()
Next      
' The example displays the following output:
'    -146 (Base 10):
'       Binary:  1111111111111111111111111111111111111111111111111111111101101110
'       Octal:   1777777777777777777556
'       Hex:     ffffffffffffff6e
'
'    11043 (Base 10):
'       Binary:  10101100100011
'       Octal:   25443
'       Hex:     2b23
'
'    2781913 (Base 10):
'       Binary:  1010100111001011011001
'       Octal:   12471331
'       Hex:     2a72d9

Utilisation de valeurs entières 32 bits non décimales

En plus d’utiliser des entiers longs individuels comme valeurs décimales, vous pouvez effectuer des opérations au niveau du bit avec des valeurs entières longues ou utiliser les représentations binaires ou hexadécimales des valeurs entières longues. Int64 les valeurs sont représentées dans 63 bits, avec le bit soixante-quatrième utilisé comme bit de signe. Les valeurs positives sont représentées à l’aide de la représentation « signe and magnitude ». Les valeurs négatives sont dans la représentation du complément à deux. Il est important de garder à l’esprit que lorsque vous effectuez des opérations au niveau du bit sur des Int64 valeurs ou lorsque vous utilisez des bits individuels. Pour effectuer une opération numérique, booléenne ou de comparaison sur deux valeurs non décimales, les deux valeurs doivent utiliser la même représentation.

Champs

MaxValue

Représente la plus grande valeur possible d'un Int64. Ce champ est constant.

MinValue

Représente la plus petite valeur possible de Int64. Ce champ est constant.

Méthodes

CompareTo(Int64)

Compare cette instance à un entier 64 bits signé et retourne une indication de leurs valeurs relatives.

CompareTo(Object)

Compare cette instance à un objet spécifié et retourne une indication de leurs valeurs relatives.

Equals(Int64)

Retourne une valeur indiquant si cette instance est égale à une valeur Int64 spécifiée.

Equals(Object)

Retourne une valeur indiquant si cette instance équivaut à un objet spécifié.

GetHashCode()

Retourne le code de hachage de cette instance.

GetTypeCode()

Retourne le TypeCode du type valeur Int64.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Convertit la représentation sous forme de plage d'un nombre dans un style et un format propre à une culture spécifiés en entier 64 bits signé équivalent.

Parse(String)

Convertit la représentation sous forme de chaîne d'un nombre en son équivalent entier 64 bits signé.

Parse(String, IFormatProvider)

Convertit la représentation d'un nombre sous forme de chaîne dans un format propre à une culture spécifié en entier 64 bits signé équivalent.

Parse(String, NumberStyles)

Convertit une représentation d'un nombre sous forme de chaîne dans un style spécifié en entier 64 bits signé équivalent.

Parse(String, NumberStyles, IFormatProvider)

Convertit la représentation sous forme de chaîne d'un nombre dans un style et un format propre à une culture spécifiés en entier 64 bits signé équivalent.

ToString()

Convertit la valeur numérique de cette instance en sa représentation équivalente sous forme de chaîne.

ToString(IFormatProvider)

Convertit la valeur numérique de cette instance en sa représentation sous forme de chaîne équivalente à l'aide des informations de format spécifiques à la culture donnée.

ToString(String)

Convertit la valeur numérique de cette instance en sa représentation sous forme de chaîne équivalente en utilisant le format spécifié.

ToString(String, IFormatProvider)

Convertit la valeur numérique de cette instance en sa représentation sous forme de chaîne équivalente à l'aide du format spécifié et des informations de format spécifiques à la culture.

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Tente de mettre en forme la valeur de l’instance de nombre long actuelle dans la plage de caractères fournie.

TryParse(ReadOnlySpan<Char>, Int64)

Convertit la représentation sous forme de plage d’un nombre en son entier signé 64 bits équivalent. Une valeur de retour indique si la conversion a réussi ou a échoué.

TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Int64)

Convertit la représentation sous forme de plage d'un nombre dans un style et un format propre à une culture spécifiés en entier 64 bits signé équivalent. Une valeur de retour indique si la conversion a réussi ou a échoué.

TryParse(String, Int64)

Convertit la représentation sous forme de chaîne d'un nombre en son équivalent entier 64 bits signé. Une valeur de retour indique si la conversion a réussi ou a échoué.

TryParse(String, NumberStyles, IFormatProvider, Int64)

Convertit la représentation sous forme de chaîne d'un nombre dans un style et un format propre à une culture spécifiés en entier 64 bits signé équivalent. Une valeur de retour indique si la conversion a réussi ou a échoué.

Implémentations d’interfaces explicites

IComparable.CompareTo(Object)

Compare cette instance à un objet spécifié et retourne une indication de leurs valeurs relatives.

IConvertible.GetTypeCode()

Retourne le TypeCode du type valeur Int64.

IConvertible.ToBoolean(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToBoolean(IFormatProvider).

IConvertible.ToByte(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToByte(IFormatProvider).

IConvertible.ToChar(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToChar(IFormatProvider).

IConvertible.ToDateTime(IFormatProvider)

Cette conversion n'est pas prise en charge. Toute tentative d'utilisation de cette méthode lève une InvalidCastException.

IConvertible.ToDecimal(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToDecimal(IFormatProvider).

IConvertible.ToDouble(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToDouble(IFormatProvider).

IConvertible.ToInt16(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToInt16(IFormatProvider).

IConvertible.ToInt32(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToInt32(IFormatProvider).

IConvertible.ToInt64(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToInt64(IFormatProvider).

IConvertible.ToSByte(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToSByte(IFormatProvider).

IConvertible.ToSingle(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToSingle(IFormatProvider).

IConvertible.ToType(Type, IFormatProvider)

Pour obtenir une description de ce membre, consultez ToType(Type, IFormatProvider).

IConvertible.ToUInt16(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToUInt16(IFormatProvider).

IConvertible.ToUInt32(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToUInt32(IFormatProvider).

IConvertible.ToUInt64(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToUInt64(IFormatProvider).

S’applique à

Cohérence de thread

Tous les membres de ce type sont thread-safe. Les membres qui semblent modifier l’état de l’instance retournent en fait une nouvelle instance initialisée avec la nouvelle valeur. Comme pour tout autre type, la lecture et l’écriture dans une variable partagée qui contient une instance de ce type doivent être protégées par un verrou pour garantir la sécurité des threads.

Voir aussi