Int64 结构

定义

表示 64 位有符号整数。Represents a 64-bit signed integer.

public value class Int64 : IComparable, IComparable<long>, IConvertible, IEquatable<long>, IFormattable
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public struct Int64 : IComparable, IComparable<long>, IConvertible, IEquatable<long>, IFormattable
type int64 = struct
    interface IFormattable
    interface IConvertible
Public Structure Int64
Implements IComparable, IComparable(Of Long), IConvertible, IEquatable(Of Long), IFormattable
继承
属性
实现

注解

Int64 是一种不可变的值类型,它表示值范围从负9223372036854775808(由 Int64.MinValue 常数表示)到正9223372036854775807(由 Int64.MaxValue 常量。Int64 is an immutable value type that represents signed integers with values that range from negative 9,223,372,036,854,775,808 (which is represented by the Int64.MinValue constant) through positive 9,223,372,036,854,775,807 (which is represented by the Int64.MaxValue constant. .NET Framework 还包括一个未签名的64位整数值类型,UInt64,它表示范围介于0到18446744073709551615之间的值。The .NET Framework also includes an unsigned 64-bit integer value type, UInt64, which represents values that range from 0 to 18,446,744,073,709,551,615.

实例化 Int64 值Instantiating an Int64 Value

可以通过多种方式实例化 Int64 值:You can instantiate an Int64 value in several ways:

  • 您可以声明一个 Int64 变量,并为其分配一个在 Int64 数据类型范围内的文本整数值。You can declare an Int64 variable and assign it a literal integer value that is within the range of the Int64 data type. 下面的示例声明两个 Int64 变量并以这种方式为它们赋值。The following example declares two Int64 variables and assigns them values in this way.

    long number1 = -64301728;
    long number2 = 255486129307;
    
    Dim number1 As Long = -64301728
    Dim number2 As Long = 255486129307
    
  • 可以指定整数类型的值,该类型的范围为 Int64 类型的子集。You can assign the value of an integral type whose range is a subset of the Int64 type. 这是一种扩大转换,不需要在中C#使用强制转换运算符,也不需要 Visual Basic 中的转换方法。This is a widening conversion that does not require a cast operator in C# or a conversion method in Visual Basic.

    sbyte value1 = 124;
    short value2 = 1618;
    int value3 = Int32.MaxValue;
    
    long number1 = value1;
    long number2 = value2;
    long number3 = 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
    
  • 可以指定数值类型的值,该数值类型的范围超出 Int64 类型的范围。You can assign the value of a numeric type whose range exceeds that of the Int64 type. 这是一种收缩转换,因此它需要中C#的强制转换运算符和 Visual Basic 中的转换方法(如果 Option Strict 为 on)。This is a narrowing conversion, so it requires a cast operator in C# and a conversion method in Visual Basic if Option Strict is on. 如果数值是包含小数部分的 SingleDoubleDecimal 值,则其小数部分的处理取决于执行转换的编译器。If the numeric value is a Single, Double, or Decimal value that includes a fractional component, the handling of its fractional part depends on the compiler performing the conversion. 下面的示例执行收缩转换,以将多个数值赋值给 Int64 变量。The following example performs narrowing conversions to assign several numeric values to 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.
    
    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.
    
  • 可以调用 Convert 类的方法,将任何支持的类型转换为 Int64 值。You can call a method of the Convert class to convert any supported type to an Int64 value. 这是可能的,因为 Int64 支持 IConvertible 接口。This is possible because Int64 supports the IConvertible interface. 下面的示例演示如何将 Decimal 值数组转换为 Int64 值。The following example illustrates the conversion of an array of Decimal values to Int64 values.

    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.
    
    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.
    
  • 可以调用 ParseTryParse 方法将 Int64 值的字符串表示形式转换为 Int64You can call the Parse or TryParse method to convert the string representation of an Int64 value to an Int64. 字符串可以包含 decimal 或十六进制数字。The string can contain either decimal or hexadecimal digits. 下面的示例通过使用 decimal 和十六进制字符串说明了分析操作。The following example illustrates the parse operation by using both a decimal and a hexadecimal string.

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

对 Int64 值执行操作Performing Operations on Int64 Values

Int64 类型支持标准数学运算,如加法、减法、除法、乘法、求反和一元求反。The Int64 type supports standard mathematical operations such as addition, subtraction, division, multiplication, negation, and unary negation. 与其他整型类型一样,Int64 类型还支持按位 ANDORXOR、左移和右移运算符。Like the other integral types, the Int64 type also supports the bitwise AND, OR, XOR, left shift, and right shift operators.

可以使用标准数字运算符比较两个 Int64 值,也可以调用 CompareToEquals 方法。You can use the standard numeric operators to compare two Int64 values, or you can call the CompareTo or Equals method.

您还可以调用 Math 类的成员来执行各种数值运算,包括获取数字的绝对值、计算除整数相除所得的商和余数、确定两个 long 的最大值或最小值整数,获取数字的符号并舍入数字。You can also call the members of the Math class to perform a wide range of numeric operations, including getting the absolute value of a number, calculating the quotient and remainder from integral division, determining the maximum or minimum value of two long integers, getting the sign of a number, and rounding a number.

将 Int64 表示为字符串Representing an Int64 as a String

Int64 类型完全支持标准和自定义数字格式字符串。The Int64 type provides full support for standard and custom numeric format strings. (有关详细信息,请参阅格式设置类型标准数字格式字符串自定义数字格式字符串。)(For more information, see Formatting Types, Standard Numeric Format Strings, and Custom Numeric Format Strings.)

若要将 Int64 值的格式设置为不带前导零的整数字符串,可以调用无参数的 ToString() 方法。To format an Int64 value as an integral string with no leading zeros, you can call the parameterless ToString() method. 通过使用 "D" 格式说明符,还可以在字符串表示形式中包含指定数目的前导零。By using the "D" format specifier, you can also include a specified number of leading zeros in the string representation. 通过使用 "N" 格式说明符,你可以包含组分隔符,并指定要在数字的字符串表示形式中显示的小数位数。By using the "N" format specifier, you can include group separators and specify the number of decimal digits to appear in the string representation of the number. 通过使用 "X" 格式说明符,可将 Int64 值表示为十六进制字符串。By using the "X" format specifier, you can represent an Int64 value as a hexadecimal string. 下面的示例采用这四种方式设置 Int64 值数组中的元素的格式。The following example formats the elements in an array of Int64 values in these four ways.

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

还可以通过调用 ToString(Int64, Int32) 方法并提供作为方法的第二个参数的基数,将 Int64 值的格式设置为二进制、八进制、十进制或十六进制字符串。You can also format an Int64 value as a binary, octal, decimal, or hexadecimal string by calling the ToString(Int64, Int32) method and supplying the base as the method's second parameter. 下面的示例调用此方法以显示整数值数组的二进制、八进制和十六进制表示形式。The following example calls this method to display the binary, octal, and hexadecimal representations of an array of integer values.

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

使用非十进制32位整数值Working with Non-Decimal 32-Bit Integer Values

除了使用单个长整数作为十进制值,你可能还需要执行包含长整数值的按位运算,或者使用长整数值的二进制或十六进制表示形式。In addition to working with individual long integers as decimal values, you may want to perform bitwise operations with long integer values, or work with the binary or hexadecimal representations of long integer values. Int64 值以63位表示,其中六十-第四位用作符号位。Int64 values are represented in 63 bits, with the sixty-fourth bit used as a sign bit. 正值是使用符号和量表示法表示的。Positive values are represented by using sign-and-magnitude representation. 负值的表示形式分为两种。Negative values are in two's complement representation. 当你对 Int64 值或使用单个位执行按位运算时,这一点很重要。This is important to keep in mind when you perform bitwise operations on Int64 values or when you work with individual bits. 若要对任意两个非十进制值执行数字、布尔或比较运算,这两个值必须使用相同的表示形式。In order to perform a numeric, Boolean, or comparison operation on any two non-decimal values, both values must use the same representation.

字段

MaxValue

表示 Int64 的最大可能值。Represents the largest possible value of an Int64. 此字段为常数。This field is constant.

MinValue

表示 Int64 的最小可能值。Represents the smallest possible value of an Int64. 此字段为常数。This field is constant.

方法

CompareTo(Int64)

将此实例与指定的 64 位有符号整数进行比较并返回对其相对值的指示。Compares this instance to a specified 64-bit signed integer and returns an indication of their relative values.

CompareTo(Object)

将此实例与指定对象进行比较并返回一个对二者的相对值的指示。Compares this instance to a specified object and returns an indication of their relative values.

Equals(Int64)

返回一个值,该值指示此实例是否等于指定的 Int64 值。Returns a value indicating whether this instance is equal to a specified Int64 value.

Equals(Object)

返回一个值,该值指示此实例是否等于指定的对象。Returns a value indicating whether this instance is equal to a specified object.

GetHashCode()

返回此实例的哈希代码。Returns the hash code for this instance.

GetTypeCode()

返回值类型 TypeCodeInt64Returns the TypeCode for value type Int64.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

将指定样式和区域性特定格式的数字的范围表示形式转换为其等效的 64 位带符号整数。Converts the span representation of a number in a specified style and culture-specific format to its 64-bit signed integer equivalent.

Parse(String)

将数字的字符串表示形式转换为它的等效 64 位有符号整数。Converts the string representation of a number to its 64-bit signed integer equivalent.

Parse(String, IFormatProvider)

将指定的区域性特定格式的数字的字符串表示形式转换为它的等效 64 位有符号整数。Converts the string representation of a number in a specified culture-specific format to its 64-bit signed integer equivalent.

Parse(String, NumberStyles)

将指定样式的数字的字符串表示形式转换为它的等效 64 位有符号整数。Converts the string representation of a number in a specified style to its 64-bit signed integer equivalent.

Parse(String, NumberStyles, IFormatProvider)

将指定样式和区域性特定格式的数字的字符串表示形式转换为它的等效 64 位有符号整数。Converts the string representation of a number in a specified style and culture-specific format to its 64-bit signed integer equivalent.

ToString()

将此实例的数值转换为其等效的字符串表示形式。Converts the numeric value of this instance to its equivalent string representation.

ToString(IFormatProvider)

使用指定的区域性特定格式信息,将此实例的数值转换为它的等效字符串表示形式。Converts the numeric value of this instance to its equivalent string representation using the specified culture-specific format information.

ToString(String)

使用指定的格式,将此实例的数值转换为它的等效字符串表示形式。Converts the numeric value of this instance to its equivalent string representation, using the specified format.

ToString(String, IFormatProvider)

使用指定的格式和区域性特定格式信息,将此实例的数值转换为它的等效字符串表示形式。Converts the numeric value of this instance to its equivalent string representation using the specified format and culture-specific format information.

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

尝试将当前长数字实例的值的格式设置为提供的字符范围。Tries to format the value of the current long number instance into the provided span of characters.

TryParse(ReadOnlySpan<Char>, Int64)

将数字的范围表示形式转换为其等效的 64 位带符号整数。Converts the span representation of a number to its 64-bit signed integer equivalent. 一个指示转换是否成功的返回值。A return value indicates whether the conversion succeeded or failed.

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

将指定样式和区域性特定格式的数字的范围表示形式转换为其等效的 64 位带符号整数。Converts the span representation of a number in a specified style and culture-specific format to its 64-bit signed integer equivalent. 一个指示转换是否成功的返回值。A return value indicates whether the conversion succeeded or failed.

TryParse(String, Int64)

将数字的字符串表示形式转换为它的等效 64 位有符号整数。Converts the string representation of a number to its 64-bit signed integer equivalent. 一个指示转换是否成功的返回值。A return value indicates whether the conversion succeeded or failed.

TryParse(String, NumberStyles, IFormatProvider, Int64)

将指定样式和区域性特定格式的数字的字符串表示形式转换为它的等效 64 位有符号整数。Converts the string representation of a number in a specified style and culture-specific format to its 64-bit signed integer equivalent. 一个指示转换是否成功的返回值。A return value indicates whether the conversion succeeded or failed.

显式界面实现

IComparable.CompareTo(Object)

将此实例与指定对象进行比较并返回一个对二者的相对值的指示。Compares this instance to a specified object and returns an indication of their relative values.

IConvertible.GetTypeCode()

返回值类型 TypeCodeInt64Returns the TypeCode for value type Int64.

IConvertible.ToBoolean(IFormatProvider)

有关此成员的说明,请参见 ToBoolean(IFormatProvider)For a description of this member, see ToBoolean(IFormatProvider).

IConvertible.ToByte(IFormatProvider)

有关此成员的说明,请参见 ToByte(IFormatProvider)For a description of this member, see ToByte(IFormatProvider).

IConvertible.ToChar(IFormatProvider)

有关此成员的说明,请参见 ToChar(IFormatProvider)For a description of this member, see ToChar(IFormatProvider).

IConvertible.ToDateTime(IFormatProvider)

不支持此转换。This conversion is not supported. 尝试使用此方法将引发 InvalidCastExceptionAttempting to use this method throws an InvalidCastException.

IConvertible.ToDecimal(IFormatProvider)

有关此成员的说明,请参见 ToDecimal(IFormatProvider)For a description of this member, see ToDecimal(IFormatProvider).

IConvertible.ToDouble(IFormatProvider)

有关此成员的说明,请参见 ToDouble(IFormatProvider)For a description of this member, see ToDouble(IFormatProvider).

IConvertible.ToInt16(IFormatProvider)

有关此成员的说明,请参见 ToInt16(IFormatProvider)For a description of this member, see ToInt16(IFormatProvider).

IConvertible.ToInt32(IFormatProvider)

有关此成员的说明,请参见 ToInt32(IFormatProvider)For a description of this member, see ToInt32(IFormatProvider).

IConvertible.ToInt64(IFormatProvider)

有关此成员的说明,请参见 ToInt64(IFormatProvider)For a description of this member, see ToInt64(IFormatProvider).

IConvertible.ToSByte(IFormatProvider)

有关此成员的说明,请参见 ToSByte(IFormatProvider)For a description of this member, see ToSByte(IFormatProvider).

IConvertible.ToSingle(IFormatProvider)

有关此成员的说明,请参见 ToSingle(IFormatProvider)For a description of this member, see ToSingle(IFormatProvider).

IConvertible.ToType(Type, IFormatProvider)

有关此成员的说明,请参见 ToType(Type, IFormatProvider)For a description of this member, see ToType(Type, IFormatProvider).

IConvertible.ToUInt16(IFormatProvider)

有关此成员的说明,请参见 ToUInt16(IFormatProvider)For a description of this member, see ToUInt16(IFormatProvider).

IConvertible.ToUInt32(IFormatProvider)

有关此成员的说明,请参见 ToUInt32(IFormatProvider)For a description of this member, see ToUInt32(IFormatProvider).

IConvertible.ToUInt64(IFormatProvider)

有关此成员的说明,请参见 ToUInt64(IFormatProvider)For a description of this member, see ToUInt64(IFormatProvider).

适用于

线程安全性

此类型的所有成员都是线程安全的。All members of this type are thread safe. 看似修改实例状态的成员实际上返回用新值初始化的新实例。Members that appear to modify instance state actually return a new instance initialized with the new value. 与任何其他类型一样,读取和写入包含此类型的实例的共享变量时,必须通过锁保护以保证线程安全。As with any other type, reading and writing to a shared variable that contains an instance of this type must be protected by a lock to guarantee thread safety.

另请参阅