System.Int64 struktúra

Megjegyzés:

Ez a cikk kiegészítő megjegyzéseket tartalmaz az API referenciadokumentációjához.

Int64 egy nem módosítható értéktípus, amely a -9 223 372 036 854 775 808 (amelyet a Int64.MinValue konstans jelöl) és a +9 223 372 036 854 775 807 (amelyet a Int64.MaxValue konstans jelöl) közötti értékeket képviseli. A .NET tartalmaz egy aláíratlan 64 bites egész számtípust is, UInt64amely a 0 és 18 446 744 073 709 551 615 közötti értékeket jelöli.

Int64-érték példányosítása

Az Int64 értéket többféleképpen is létrehozhatja.

  • Deklarálhat egy változót Int64 , és az adattípus tartományán belüli literális egész számértéket rendelhet hozzá Int64 . Az alábbi példa két Int64 változót deklarál, és így rendeli hozzájuk az értékeket.

    long number1 = -64301728;
long number2 = 255486129307;

    let number1 = -64301728L
let number2 = 255486129307L

    Dim number1 As Long = -64301728
Dim number2 As Long = 255486129307

  • Olyan integráltípus értékét rendelheti hozzá, amelynek tartománya a Int64 típus egy részhalmaza. Ez egy olyan szélesítő átalakítás, amely nem igényel típusátalakító operátort C#-ban vagy átalakítási metódust a Visual Basic nyelvben. Az F#-ban csak a Int32 típus bővíthető automatikusan.

    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

  • Olyan numerikus típus értékét rendelheti hozzá, amelynek tartománya meghaladja a Int64 típus értékét. Ez egy szűkítő átalakítás, ezért kötelező a C# vagy F# típus átalakító operátora, valamint a Visual Basic konverziós metódusa, ha a Option Strict be van kapcsolva. Ha a numerikus érték egy Single, Double vagy Decimal törtösszetevőt tartalmazó érték, a törtrész kezelése az átalakítást végző fordítótól függ. Az alábbi példa szűkítő konverziókat hajt végre, hogy több numerikus értéket rendeljen a változókhoz Int64 .

    ulong ulNumber = 163245617943825;
try {
   long number1 = (long) ulNumber;
   Console.WriteLine(number1);
}
catch (OverflowException) {
   Console.WriteLine($"{ulNumber} is out of range of an Int64.");
}

double dbl2 = 35901.997;
try {
   long number2 = (long) dbl2;
   Console.WriteLine(number2);
}
catch (OverflowException) {
   Console.WriteLine($"{dbl2} is out of range of an Int64.");
}

BigInteger bigNumber = (BigInteger) 1.63201978555e30;
try {
   long number3 = (long) bigNumber;
   Console.WriteLine(number3);
}
catch (OverflowException) {
   Console.WriteLine($"{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.

    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.

  • Az osztály metódusát Convert meghívva bármilyen támogatott típust átalakíthat értékké Int64 . Ez azért lehetséges, mert Int64 támogatja a IConvertible felületet. Az alábbi példa egy Decimal értéktömb Int64 értékekké alakítását szemlélteti.

    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 {value.GetType().Name} value '{value}' to the {result.GetType().Name} value {result}.");
   }
   catch (OverflowException) {
      Console.WriteLine($"{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.

    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.

  • Meghívhatja a Parse vagy TryParse metódust, amely az Int64 érték sztringképét átalakítja egy Int64 típusú értékké. A sztring decimális vagy hexadecimális számjegyeket tartalmazhat. Az alábbi példa egy decimális és egy hexadecimális sztring használatával szemlélteti az elemzési műveletet.

    string string1 = "244681903147";
try {
   long number1 = Int64.Parse(string1);
   Console.WriteLine(number1);
}
catch (OverflowException) {
   Console.WriteLine($"'{string1}' is out of range of a 64-bit integer.");
}
catch (FormatException) {
   Console.WriteLine($"The format of '{string1}' is invalid.");
}

string string2 = "F9A3CFF0A";
try {
   long number2 = Int64.Parse(string2,
                              System.Globalization.NumberStyles.HexNumber);
   Console.WriteLine(number2);
}
catch (OverflowException) {
   Console.WriteLine($"'{string2}' is out of range of a 64-bit integer.");
}
catch (FormatException) {
   Console.WriteLine($"The format of '{string2}' is invalid.");
}
// 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

Műveletek végrehajtása Int64-értékeken

A Int64 típus támogatja a standard matematikai műveleteket, például az összeadást, kivonást, osztást, szorzást, negációt és unary negationt. A többi integráltípushoz hasonlóan a Int64 típus is támogatja a bitenkénti AND, OR, a balra tolás és a jobbra tolás operátorokat.

A standard numerikus operátorok segítségével összehasonlíthat két Int64 értéket, vagy meghívhatja a metódustCompareTo.Equals

Az osztály Math tagjait széles körű numerikus műveletek elvégzésére is meghívhatod, beleértve a szám abszolút értékének lekérését, az egész számok osztásából származó hányados és maradék kiszámítását, két hosszú egész szám maximális vagy minimális értékének meghatározását, egy szám jelének megállapítását és egy szám kerekítését.

Int64 sztringként való ábrázolása

A Int64 típus teljes körű támogatást nyújt a szabványos és egyéni numerikus formátumú sztringekhez. (További információ: Formázástípusok, Standard numerikus formázási sztringek és egyéni numerikus formázási sztringek.)

Ha egy Int64 értéket bevezető nullák nélküli integrál sztringként szeretne formázni, meghívhatja a paraméter nélküli ToString() metódust. A "D" formátumkijelölővel megadott számú kezdő nullát is felvehet a sztringábrázolásba. Az "N" formátumkijelölő használatával csoportelválasztókat is megadhat, és megadhatja a szám sztringképében megjelenítendő tizedesjegyek számát. Az "X" formátumjelölővel egy Int64 értéket hexadecimális karakterláncként ábrázolhat. Az alábbi példa az értékek tömbjében Int64 lévő elemeket a következő négy módon formázja.

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

Az értékeket bináris, oktális, decimális vagy hexadecimális sztringként is formázhatja Int64 úgy, hogy meghívja a ToString(Int64, Int32) metódust, és megadja az alapot a metódus második paramétereként. Az alábbi példa ezt a metódust meghívja egy egész számból álló tömb bináris, oktális és hexadecimális ábrázolásának megjelenítésére.

long[] numbers = { -146, 11043, 2781913 };
foreach (var number in numbers)
{
    Console.WriteLine($"{number} (Base 10):");
    Console.WriteLine($"   Binary:  {Convert.ToString(number, 2)}");
    Console.WriteLine($"   Octal:   {Convert.ToString(number, 8)}");
    Console.WriteLine($"   Hex:     {Convert.ToString(number, 16)}{Environment.NewLine}");
}
// 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

Nem decimális 64 bites egész számértékek használata

Az egyes hosszú egész számok decimális értékekként való használata mellett érdemes lehet bitenkénti műveleteket végezni, vagy a hosszú egész értékek bináris vagy hexadecimális ábrázolásával dolgozni. Int64 az értékek 63 bitben jelennek meg, és a hatvannegyedik bitet jelbitként használják. A pozitív értékeket a jelek és a nagyság ábrázolásával jelöljük. A negatív értékek két komplementer ábrázolásban vannak. Ezt fontos szem előtt tartani, amikor bitenkénti műveleteket hajt végre az értékeken Int64 , vagy amikor egyéni bitekkel dolgozik. Ha numerikus, logikai vagy összehasonlító műveletet szeretne végrehajtani két nem decimális értéken, mindkét értéknek ugyanazt a reprezentációt kell használnia.

  • Last updated on