Int64 Structure
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
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;
let number1 = -64301728L let number2 = 255486129307L
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. En F #, seul le Int32 type peut être élargi automatiquement.
sbyte value1 = 124; short value2 = 1618; int value3 = Int32.MaxValue; long number1 = value1; long number2 = value2; long number3 = value3;
let value1 = 124y let value2 = 1618s let value3 = Int32.MaxValue let number1 = int64 value1 let number2 = int64 value2 let number3: int64 = 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# ou F # 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.
let ulNumber = 163245617943825uL try let number1 = int64 ulNumber printfn $"{number1}" with :? OverflowException -> printfn $"{ulNumber} is out of range of an Int64." let dbl2 = 35901.997 try let number2 = int64 dbl2 printfn $"{number2}" with :? OverflowException -> printfn $"{dbl2} is out of range of an Int64." let bigNumber = BigInteger 1.63201978555e30 try let number3 = int64 bigNumber printfn $"{number3}" with :? OverflowException -> printfn $"{bigNumber} is out of range of an Int64." // 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.
let values= [| Decimal.MinValue; -1034.23M; -12M; 0M; 147M 199.55M; 9214.16M; Decimal.MaxValue |] for value in values do try let result = Convert.ToInt64 value printfn $"Converted the {value.GetType().Name} value '{value}' to the {result.GetType().Name} value {result}." with :? OverflowException -> printfn $"{value} is outside the range of the Int64 type." // 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
let string1 = "244681903147" try let number1 = Int64.Parse string1 printfn $"{number1}" with | :? OverflowException -> printfn $"'{string1}' is out of range of a 64-bit integer." | :? FormatException -> printfn $"The format of '{string1}' is invalid." let string2 = "F9A3CFF0A" try let number2 = Int64.Parse(string2, NumberStyles.HexNumber) printfn $"{number2}" with | :? OverflowException -> printfn $"'{string2}' is out of range of a 64-bit integer." | :? FormatException -> printfn $"The format of '{string2}' is invalid." // 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
let numbers = [| -1403L; 0L; 169L; 1483104L |]
for number in numbers do
// Display value using default formatting.
printf $"{number.ToString(),-8} --> "
// Display value with 3 digits and leading zeros.
printf $"{number,8:D3}"
// Display value with 1 decimal digit.
printf $"{number,13:N1}"
// Display value as hexadecimal.
printf $"{number,18:X2}"
// Display value with eight hexadecimal digits.
printfn $"{number,18:X8}"
// 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
let numbers = [| -146L; 11043L; 2781913L |]
for number in numbers do
printfn $"{number} (Base 10):"
printfn $" Binary: {Convert.ToString(number, 2)}"
printfn $" Octal: {Convert.ToString(number, 8)}"
printfn $" Hex: {Convert.ToString(number, 16)}\n"
// 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() | |
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
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.