附件 C 标准库
C.1 常规
符合要求的 C# 实现应提供具有特定语义的最小类型集。 这些类型及其成员按命名空间和类型按字母顺序列出。 有关这些类型及其成员的正式定义，请参阅 ISO/IEC 23271：2012 公共语言基础结构 （CLI），分区 IV;基类库（BCL）、扩展数值库和扩展数组库，这些库由此规范中的引用包含。
此文本具有信息性。
标准库旨在成为符合 C# 实现所需的最小类型和成员集。 因此，它仅包含 C# 语言规范显式要求的那些成员。
预计一个符合要求的 C# 实现将提供一个更为广泛的库，使有用的程序能够编写。 例如，符合要求的实现可能会通过以下方式扩展此库
- 添加命名空间。
- 添加类型。
- 将成员添加到非接口类型。
- 添加干预基类或接口。
- 具有结构和类类型可实现其他接口。
- 将属性（而非 ）
ConditionalAttribute添加到现有类型和成员。
信息性文本的结尾。
在 ISO/IEC 23271 中定义的 C.2 标准库类型
注意： 下面的某些
struct类型具有readonly修饰符。 此修饰符在 ISO/IEC 23271 发布时不可用，但符合此规范的实现需要。 end note
namespace System
{
public delegate void Action();
public class ArgumentException : SystemException
{
public ArgumentException();
public ArgumentException(string message);
public ArgumentException(string message, Exception innerException);
}
public class ArithmeticException : Exception
{
public ArithmeticException();
public ArithmeticException(string message);
public ArithmeticException(string message, Exception innerException);
}
public abstract class Array : IList, ICollection, IEnumerable
{
public int Length { get; }
public int Rank { get; }
public int GetLength(int dimension);
}
public class ArrayTypeMismatchException : Exception
{
public ArrayTypeMismatchException();
public ArrayTypeMismatchException(string message);
public ArrayTypeMismatchException(string message,
Exception innerException);
}
[AttributeUsageAttribute(AttributeTargets.All, Inherited = true,
AllowMultiple = false)]
public abstract class Attribute
{
protected Attribute();
}
public enum AttributeTargets
{
Assembly = 0x1,
Module = 0x2,
Class = 0x4,
Struct = 0x8,
Enum = 0x10,
Constructor = 0x20,
Method = 0x40,
Property = 0x80,
Field = 0x100,
Event = 0x200,
Interface = 0x400,
Parameter = 0x800,
Delegate = 0x1000,
ReturnValue = 0x2000,
GenericParameter = 0x4000,
All = 0x7FFF
}
[AttributeUsageAttribute(AttributeTargets.Class, Inherited = true)]
public sealed class AttributeUsageAttribute : Attribute
{
public AttributeUsageAttribute(AttributeTargets validOn);
public bool AllowMultiple { get; set; }
public bool Inherited { get; set; }
public AttributeTargets ValidOn { get; }
}
public readonly struct Boolean { }
public readonly struct Byte { }
public readonly struct Char { }
public readonly struct Decimal { }
public abstract class Delegate { }
public class DivideByZeroException : ArithmeticException
{
public DivideByZeroException();
public DivideByZeroException(string message);
public DivideByZeroException(string message, Exception innerException);
}
public readonly struct Double { }
public abstract class Enum : ValueType
{
protected Enum();
}
public class Exception
{
public Exception();
public Exception(string message);
public Exception(string message, Exception innerException);
public sealed Exception InnerException { get; }
public virtual string Message { get; }
}
public class GC { }
public interface IDisposable
{
void Dispose();
}
public interface IFormattable { }
public sealed class IndexOutOfRangeException : Exception
{
public IndexOutOfRangeException();
public IndexOutOfRangeException(string message);
public IndexOutOfRangeException(string message,
Exception innerException);
}
public readonly struct Int16 { }
public readonly struct Int32 { }
public readonly struct Int64 { }
public readonly struct IntPtr { }
public class InvalidCastException : Exception
{
public InvalidCastException();
public InvalidCastException(string message);
public InvalidCastException(string message, Exception innerException);
}
public class InvalidOperationException : Exception
{
public InvalidOperationException();
public InvalidOperationException(string message);
public InvalidOperationException(string message,
Exception innerException);
}
public class NotSupportedException : Exception
{
public NotSupportedException();
public NotSupportedException(string message);
public NotSupportedException(string message,
Exception innerException);
}
public struct Nullable<T>
{
public bool HasValue { get; }
public T Value { get; }
}
public class NullReferenceException : Exception
{
public NullReferenceException();
public NullReferenceException(string message);
public NullReferenceException(string message, Exception innerException);
}
public class Object
{
public Object();
~Object();
public virtual bool Equals(object obj);
public virtual int GetHashCode();
public Type GetType();
public virtual string ToString();
}
[AttributeUsageAttribute(AttributeTargets.Class | AttributeTargets.Struct |
AttributeTargets.Enum | AttributeTargets.Interface |
AttributeTargets.Constructor | AttributeTargets.Method |
AttributeTargets.Property | AttributeTargets.Field |
AttributeTargets.Event | AttributeTargets.Delegate, Inherited = false)]
public sealed class ObsoleteAttribute : Attribute
{
public ObsoleteAttribute();
public ObsoleteAttribute(string message);
public ObsoleteAttribute(string message, bool error);
public bool IsError { get; }
public string Message { get; }
}
public class OutOfMemoryException : Exception
{
public OutOfMemoryException();
public OutOfMemoryException(string message);
public OutOfMemoryException(string message, Exception innerException);
}
public class OverflowException : ArithmeticException
{
public OverflowException();
public OverflowException(string message);
public OverflowException(string message, Exception innerException);
}
public readonly struct SByte { }
public readonly struct Single { }
public sealed class StackOverflowException : Exception
{
public StackOverflowException();
public StackOverflowException(string message);
public StackOverflowException(string message, Exception innerException);
}
public sealed class String : IEnumerable<Char>, IEnumerable
{
public int Length { get; }
public char this [int index] { get; }
public static string Format(string format, params object[] args);
}
public abstract class Type : MemberInfo { }
public sealed class TypeInitializationException : Exception
{
public TypeInitializationException(string fullTypeName,
Exception innerException);
}
public readonly struct UInt16 { }
public readonly struct UInt32 { }
public readonly struct UInt64 { }
public readonly struct UIntPtr { }
public abstract class ValueType
{
protected ValueType();
}
}
namespace System.Collections
{
public interface ICollection : IEnumerable
{
int Count { get; }
bool IsSynchronized { get; }
object SyncRoot { get; }
void CopyTo(Array array, int index);
}
public interface IEnumerable
{
IEnumerator GetEnumerator();
}
public interface IEnumerator
{
object Current { get; }
bool MoveNext();
void Reset();
}
public interface IList : ICollection, IEnumerable
{
bool IsFixedSize { get; }
bool IsReadOnly { get; }
object this [int index] { get; set; }
int Add(object value);
void Clear();
bool Contains(object value);
int IndexOf(object value);
void Insert(int index, object value);
void Remove(object value);
void RemoveAt(int index);
}
}
namespace System.Collections.Generic
{
public interface ICollection<T> : IEnumerable<T>
{
int Count { get; }
bool IsReadOnly { get; }
void Add(T item);
void Clear();
bool Contains(T item);
void CopyTo(T[] array, int arrayIndex);
bool Remove(T item);
}
public interface IEnumerable<T> : IEnumerable
{
IEnumerator<T> GetEnumerator();
}
public interface IEnumerator<T> : IDisposable, IEnumerator
{
T Current { get; }
}
public interface IList<T> : ICollection<T>
{
T this [int index] { get; set; }
int IndexOf(T item);
void Insert(int index, T item);
void RemoveAt(int index);
}
}
namespace System.Diagnostics
{
[AttributeUsageAttribute(AttributeTargets.Method | AttributeTargets.Class,
AllowMultiple = true)]
public sealed class ConditionalAttribute : Attribute
{
public ConditionalAttribute(string conditionString);
public string ConditionString { get; }
}
}
namespace System.Reflection
{
public abstract class MemberInfo
{
protected MemberInfo();
}
}
namespace System.Runtime.CompilerServices
{
public sealed class IndexerNameAttribute : Attribute
{
public IndexerNameAttribute(String indexerName);
}
public static class Unsafe
{
public static ref T NullRef<T>();
}
}
namespace System.Threading
{
public static class Monitor
{
public static void Enter(object obj);
public static void Exit(object obj);
}
}
C.3 标准库类型未在 ISO/IEC 23271 中定义
以下类型（包括列出的成员）应在符合标准库中定义。 （这些类型可能在 ISO/IEC 23271 的未来版本中定义。预计其中许多类型将具有比列出的更多的可用成员。
一个符合要求的实现可以提供 Task.GetAwaiter() 和 Task<TResult>.GetAwaiter() 作为扩展方法。
namespace System
{
public class FormattableString : IFormattable { }
public class OperationCanceledException : Exception
{
public OperationCanceledException();
public OperationCanceledException(string message);
public OperationCanceledException(string message, Exception innerException);
}
public readonly ref struct ReadOnlySpan<T>
{
public int Length { get; }
public ref readonly T this[int index] { get; }
}
public readonly ref struct Span<T>
{
public int Length { get; }
public ref T this[int index] { get; }
public static implicit operator ReadOnlySpan<T>(Span<T> span);
}
public struct ValueTuple<T1>
{
public T1 Item1;
public ValueTuple(T1 item1);
}
public struct ValueTuple<T1, T2>
{
public T1 Item1;
public T2 Item2;
public ValueTuple(T1 item1, T2 item2);
}
public struct ValueTuple<T1, T2, T3>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public ValueTuple(T1 item1, T2 item2, T3 item3);
}
public struct ValueTuple<T1, T2, T3, T4>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public T4 Item4;
public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4);
}
public struct ValueTuple<T1, T2, T3, T4, T5>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public T4 Item4;
public T5 Item5;
public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5);
}
public struct ValueTuple<T1, T2, T3, T4, T5, T6>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public T4 Item4;
public T5 Item5;
public T6 Item6;
public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5,
T6 item6);
}
public struct ValueTuple<T1, T2, T3, T4, T5, T6, T7>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public T4 Item4;
public T5 Item5;
public T6 Item6;
public T7 Item7;
public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5,
T6 item6, T7 item7);
}
public struct ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public T4 Item4;
public T5 Item5;
public T6 Item6;
public T7 Item7;
public TRest Rest;
public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5,
T6 item6, T7 item7, TRest rest);
}
}
namespace System.Collections.Generic
{
public interface IReadOnlyCollection<out T> : IEnumerable<T>
{
int Count { get; }
}
public interface IReadOnlyList<out T> : IReadOnlyCollection<T>
{
T this [int index] { get; }
}
}
namespace System.Linq.Expressions
{
public sealed class Expression<TDelegate>
{
public TDelegate Compile();
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct |
AttributeTargets.Interface,
Inherited = false, AllowMultiple = false)]
public sealed class AsyncMethodBuilderAttribute : Attribute
{
public AsyncMethodBuilderAttribute(Type builderType) {}
public Type BuilderType { get; }
}
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
public sealed class CallerFilePathAttribute : Attribute
{
public CallerFilePathAttribute() { }
}
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
public sealed class CallerLineNumberAttribute : Attribute
{
public CallerLineNumberAttribute() { }
}
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
public sealed class CallerMemberNameAttribute : Attribute
{
public CallerMemberNameAttribute() { }
}
public static class FormattableStringFactory
{
public static FormattableString Create(string format,
params object[] arguments);
}
public interface ICriticalNotifyCompletion : INotifyCompletion
{
void UnsafeOnCompleted(Action continuation);
}
public interface INotifyCompletion
{
void OnCompleted(Action continuation);
}
public readonly struct TaskAwaiter : ICriticalNotifyCompletion,
INotifyCompletion
{
public bool IsCompleted { get; }
public void GetResult();
}
public readonly struct TaskAwaiter<TResult> : ICriticalNotifyCompletion,
INotifyCompletion
{
public bool IsCompleted { get; }
public TResult GetResult();
}
public readonly struct ValueTaskAwaiter : ICriticalNotifyCompletion,
INotifyCompletion
{
public bool IsCompleted { get; }
public void GetResult();
}
public readonly struct ValueTaskAwaiter<TResult>
: ICriticalNotifyCompletion, INotifyCompletion
{
public bool IsCompleted { get; }
public TResult GetResult();
}
[System.AttributeUsage(System.AttributeTargets.Field |
System.AttributeTargets.Parameter | System.AttributeTargets.Property,
Inherited=false)]
public sealed class AllowNullAttribute : Attribute
{
public AllowNullAttribute() { }
}
[System.AttributeUsage(System.AttributeTargets.Field |
System.AttributeTargets.Parameter | System.AttributeTargets.Property,
Inherited=false)]
public sealed class DisallowNullAttribute : Attribute
{
public DisallowNullAttribute() {}
}
[System.AttributeUsage(System.AttributeTargets.Method, Inherited=false)]
public sealed class DoesNotReturnAttribute : Attribute
{
public DoesNotReturnAttribute() {}
}
[System.AttributeUsage(System.AttributeTargets.Parameter, Inherited=false)]
public sealed class DoesNotReturnIfAttribute : Attribute
{
public DoesNotReturnIfAttribute(bool parameterValue) {}
}
[System.AttributeUsage(System.AttributeTargets.Field |
System.AttributeTargets.Parameter | System.AttributeTargets.Property |
System.AttributeTargets.ReturnValue, Inherited=false)]
public sealed class MaybeNullAttribute : Attribute
{
public MaybeNullAttribute() {}
}
[System.AttributeUsage(System.AttributeTargets.Parameter, Inherited=false)]
public sealed class MaybeNullWhenAttribute : Attribute
{
public MaybeNullWhenAttribute(bool returnValue) {}
}
[System.AttributeUsage(System.AttributeTargets.Field |
System.AttributeTargets.Parameter | System.AttributeTargets.Property |
System.AttributeTargets.ReturnValue, Inherited=false)]
public sealed class NotNullAttribute : Attribute
{
public NotNullAttribute() {}
}
[System.AttributeUsage(System.AttributeTargets.Parameter |
System.AttributeTargets.Property | System.AttributeTargets.ReturnValue,
AllowMultiple=true, Inherited=false)]
public sealed class NotNullIfNotNullAttribute : Attribute
{
public NotNullIfNotNullAttribute(string parameterName) {}
}
[System.AttributeUsage(System.AttributeTargets.Parameter, Inherited=false)]
public sealed class NotNullWhenAttribute : Attribute
{
public NotNullWhenAttribute(bool returnValue) {}
}
}
namespace System.Threading.Tasks
{
public class Task
{
public System.Runtime.CompilerServices.TaskAwaiter GetAwaiter();
}
public class Task<TResult> : Task
{
public new System.Runtime.CompilerServices.TaskAwaiter<T> GetAwaiter();
}
public readonly struct ValueTask : System.IEquatable<ValueTask>
{
public System.Runtime.CompilerServices.ValueTaskAwaiter GetAwaiter();
}
public readonly struct ValueTask<TResult>
: System.IEquatable<ValueTask<TResult>>
{
public new System.Runtime.CompilerServices.ValueTaskAwaiter<TResult>
GetAwaiter();
}
}
C.4 格式规范
内插字符串表达式（§12.8.3）中使用的格式的含义在 ISO/IEC 23271：2012 中定义。 为方便起见，将从说明 System.IFormattable复制以下文本。
此文本具有信息性。
格式是描述对象转换为字符串时对象的外观的字符串。 可以使用标准格式或自定义格式。 标准格式采用 Axx 形式，其中 A 是名为格式说明符的单个字母字符，xx 是介于零和 99（含 99）之间的整数，称为精度说明符。 格式说明符控制应用于要表示为字符串的值的格式类型。 精度说明符控制字符串中有效位数或小数位数（如果适用）。
注意：有关标准格式说明符的列表，请参阅下表。 请注意，给定的数据类型（如
System.Int32）可能不支持一个或多个标准格式说明符。 end note
注意：当格式包含因区域性而变化的符号（如“C”和“c”格式包含的 currencysymbol）时，格式对象会提供字符串表示形式中使用的实际字符。 方法可能包括一个参数来传递
System.IFormatProvider提供格式对象的对象，或者该方法可能使用默认格式对象，该对象包含当前区域性的符号定义。 当前区域性通常使用系统范围的同一组符号。 在基类库中，系统提供的数值类型的格式设置对象是一个System.Globalization.NumberFormatInfo实例。System.DateTime例如，使用 aSystem.Globalization.DateTimeFormatInfo。 end note
下表描述了用于基类库中数值数据类型的标准格式说明符和关联的格式对象成员。
| 格式说明符 | 说明 |
|---|---|
|
货币格式： 用于包含货币值的字符串。
如果省略精度说明符， |
|
十进制格式： （此格式仅在使用整型数据类型指定时才有效。用于包含整数值的字符串。 负数以属性指定的 精度说明符确定字符串中显示的最小位数。 如果指定的精度要求的值包含的数字数多，则字符串将用零填充。 如果精度说明符指定的数字少于值中的位数，则忽略精度说明符。 |
|
科学（工程）格式： 用于以下形式之一的字符串： [-]m.dddddE+xxx [-]m.ddddd E-xxx [-]m.ddddde+xxx [-]m.ddddde-xxx 仅当值为负数并且由 只有一个非零十进制数字（m）位于该属性提供的 精度说明符确定字符串中的小数位数（dddddd）。 如果省略精度说明符，则字符串中包含六个小数位数。 指数（+/-xxx）由正数或负数符号组成，后跟至少三位数字（xxx）。 如有必要，指数用零填充。 格式说明符（“E”或“e”）的事例确定用于字符串中指数前缀（E 或 e）的事例。 如果需要，结果将舍入为最接近的可表示值。 正数符号由 |
|
固定点格式： 用于以下形式的字符串： [-]m.dd...d 属性提供的 仅当值为负数时，负数符号符号 （'-'） 才位于 m 之前。 此符号由 精度说明符确定小数位数（dd...字符串中的 d） 。 如果省略精度说明符， |
|
常规格式： 字符串采用固定点格式（“F”或“f”）或科学格式（“E”或“e”）。 对于整型类型： 如果指数<精度说明符是采用科学格式的值指数，则使用固定点格式设置值的格式。 对于所有其他值，将使用科学格式。 如果省略精度说明符，则使用默认精度等于显示数据类型的最大值所需的字段宽度，这将导致值采用固定点格式设置。 整型类型的默认精度如下所示： 对于 Single、Decimal 和 Double 类型： 如果指数≥ -4 和指数精度说明符，则使用固定点格式设置值的格式，其中指数<是科学格式的值的指数。 对于所有其他值，将使用科学格式。 如果需要，结果将舍入为最接近的可表示值。 如果省略精度说明符，则使用以下默认精度： 对于所有类型：
|
|
数字格式： 用于以下形式的字符串： [-]d，ddd，d.dd...d 负值的表示形式由 属性提供的 精度说明符确定小数位数（dd...d）。 如果省略精度说明符， |
|
百分比格式： 用于包含百分比的字符串。
如果未指定精度，则由结果中的小数位数确定 结果将缩放 100（.99 变为 99%）。 |
|
往返格式：（此格式仅在指定了 <System.Single/> 时有效）用于确保浮点值的字符串表示形式的精度使得分析字符串不会在与原始值进行比较时导致精度损失。 如果数据类型（7 for System.Single和 15 for System.Double）的最大精度将导致精度损失，则精度将增加两个小数位数。 如果使用此格式说明符提供精度说明符，则忽略该说明符。 此格式与其他固定点格式相同。 |
|
十六进制格式： （此格式仅在使用整型数据类型指定时才有效。用于 Base 16 中数字的字符串表示形式。精度确定字符串中的最小位数。 如果精度指定的数字数多于数字所包含的数字，则用零填充数字。 格式说明符（“X”或“x”）的事例确定在十六进制表示形式中使用大写字母还是小写字母。 |
如果数值是一个System.Single或具有一个值NaN，PositiveInfinity或者NegativeInfinity忽略格式说明符，则返回下列值之一：System.Globalization.NumberFormatInfo.NaNSymbol、或System.Globalization.NumberFormatInfo.NegativeInfinitySymbolSystem.Globalization.NumberFormatInfo.PositiveInfinitySymbol。System.Double
自定义格式是指定为格式的任何字符串，格式不是上述标准格式字符串（Axx）。 下表描述了用于构造自定义格式的字符。
| 格式说明符 | 说明 |
|---|---|
0 （零） |
零占位符： 如果格式化的值在“0”出现在自定义格式的位置中，则该数字将复制到输出字符串;否则，零将存储在输出字符串中的该位置。 小数分隔符前最左侧的“0”的位置和小数分隔符后面的最右侧的“0”的位置决定了输出字符串中始终存在的数字范围。 小数分隔符后面的零位和/或数字占位符确定小数分隔符之后出现的位数。 值根据需要进行舍入。 |
# |
数字占位符： 如果设置格式的值在“#”出现在自定义格式的位置中包含一位数字，则该数字将复制到输出字符串;否则，输出字符串中将没有任何内容存储在该位置。 请注意，即使“0”是字符串中唯一的数字，此说明符也不会存储“0”字符。 （如果输出字符串是有效数字，则会在输出字符串中显示“0”字符。 小数分隔符后面的零位和/或数字占位符确定小数分隔符之后出现的位数。 值根据需要进行舍入。 |
. （句点） |
小数分隔符： 最左侧的“.”
格式字符串中的字符确定格式值中的小数分隔符的位置;任何其他“.” 将忽略字符。 该 System.Globalization.NumberFormatInfo.NumberDecimalSeparator 属性确定用作小数分隔符的符号。 |
, （逗号） |
组分隔符和数字缩放： “，”字符用于两个目的。 首先，如果自定义格式包含两个零位或数字占位符（0 或 #）之间的此字符，如果存在十进制分隔符，则输出将在小数分隔符左侧的每个数字组之间插入组分隔符。 和 如果格式字符串包含一个或多个“，则小数分隔符左侧的字符将立即缩放。 刻度因子由小数点分隔符左侧的组分隔符数确定。 如果有 x 个字符，则该值在格式化前除以 1000X 。 例如，格式字符串“0”将值除以 100 万。 请注意，如果存在“，则表示缩放不会在输出字符串中插入组分隔符。 因此，若要将数字缩放 100 万并插入组分隔符，请使用类似于“#，##0，”的自定义格式。 |
% （百分比） |
百分比占位符： 自定义格式中存在“%”字符会导致数字在格式化前乘以 100。 百分比符号插入到输出字符串中，位于格式字符串中显示“%”的位置。 该 System.Globalization.NumberFormatInfo.PercentSymbol 属性确定百分比符号。 |
|
工程格式： 如果任何字符串“E”、“E+”、“E-”、“e+”、“e+”或“e-”以自定义格式存在，并且紧跟至少一个“0”字符，则使用科学表示法设置值的格式。 指数前缀（E 或 e）后面的“0”字符数决定了指数中的最小位数。 “E+”和“e+”格式表示正数或负数符号始终位于指数之前。 “E”、“E-”、“e”或“e-”格式指示负数符号前面有负指数;没有符号位于正指数之前。 正数符号由 System.Globalization.NumberFormatInfo.PositiveSign 属性提供。 负数符号由 System.Globalization.NumberFormatInfo.NegativeSign 属性提供。 |
\ （反斜杠） |
转义字符： 在某些语言（如 C#）中，反斜杠字符会导致自定义格式的下一个字符解释为转义序列。 它与 C 语言格式序列一起使用，例如“\n”（换行符）。 在某些语言中，转义字符本身需要以转义字符开头，用作文本。 否则，编译器会将字符解释为转义序列。 并非所有编程语言都支持此转义字符。 |
|
文本字符串： 将括在单引号或双引号中的字符按字面复制到输出字符串，不会影响格式设置。 |
; （分号） |
节分隔符： “;”字符用于分隔格式字符串中的正数、负数和零数的节。 （下面详细介绍了此功能。 |
| 其他 | 所有其他字符： 所有其他字符都作为文本存储在输出字符串中，其显示位置。 |
请注意，对于固定点格式字符串（不包含“E0”、“E+0”、“E-0”、“e-0”、“e+0”或“e-0”）的字符串，数字将舍入为小数位数，因为小数点分隔符右侧有零位或数字占位符。 如果自定义格式不包含小数分隔符，则数字将舍入为最接近的整数。 如果数字的位数多于小数分隔符左侧的零位符或数字占位符，则额外的数字将立即复制到输出字符串前的第一个零位或数字占位符。
自定义格式最多可以包含三个分区，用节分隔符分隔，以指定正值、负值和零值的不同格式。 这些部分解释如下：
一节：自定义格式适用于所有值（正值、负值和零）。 负值包括负号。
两个部分：第一节适用于正值和零，第二节适用于负值。 如果要格式化的值为负值，但根据第二节中的格式舍入后变为零，则生成的零将按照第一节的格式进行格式化。 负值不包括负号，以允许完全控制负值的表示形式。 例如，可以使用类似于“###”的自定义格式以括号表示负值;(####.####)’.
三个部分：第一节适用于正值，第二节适用于负值，第三节适用于零。 第二节可以为空（分号之间无任何显示），在这种情况下，第一节适用于所有非零值，负值包括负号。 如果要格式化的数字为非零，但根据第一节或第二节中的格式进行舍入后变为零，则生成的零将按照第三节进行格式化。
这些 System.Enum 和 System.DateTime 类型还支持使用格式说明符设置值的字符串表示形式。 特定格式说明符的含义因格式化的数据类型（数字、日期/时间、枚举）而异。 查看 System.Enum 和 System.Globalization.DateTimeFormatInfo 了解每种类型支持的格式说明符的完整列表。
C.5 库类型缩写
此规范引用了以下库类型。 下面列出了这些类型的全名，包括全局命名空间限定符。 在整个规范中，这些类型显示为完全限定名称;省略全局命名空间限定符;或作为简单不限定的类型名称，同时省略命名空间。 例如，此规范中使用的类型 ICollection<T>始终表示类型 global::System.Collections.Generic.ICollection<T>。
global::System.Actionglobal::System.ArgumentExceptionglobal::System.ArithmeticExceptionglobal::System.Arrayglobal::System.ArrayTypeMisMatchExceptionglobal::System.Attributeglobal::System.AttributeTargetsglobal::System.AttributeUsageAttributeglobal::System.Booleanglobal::System.Byteglobal::System.Charglobal::System.Collections.Generic.ICollection<T>global::System.Collections.Generic.IEnumerable<T>global::System.Collections.Generic.IEnumerator<T>global::System.Collections.Generic.IList<T>global::System.Collections.Generic.IReadonlyCollection<out T>global::System.Collections.Generic.IReadOnlyList<out T>global::System.Collections.ICollectionglobal::System.Collections.IEnumerableglobal::System.Collections.IListglobal::System.Collections.IEnumeratorglobal::System.Decimalglobal::System.Delegateglobal::System.Diagnostics.ConditionalAttributeglobal::System.DivideByZeroExceptionglobal::System.Doubleglobal::System.Enumglobal::System.Exceptionglobal::System.GCglobal::System.ICollectionglobal::System.IDisposableglobal::System.IEnumerableglobal::System.IEnumerable<out T>global::System.IListglobal::System.IndexOutOfRangeExceptionglobal::System.Int16global::System.Int32global::System.Int64global::System.IntPtrglobal::System.InvalidCastExceptionglobal::System.InvalidOperationExceptionglobal::System.Linq.Expressions.Expression<TDelegate>global::System.MemberInfoglobal::System.NotSupportedExceptionglobal::System.Nullable<T>global::System.NullReferenceExceptionglobal::System.Objectglobal::System.ObsoleteAttributeglobal::System.OutOfMemoryExceptionglobal::System.OverflowExceptionglobal::System.Runtime.CompilerServices.CallerFileAttributeglobal::System.Runtime.CompilerServices.CallerLineNumberAttributeglobal::System.Runtime.CompilerServices.CallerMemberNameAttributeglobal::System.Runtime.CompilerServices.ICriticalNotifyCompletionglobal::System.Runtime.CompilerServices.IndexerNameAttributeglobal::System.Runtime.CompilerServices.INotifyCompletionglobal::System.Runtime.CompilerServices.TaskAwaiterglobal::System.Runtime.CompilerServices.TaskAwaiter<T>global::System.SByteglobal::System.Singleglobal::System.StackOverflowExceptionglobal::System.Stringglobal::System.SystemExceptionglobal::System.Threading.Monitorglobal::System.Threading.Tasks.Taskglobal::System.Threading.Tasks.Task<TResult>global::System.Typeglobal::System.TypeInitializationExceptionglobal::System.UInt16global::System.UInt32global::System.UInt64global::System.UIntPtrglobal::System.ValueType
信息性文本的结尾。
