Przeczytaj w języku angielskim

Udostępnij za pośrednictwem

System.Int64, struktura

  • Artykuł

Ten artykuł zawiera dodatkowe uwagi dotyczące dokumentacji referencyjnej dla tego interfejsu API.

Int64 jest niezmiennym typem wartości reprezentującym podpisane liczby całkowite z wartościami, które wahają się od ujemnych 9223 372 036 854 775 808 (co jest reprezentowane przez stałą Int64.MinValue ) przez dodatnie 923 372 036 854 775 807 (co jest reprezentowane przez stałą Int64.MaxValue ). Platforma .NET zawiera również niepodpisany 64-bitowy typ wartości całkowitej, UInt64który reprezentuje wartości z zakresu od 0 do 18 446 744 073 709 551 615.

Tworzyć instancję wartości Int64

Możesz zadać wartość Int64 na kilka sposobów:

  • Można zadeklarować zmienną Int64 i przypisać jej literał wartości całkowitej, który mieści się w zakresie typu danych Int64. Poniższy przykład deklaruje dwie zmienne Int64 i przypisuje im wartości w ten sposób.

    C# 
    long number1 = -64301728;
long number2 = 255486129307;

  • Można przypisać wartość typu całkowitego, którego zakres jest podzbiorem Int64 typu. Jest to konwersja rozszerzająca, która nie wymaga operatora rzutowania w języku C# ani metody konwersji w Visual Basic. W języku F#tylko Int32 typ można rozszerzyć automatycznie.

    C# 
    sbyte value1 = 124;
short value2 = 1618;
int value3 = Int32.MaxValue;

long number1 = value1;
long number2 = value2;
long number3 = value3;

  • Można przypisać wartość typu liczbowego, którego zakres przekracza ten typ Int64. Jest to konwersja zawężająca, dlatego wymaga operatora rzutowania w języku C# lub F# oraz metody konwersji w języku Visual Basic, jeśli Option Strict jest włączona. Jeśli wartość liczbowa jest wartością Single, Doublelub Decimal wartością zawierającą składnik ułamkowy, obsługa jej części ułamkowej zależy od kompilatora wykonującego konwersję. W poniższym przykładzie wykonywane są konwersje zawężające, aby przypisać kilka liczb do zmiennych Int64.

    C# 
    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.

  • Możesz wywołać metodę klasy Convert, aby przekonwertować dowolny obsługiwany typ na wartość Int64. Jest to możliwe, ponieważ Int64 obsługuje interfejs IConvertible. Poniższy przykład ilustruje konwersję tablicy wartości Decimal na wartości Int64.

    C# 
    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.

  • Możesz wywołać metodę Parse lub TryParse, aby przekonwertować reprezentację ciągu wartości Int64 na Int64. Ciąg może zawierać cyfry dziesiętne lub szesnastkowe. Poniższy przykład ilustruje operację analizowania przy użyciu zarówno ciągu dziesiętnego, jak i szesnastkowego.

    C# 
    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

Wykonywanie operacji na wartościach Int64

Typ Int64 obsługuje standardowe operacje matematyczne, takie jak dodawanie, odejmowanie, dzielenie, mnożenie, negacja i negacja jednoargumentowa. Podobnie jak inne typy całkowite, typ Int64 obsługuje również operatory bitowych AND, OR, XOR, przesunięcia w lewo i w prawo.

Można użyć standardowych operatorów liczbowych do porównania dwóch wartości Int64 lub wywołać metodę CompareTo lub Equals.

Można również wywołać członków klasy Math, aby wykonać szeroki zakres operacji liczbowych, w tym uzyskanie wartości bezwzględnej liczby, obliczenie ilorazu i reszty z dzielenia całkowitego, określenie maksymalnej lub minimalnej wartości dwóch liczb całkowitych typu long, uzyskanie znaku liczby oraz jej zaokrąglenie.

Reprezentowanie int64 jako ciągu

Typ Int64 zapewnia pełną obsługę standardowych i niestandardowych ciągów formatu liczbowego. (Aby uzyskać więcej informacji, zobacz typy formatowania , standardowych ciągów formatu liczbowegoi niestandardowych ciągów formatu liczbowego.)

Aby sformatować wartość Int64 jako ciąg całkowity bez zer wiodących, możesz wywołać metodę ToString() bez parametrów. Używając specyfikatora formatu "D", można również uwzględnić określoną liczbę zer wiodących w reprezentacji ciągu. Używając specyfikatora formatu "N", można uwzględnić separatory grup i określić liczbę cyfr dziesiętnych, które mają być wyświetlane w ciągu reprezentującym liczbę. Używając specyfikatora formatu "X", można reprezentować wartość Int64 jako ciąg szesnastkowy. Poniższy przykład formatuje elementy w tablicy wartości Int64 na te cztery sposoby.

C# 
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

Można również sformatować wartość Int64 jako ciąg binarny, ósemkowy, dziesiętny lub szesnastkowy, wywołując metodę ToString(Int64, Int32) i podając bazę jako drugi parametr metody. Poniższy przykład wywołuje tę metodę, aby wyświetlić reprezentacje binarne, ósemkowe i szesnastkowe tablicy wartości całkowitych.

C# 
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

Operowanie na nie-dziesiętnych 32-bitowych wartościach całkowitych

Oprócz pracy z poszczególnymi długimi liczbami całkowitymi jako wartościami dziesiętnymi możesz wykonywać operacje bitowe z długimi wartościami całkowitymi lub pracować z reprezentacjami binarnymi lub szesnastkowymi wartościami liczb całkowitych. Int64 wartości są reprezentowane w 63 bitach, a sześcioty czwarty bit jest używany jako bit znaku. Wartości dodatnie są reprezentowane przy użyciu reprezentacji znaku i wielkości. Wartości ujemne znajdują się w reprezentacji dwóch uzupełnień. Ważne jest, aby mieć to na uwadze podczas wykonywania operacji bitowych na wartościach Int64 lub przy pracy z pojedynczymi bitami. Aby wykonać operację liczbową, logiczną lub porównawczą na dowolnych dwóch wartościach innych niż dziesiętne, obie wartości muszą używać tej samej reprezentacji.