Int64 Struktura

Definicja

Reprezentuje 64-bitową liczbę całkowitą ze podpisem.

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
Dziedziczenie
Atrybuty
Implementuje

Uwagi

Int64 jest niezmiennym typem wartości reprezentującym liczby całkowite ze podpisanymi liczbami całkowitymi z wartościami z zakresu od ujemnych 9 223 372 036 854 775 808 (reprezentowanych przez stałą) do dodatnich Int64.MinValue 9 223 372 036 854 775 807 (reprezentowanych przez Int64.MaxValue stałą). Element .NET Framework również typ wartości 64-bitowej liczby całkowitej bez znaku, , który reprezentuje wartości z zakresu od 0 do UInt64 18 446 744 073 709 551 615.

Wystąpienia wartości Int64

Można utworzyć wystąpienia wartości Int64 na kilka sposobów:

  • Możesz zadeklarować zmienną i przypisać do jej wartość całkowitą literału, która należy Int64 do zakresu Int64 typu danych. Poniższy przykład deklaruje dwie Int64 zmienne i przypisuje im wartości w ten sposób.

    long number1 = -64301728;
    long number2 = 255486129307;
    
    let number1 = -64301728L
    let number2 = 255486129307L
    
    Dim number1 As Long = -64301728
    Dim number2 As Long = 255486129307
    
  • Możesz przypisać wartość typu całkowitego, którego zakres jest podzbiorem Int64 typu. Jest to konwersja poszerzania, która nie wymaga operatora rzutowania w języku C# ani metody konwersji w Visual Basic. W F# tylko Int32 typ może zostać automatycznie poszerzony.

    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
    
  • Możesz przypisać wartość typu liczbowego, którego zakres przekracza zakres Int64 typu. Jest to konwersja zawężająca, więc wymaga operatora rzutowania w języku C# lub F# oraz metody konwersji w Visual Basic Option Strict jeśli jest wł. Jeśli wartość liczbowa to wartość typu , lub , która zawiera składnik ułamkowy, obsługa części ułamkowej zależy od Single Double Decimal kompilatora wykonującego konwersję. Poniższy przykład wykonuje konwersje zawężania w celu przypisania kilku wartości liczbowych Int64 do zmiennych.

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

    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.
    
  • Możesz wywołać metodę Parse lub TryParse , aby przekonwertować ciągową Int64 reprezentację wartości na Int64 . Ciąg może zawierać cyfrę dziesiętną lub szesnastkową. Poniższy przykład ilustruje operację analizowania przy użyciu zarówno ciągu dziesiętnego, jak i szesnastkowego.

    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
    

Wykonywanie operacji na wartościach Int64

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

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

Można również wywołać składowe klasy w celu wykonania szerokiego zakresu operacji liczbowych, w tym uzyskiwania wartości bezwzględnej liczby, obliczania ilorazu i reszty z dzielenia całkowitego, określania maksymalnej lub minimalnej wartości dwóch długich liczb całkowitych, uzyskiwania znaku liczby i zaokrąglania Math liczby.

Reprezentowanie typu Int64 jako ciągu

Typ Int64 zapewnia pełną obsługę standardowych i niestandardowych ciągów formatu liczb. (Aby uzyskać więcej informacji, zobacz Typy formatowania, Standardowe ciągi formatów liczbowychi Niestandardowe ciągi formatu liczbowego).

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

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

Można również sformatować wartość jako ciąg binarny, ósemkowy, dziesiętny lub szesnastkowy, wywołując metodę i dostarczając bazę jako Int64 ToString(Int64, Int32) drugi parametr metody. Poniższy przykład wywołuje tę metodę w celu wyświetlenia reprezentacji binarnych, ósemkowym i szesnastkowym tablicy wartości całkowitych.

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

Posługiwanie się niedziesiętnymi 32-bitowymi liczbami całkowitymi

Oprócz pracy z poszczególnymi długimi liczbami całkowitymi jako wartościami dziesiętnych można wykonywać operacje bitowe z długimi wartościami całkowitymi lub pracować z binarnymi lub szesnastkowymi reprezentacjami długich wartości całkowitych. Int64 Wartości są reprezentowane w 63 bitach, a sześćdziesiąty czwarty bit jest używany jako bit znaku. Wartości dodatnie są reprezentowane przy użyciu reprezentacji znaku i wielkości. Wartości ujemne są w reprezentacji dopełnień dwóch. Należy o tym pamiętać podczas wykonywania operacji bitowych na wartościach lub pracy z Int64 poszczególnymi bitami. Aby wykonać operację liczbową, logiczną lub porównywaną na dowolnej wartości niedziesiętnej, obie wartości muszą używać tej samej reprezentacji.

Pola

MaxValue

Reprezentuje największą możliwą wartość Int64 . To pole jest stałe.

MinValue

Reprezentuje najmniejszą możliwą Int64 wartość . To pole jest stałe.

Metody

CompareTo(Int64)

Porównuje to wystąpienie z określoną 64-bitową liczbą całkowitą ze podpisem i zwraca wskazanie ich wartości względnych.

CompareTo(Object)

Porównuje to wystąpienie z określonym obiektem i zwraca wskazanie ich względnych wartości.

Equals(Int64)

Zwraca wartość wskazującą, czy to wystąpienie jest równe określonej Int64 wartości.

Equals(Object)

Zwraca wartość wskazującą, czy to wystąpienie jest równe podanemu obiektowi.

GetHashCode()

Zwraca wartość skrótu dla tego wystąpienia.

GetTypeCode()

Zwraca wartość TypeCode dla typu wartości Int64 .

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Konwertuje reprezentację zakresu liczby w określonym stylu i formacie specyficznym dla kultury na równoważnik 64-bitowej liczby całkowitej ze podpisem.

Parse(String)

Konwertuje ciąg reprezentujący liczbę na równoważnik 64-bitowej liczby całkowitej ze znakem.

Parse(String, IFormatProvider)

Konwertuje ciąg reprezentujący liczbę w określonym formacie specyficznym dla kultury na 64-bitową liczbę całkowitą ze podpisem.

Parse(String, NumberStyles)

Konwertuje ciąg reprezentujący liczbę w określonym stylu na równoważnik 64-bitowej liczby całkowitej ze znakem.

Parse(String, NumberStyles, IFormatProvider)

Konwertuje ciąg reprezentujący liczbę w określonym stylu i formacie specyficznym dla kultury na 64-bitowy odpowiednik liczby całkowitej ze znakami.

ToString()

Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację w postaci ciągu.

ToString(IFormatProvider)

Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację w postaci ciągu przy użyciu podanych danych formatowania specyficznych dla kultury.

ToString(String)

Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację w postaci ciągu przy użyciu podanego formatu.

ToString(String, IFormatProvider)

Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację w postaci ciągu przy użyciu podanego formatu i informacji specyficznych dla kultury.

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

Próbuje sformatować wartość bieżącego długiego wystąpienia liczby do podanego zakresu znaków.

TryParse(ReadOnlySpan<Char>, Int64)

Konwertuje reprezentację zakresu liczby na równoważnik liczby całkowitej ze podpisem 64-bitowym. Zwracana wartość wskazuje, czy konwersja powiodła się czy nie.

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

Konwertuje reprezentację zakresu liczby w określonym stylu i formacie specyficznym dla kultury na równoważnik 64-bitowej liczby całkowitej ze podpisem. Zwracana wartość wskazuje, czy konwersja powiodła się czy nie.

TryParse(String, Int64)

Konwertuje ciąg reprezentujący liczbę na równoważnik 64-bitowej liczby całkowitej ze znakem. Zwracana wartość wskazuje, czy konwersja powiodła się czy nie.

TryParse(String, NumberStyles, IFormatProvider, Int64)

Konwertuje ciąg reprezentujący liczbę w określonym stylu i formacie specyficznym dla kultury na równoważnik 64-bitowej liczby całkowitej ze znakem. Zwracana wartość wskazuje, czy konwersja powiodła się czy nie.

Jawne implementacje interfejsu

IComparable.CompareTo(Object)

Porównuje to wystąpienie z określonym obiektem i zwraca wskazanie ich względnych wartości.

IConvertible.GetTypeCode()

Zwraca wartość TypeCode dla typu wartości Int64 .

IConvertible.ToBoolean(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToBoolean(IFormatProvider) .

IConvertible.ToByte(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToByte(IFormatProvider) .

IConvertible.ToChar(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToChar(IFormatProvider) .

IConvertible.ToDateTime(IFormatProvider)

Ta konwersja nie jest obsługiwana. Próba użycia tej metody zgłasza wyjątek InvalidCastException .

IConvertible.ToDecimal(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToDecimal(IFormatProvider) .

IConvertible.ToDouble(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToDouble(IFormatProvider) .

IConvertible.ToInt16(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToInt16(IFormatProvider) .

IConvertible.ToInt32(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToInt32(IFormatProvider) .

IConvertible.ToInt64(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToInt64(IFormatProvider) .

IConvertible.ToSByte(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToSByte(IFormatProvider) .

IConvertible.ToSingle(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToSingle(IFormatProvider) .

IConvertible.ToType(Type, IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToType(Type, IFormatProvider) .

IConvertible.ToUInt16(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToUInt16(IFormatProvider) .

IConvertible.ToUInt32(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToUInt32(IFormatProvider) .

IConvertible.ToUInt64(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToUInt64(IFormatProvider) .

Dotyczy

Bezpieczeństwo wątkowe

Wszystkie elementy członkowskie tego typu są bezpieczne wątkowo. Elementy członkowskie, które na pierwszy rzut oka modyfikują stan wystąpienia, w rzeczywistości zwracają nowe wystąpienie zainicjowane z nową wartością. Podobnie jak w przypadku innych typów odczytywanie i zapisywanie w udostępnionej zmiennej, która zawiera wystąpienie tego typu, musi być chronione przez blokadę w celu zagwarantowania bezpieczeństwa wątków.

Zobacz też