Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

Int64 structure

 

Date de publication : novembre 2016

Représente un entier signé 64 bits.

Espace de noms:   System
Assembly:  mscorlib (dans mscorlib.dll)

[SerializableAttribute]
[ComVisibleAttribute(true)]
public struct Int64 : IComparable, IFormattable, IConvertible, 
	IComparable<long>, IEquatable<long>

NomDescription
System_CAPS_pubmethodCompareTo(Int64)

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

System_CAPS_pubmethodCompareTo(Object)

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

System_CAPS_pubmethodEquals(Int64)

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

System_CAPS_pubmethodEquals(Object)

Retourne une valeur indiquant si cette instance équivaut à un objet spécifié.(Remplace ValueType.Equals(Object).)

System_CAPS_pubmethodGetHashCode()

Retourne le code de hachage de cette instance.(Remplace ValueType.GetHashCode().)

System_CAPS_pubmethodGetType()

Obtient le Type de l'instance actuelle.(Hérité de Object.)

System_CAPS_pubmethodGetTypeCode()

Retourne le TypeCode du type valeur Int64.

System_CAPS_pubmethodSystem_CAPS_staticParse(String)

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

System_CAPS_pubmethodSystem_CAPS_staticParse(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.

System_CAPS_pubmethodSystem_CAPS_staticParse(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.

System_CAPS_pubmethodSystem_CAPS_staticParse(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.

System_CAPS_pubmethodToString()

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

System_CAPS_pubmethodToString(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.

System_CAPS_pubmethodToString(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é.

System_CAPS_pubmethodToString(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.

System_CAPS_pubmethodSystem_CAPS_staticTryParse(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é.

System_CAPS_pubmethodSystem_CAPS_staticTryParse(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é.

NomDescription
System_CAPS_pubfieldSystem_CAPS_staticMaxValue

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

System_CAPS_pubfieldSystem_CAPS_staticMinValue

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

NomDescription
System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToBoolean(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToBoolean.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToByte(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToByte.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToChar(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToChar.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDateTime(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Cette conversion n'est pas prise en charge. Toute tentative d'utilisation de cette méthode lève une InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDecimal(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToDecimal.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDouble(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToDouble.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt16(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToInt16.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt32(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToInt32.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt64(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToInt64.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSByte(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToSByte.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSingle(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToSingle.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToType(Type, IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToType.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt16(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToUInt16.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt32(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToUInt32.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt64(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToUInt64.

System_CAPS_noteRemarque

Pour afficher le code source .NET Framework pour ce type, consultez la Reference Source. Vous pouvez parcourir le code source en ligne, télécharger la référence hors connexion et parcourir les sources (y compris les correctifs et mises à jour) pendant le débogage ; see instructions.

Int64 est un type immuable qui représente des entiers signés dont les valeurs comprises entre 9,223,372,036,854,775,808 négatives (qui est représenté par la Int64.MinValue constant) à 9,223,372,036,854,775,807 positif (ce qui est représenté par la Int64.MaxValue constante. Le .NET Framework inclut également un type de valeur d’entier 64 bits non signé, UInt64, qui représente des valeurs comprises entre 0 et 18,446,744,073,709,551,615.

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

  • Vous pouvez déclarer une Int64 variable et lui assigner une valeur de littéral entier qui se trouve dans la plage de la Int64 type de données. L’exemple suivant déclare deux Int64 variables et leur affecte des valeurs de cette façon.

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

    sbyte value1 = 124;
    short value2 = 1618;
    int value3 = Int32.MaxValue;
    
    long number1 = value1;
    long number2 = value2;
    long number3 = value3;
    
  • Vous pouvez affecter la valeur d’un type numérique dont la plage dépasse celle de la Int64 type. Ceci est une conversion restrictive, elle nécessite un opérateur de cast en c# et en Visual Basic, une méthode de conversion si OptionStrict sur. Si la valeur numérique est un Single, Double, ou Decimal valeur qui inclut un composant fractionnaire, la gestion de sa partie fractionnaire dépend du compilateur qui effectue la conversion. L’exemple suivant effectue des conversions restrictives pour assigner plusieurs valeurs numériques aux 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.
    
  • Vous pouvez appeler une méthode de la Convert classe pour convertir une prise en charge de type à un Int64 valeur. Cela est possible, car Int64 prend en charge la IConvertible interface. L’exemple suivant illustre la conversion d’un tableau de Decimal valeurs 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.
    
  • Vous pouvez appeler la Parse ou TryParse méthode pour convertir la représentation sous forme de chaîne d’un Int64 valeur à un Int64. La chaîne peut contenir des chiffres décimales ou hexadécimales. L’exemple suivant illustre l’opération d’analyse à l’aide d’un nombre décimal et 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
    

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

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

Vous pouvez également appeler les membres de la Math classe à exécuter un large éventail d’opérations numériques, y compris l’obtention de la valeur absolue d’un nombre, en calculant le quotient et le reste de la division intégrale, déterminer la valeur minimale ou maximale de deux entiers longs, obtenir le signe d’un nombre et arrondir un nombre.

Le Int64 type prend en charge les chaînes de format numériques standard et personnalisées. (Pour plus d’informations, consultez Mise en forme des types dans .NET Framework, Chaînes de format numériques standard, et Chaînes de format numériques personnalisées.)

Pour mettre en forme un Int64 valeur de chaîne d’entier sans zéros non significatifs, vous pouvez appeler la méthode sans paramètre ToString() méthode. En utilisant le 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. En utilisant le spécificateur de format « N », vous pouvez inclure des séparateurs de groupe et spécifier le nombre de décimales à afficher dans la représentation sous forme de chaîne du nombre. En utilisant le spécificateur de format « X », vous pouvez représenter une Int64 valeur sous forme de chaîne hexadécimale. L’exemple suivant met en forme les éléments dans un tableau de Int64 les valeurs de ces 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

Vous pouvez également mettre en forme un Int64 valeur sous forme binaire, octal, décimale ou hexadécimale chaîne en appelant le ToString(Int64, Int32) (méthode) et en fournissant la base en tant que second paramètre de la méthode. L’exemple suivant appelle cette méthode pour afficher le fichier binaire, octal et les représentations 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

En plus des entiers longs en tant que valeurs décimales, vous souhaiterez peut-être effectuer des opérations au niveau du bit 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 en 63 bits, le bit de soixante quart utilisé comme bit de signe. Les valeurs positives sont représentées à l’aide de représentation « signe et magnitude ». Les valeurs négatives sont dans la représentation de complément à deux. Il est important de garder à l’esprit lorsque vous effectuez des opérations au niveau du bit sur Int64 valeurs ou lorsque vous travaillez avec des bits. Pour effectuer une valeur numérique, booléen ou opération de comparaison sur deux valeurs non décimales, les deux valeurs doivent utiliser la même représentation.

Plateforme Windows universelle
Disponible depuis 8
.NET Framework
Disponible depuis 1.1
Bibliothèque de classes portable
Pris en charge dans : plateformes .NET portables
Silverlight
Disponible depuis 2.0
Silverlight pour Windows Phone
Disponible depuis 7.0
Windows Phone
Disponible depuis 8.1

Tous les membres de ce type sont thread-safe. En réalité, les membres qui semblent modifier l'état de l'instance renvoie une nouvelle instance initialisée avec la nouvelle valeur. Comme avec tout autre type, la lecture et l'écriture sur 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.

System_CAPS_cautionAttention

Affectation d’une instance de ce type n’est pas thread-safe sur toutes les plateformes matérielles car la représentation binaire de cette instance peut être trop volumineuse pour affecter en une seule opération atomique.

Retour au début
Afficher: