付属書 C 標準ライブラリ

C.1 全般

準拠する C# 実装では、特定のセマンティクスを持つ型の最小セットを提供する必要があります。 これらの型とそのメンバーは、名前空間と型のアルファベット順に一覧表示されます。 (§C.2) で識別される型とそのメンバーの正式な定義については、ISO/IEC 23271:2012 共通言語インフラストラクチャ (CLI)、Partition IV を参照してください。基本クラス ライブラリ (BCL)、拡張数値ライブラリ、および拡張配列ライブラリ。この仕様のリファレンスに含まれています。 §C.2 で識別されているもの以外に必要な型とそのメンバーの一覧については、§C.3 を参照してください。

注: CLI のライブラリ API のサブセットを採用しても、CLI 自体への依存関係は作成されません。準拠する実装を CLI に基づいて構築したり、ターゲットにしたりする必要はありません。

このテキストは有益です。

標準ライブラリは、準拠する C# 実装に必要な型とメンバーの最小セットを意図しています。 そのため、C# 言語仕様で明示的に必要なメンバーのみが含まれます。

準拠した C# 実装では、有用なプログラムを記述できる、より広範なライブラリが提供されることが期待されます。 たとえば、準拠した実装では、次の方法でこのライブラリを拡張できます。

• 名前空間の追加。
• 型の追加。
• インターフェイス以外の型へのメンバーの追加。
• 介在する基底クラスまたはインターフェイスを追加する。
• 構造体とクラス型を使用すると、追加のインターフェイスが実装されます。
• 既存の型とメンバーに ( ConditionalAttribute以外の) 属性を追加する。

情報テキストの末尾。

C.2 ISO/IEC 23271 で定義されている標準ライブラリの種類

注: 以下の一部の struct 型には、 readonly 修飾子があります。 この修飾子は ISO/IEC 23271 のリリース時には使用できませんでしたが、この仕様の実装に準拠するために必要です。 注釈

namespace System
{
    public delegate void Action();

    public class ArgumentException : SystemException
    {
        public ArgumentException();
        public ArgumentException(string? message);
        public ArgumentException(string? message, Exception? innerException);
    }

    public class ArgumentOutOfRangeException : ArgumentException
    {
        public ArgumentOutOfRangeException(string? paramName);
        public ArgumentOutOfRangeException(string? paramName, string? message);
    }

    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 Exception? InnerException { get; }
        public virtual string Message { get; }
    }

    public static class GC { }

    public interface IDisposable
    {
        void Dispose();
    }

    public interface IEquatable<T> where T : allows ref struct
    {
        bool Equals(T? other);
    }

    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> where T : struct
    {
        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);
        System.Collections.IEnumerator IEnumerable.GetEnumerator();
        System.Collections.Generic.IEnumerator<char> IEnumerable<char>.GetEnumerator();
    }

    public class SystemException : Exception
    {
        public SystemException();
        public SystemException(string? message);
        public SystemException(string? message, Exception? innerException);
    }

    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>();
        public static bool IsNullRef<T>(ref T source);
    }
}

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 interface IAsyncDisposable
    {
        System.Threading.Tasks.ValueTask DisposeAsync();
    }

    public abstract class FormattableString : IFormattable { }

    public static class MemoryExtensions
    {
        public static ReadOnlySpan<char> AsSpan (this string? text);
        public static bool SequenceEqual<T> (this Span<T> span, ReadOnlySpan<T> other)
          where T : IEquatable<T>;
        public static bool SequenceEqual<T> (this ReadOnlySpan<T> span,
          ReadOnlySpan<T> other) where T : IEquatable<T>;
    }

    public class OperationCanceledException : Exception
    {
        public OperationCanceledException();
        public OperationCanceledException(string? message);
        public OperationCanceledException(string? message, Exception? innerException);
    }

    /// <summary>
    ///    A read-only value type which represents an abstract
    ///    index to be used with collections.
    ///    - The Index can be relative to the start or end of a
    ///      collection.
    ///    - An Index can be converted to a zero-based concrete
    ///      from-start index to be used with a collection
    ///      of some specified length.
    ///    - Equality between Index values is provided, however
    ///      unlike concrete indices they are not ordered.
    ///    - Array and String element access support indexing
    ///      with Index values.
    /// </summary>
    public readonly struct Index : IEquatable<Index>
    {
        /// <summary>
        ///    Construct an Index from an integer value and a
        ///    boolean indicating whether the value is relative
        ///    to the end (true) or start (false).
        /// </summary>
        /// <param name="value">
        ///    The value, must be ≥ 0.
        /// </param>
        /// <param name="fromEnd">
        ///    Optional boolean indicating whether the Index is
        ///    relative to the end (true) or start (false).
        ///    The default value is false.
        /// </param>
        /// <exception cref="ArgumentOutOfRangeException">
        ///    Thrown if value < 0.
        /// </exception>
        /// <remarks>
        ///    If the Index is relative to the start then:
        ///       - the value 0 refers to the first element.
        ///    If the Index is relative to the end then:
        ///       - the value 1 refers to the last element; and
        ///       - the value 0 refers to beyond last element.
        /// </remarks>
        public Index(int value, bool fromEnd = false);

        /// <summary>
        ///    Implicit conversion from integer to a
        ///    from-start Index.
        /// </summary>
        /// <remarks>
        ///    The predefined operator:
        ///       <c>Index operator ^(int value);</c>
        ///    is provided to convert from integer to a
        ///    from-end Index.
        /// </remarks>
        public static implicit operator Index(int value);

        /// <summary>
        ///    Return the value.
        /// </summary>
        public int Value { get; }

        /// <summary>
        ///    Return whether the Index is relative to
        ///    the end (true) or start (false).
        /// </summary>
        public bool IsFromEnd { get; }

        /// <summary>
        ///    Return a concrete from-start index for a
        ///    given collection length.
        /// </summary>
        /// <param name="length">
        ///    The length of the collection that the index
        ///    will be used with.
        /// </param>
        /// <remarks>
        ///    This method performs no sanity checking and
        ///    will never throw an IndexOutOfRangeException.
        ///    It is expected that the returned index will be
        ///    used with a collection which will do validation.
        /// </remarks>
        public int GetOffset(int length);

        /// <summary>
        ///    Indicates whether the current Index value is
        ///    equal to another Index value.
        /// </summary>
        /// <param name="other">
        ///    The value to compare with this Index.
        /// </param>
        public bool Equals(Index other);
    }

    /// <summary>
    ///    A read-only value type which represents a range of
    ///    abstract indices to be used with collections.
    ///    - The Range has two Index properties, Start and End.
    ///    - A Range can be converted to a concrete index from
    ///      the start and a length value to be used with a
    ///      collection of some specified length.
    ///    - Equality between Range values is provided,
    ///      however they are not ordered.
    ///    - Array and String element access supports indexing
    ///      with Range values, returning a sub-array/substring
    ///      of the indexed value respectively.
    /// </summary>
    public readonly struct Range : IEquatable<Range>
    {
        /// <summary>
        ///    Construct a Range from two Index values.
        /// </summary>
        /// <param name="start">
        ///    The inclusive Index value for the start
        ///    of the range.
        /// </param>
        /// <param name="end">
        ///    The exclusive Index value for the end
        ///    of the range.</param>
        /// <remarks>
        ///    As Index values represent unordered abstract
        ///    indices no sanity checking can be performed
        ///    on the resultant Range value,
        ///    <see cref="GetOffsetAndLength">".
        ///
        ///    The predefined operator:
        ///       <c>Range operator ..(Index start, Index end);</c>
        ///    also exists to create a Range value.
        /// </remarks>
        public Range(Index start, Index end);

        /// <summary>Return the starting Index.</summary>
        public Index Start { get; }

        /// <summary>Return the ending Index.</summary>
        public Index End { get; }

        /// <summary>
        ///    Return a concrete from-start index and the
        ///    range length for a given collection length.
        /// </summary>
        /// <param name="length">
        ///    The length of the collection that the result
        ///    will be used with.
        /// </param>
        /// <exception cref="ArgumentOutOfRangeException">
        ///    Thrown if the range is not valid wrt length.
        /// </exception>
        /// <returns>
        ///    A tuple consisting of an index value and range length
        /// </returns>
        public (int Offset, int Length) GetOffsetAndLength(int length);

        /// <summary>
        ///    Indicates whether the current Range value is equal
        ///    to another Range value.
        /// </summary>
        /// <param name="other">
        ///    The value to compare with this Range.
        /// </param>
        public bool Equals(Range other);
    }

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

    public interface IAsyncEnumerable<out T>
    {
        IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken token = default);
    }

    public interface IAsyncEnumerator<out T> : IAsyncDisposable
    {
        System.Threading.Tasks.ValueTask<bool> MoveNextAsync();
        T Current { get; }
    }
}

namespace System.Diagnostics.CodeAnalysis
{
    [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.Method | 
    System.AttributeTargets.Property, AllowMultiple=true, Inherited=false)]
    public sealed class MemberNotNullAttribute : Attribute
    {
        public MemberNotNullAttribute(string member) {}
        public MemberNotNullAttribute(params string[] members) {}
    }

    [System.AttributeUsage(System.AttributeTargets.Method | 
      System.AttributeTargets.Property, AllowMultiple=true, Inherited=false)]
    public sealed class MemberNotNullWhenAttribute : Attribute
    {
        public MemberNotNullWhenAttribute(bool returnValue, string member) {}
        public MemberNotNullWhenAttribute(bool returnValue, params string[] members) {}
    }

    [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);
    }

    [System.AttributeUsage(System.AttributeTargets.Method
      | System.AttributeTargets.Parameter
      | System.AttributeTargets.Property,
      AllowMultiple=false, Inherited=false)]
    public sealed class UnscopedRefAttribute : Attribute
    {
        public UnscopedRefAttribute();
    }

    [System.AttributeUsage(System.AttributeTargets.Constructor,
      AllowMultiple=false, Inherited=false)]
    public sealed class SetsRequiredMembersAttribute : Attribute
    {
        public SetsRequiredMembersAttribute() {}
    }
}

namespace System.Linq.Expressions
{
    public sealed class Expression<TDelegate>
    {
        public TDelegate Compile();
        public static UnaryExpression NegateChecked(Expression expression,
            MethodInfo? method);
        public static BinaryExpression AddChecked(Expression left,
            Expression right, MethodInfo? method);
        public static BinaryExpression SubtractChecked(Expression left,
            Expression right, MethodInfo? method);
        public static BinaryExpression MultiplyChecked(Expression left,
            Expression right, MethodInfo? method);
        public static UnaryExpression ConvertChecked(Expression expression,
            Type type, MethodInfo? method);
    }
}

namespace System.Runtime.CompilerServices
{
    [System.AttributeUsage(System.AttributeTargets.Class
      | System.AttributeTargets.Interface
      | System.AttributeTargets.Struct, Inherited=false)]
    public sealed class CollectionBuilderAttribute : System.Attribute
    {
        public CollectionBuilderAttribute(Type builderType, string methodName);
        public Type BuilderType { get; }
        public string MethodName { get; }
    }

    public ref struct DefaultInterpolatedStringHandler
    {
        public DefaultInterpolatedStringHandler(int literalLength,
            int formattedCount);
        public DefaultInterpolatedStringHandler(int literalLength,
            int formattedCount, IFormatProvider? provider);
        public DefaultInterpolatedStringHandler(int literalLength,
            int formattedCount, IFormatProvider? provider, Span<char> initialBuffer);
        public void AppendFormatted(scoped ReadOnlySpan<char> value);
        public void AppendFormatted(string? value);
        public void AppendFormatted(object? value, int alignment = 0,
            string? format = default);
        public void AppendFormatted(scoped ReadOnlySpan<char> value,
            int alignment = 0, string? format = default);
        public void AppendFormatted(string? value, int alignment = 0,
            string? format = default);
        public void AppendFormatted<T>(T value);
        public void AppendFormatted<T>(T value, int alignment);
        public void AppendFormatted<T>(T value, string? format);
        public void AppendFormatted<T>(T value, int alignment, string? format);
        public void AppendLiteral(string value);
        public override string ToString();
        public string ToStringAndClear();
    }

    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | 
        AttributeTargets.Interface | AttributeTargets.Method,
        Inherited = false, AllowMultiple = false)]
    public sealed class AsyncMethodBuilderAttribute : Attribute
    {
        public AsyncMethodBuilderAttribute(Type builderType);
 
        public Type BuilderType { get; }
    }

    [AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false,
        Inherited = false)]
    public sealed class CallerArgumentExpressionAttribute : Attribute
    {
        public CallerArgumentExpressionAttribute(string parameterName);
    }

    [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();
    }

    [System.AttributeUsage(System.AttributeTargets.Parameter, Inherited=false)]
    public sealed class EnumeratorCancellationAttribute : Attribute
    {
        public EnumeratorCancellationAttribute();
    }
    
    public static class FormattableStringFactory
    {
        public static FormattableString Create(string format,
            params object?[] arguments);
    }

    public interface ICriticalNotifyCompletion : INotifyCompletion
    {
        void UnsafeOnCompleted(Action continuation);
    }

    [AttributeUsage(AttributeTargets.Struct, AllowMultiple=false)]
    public sealed class InlineArrayAttribute : Attribute
    {
        public InlineArrayAttribute(int length);

        public int Length { get; }
    }

    public interface INotifyCompletion
    {
        void OnCompleted(Action continuation);
    }

    [System.AttributeUsage(System.AttributeTargets.Parameter,
        AllowMultiple=false, Inherited=false)]
    public sealed class InterpolatedStringHandlerArgumentAttribute : Attribute
    {
        public InterpolatedStringHandlerArgumentAttribute(string argument);
        public InterpolatedStringHandlerArgumentAttribute(params string[] arguments);
    }

    [System.AttributeUsage(System.AttributeTargets.Class |
        System.AttributeTargets.Struct, AllowMultiple=false, Inherited=false)]
    public sealed class InterpolatedStringHandlerAttribute : Attribute
    {
        public InterpolatedStringHandlerAttribute ();
    }

    /// <summary>
    ///    Provides indexed access to the elements of a
    ///    tuple-like value at runtime. This interface is
    ///    used by the language to implement positional
    ///    pattern matching (§11.2.5) when no static
    ///    tuple type or <c>Deconstruct</c> method is
    ///    available.
    /// </summary>
    public interface ITuple
    {
        /// <summary>
        ///    The number of elements in the tuple.
        /// </summary>
        /// <remarks>
        ///    The value returned shall be non-negative,
        ///    and shall not change for the lifetime of
        ///    the instance.
        /// </remarks>
        int Length { get; }

        /// <summary>
        ///    Returns the element at the specified
        ///    zero-based position.
        /// </summary>
        /// <param name="index">
        ///    The zero-based position of the element
        ///    to return; shall be ≥ 0 and &lt; <see cref="Length"/>.
        /// </param>
        /// <exception cref="IndexOutOfRangeException">
        ///    Thrown if <paramref name="index"/> is
        ///    outside the range
        ///    <c>[0, Length)</c>.
        /// </exception>
        object? this[int index] { get; }
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
    public sealed class ModuleInitializerAttribute : Attribute
    {
        public ModuleInitializerAttribute() { }
    }

    [System.AttributeUsage(System.AttributeTargets.Constructor
    | System.AttributeTargets.Method | System.AttributeTargets.Property,
      AllowMultiple=false, Inherited=false)]
    public sealed class OverloadResolutionPriorityAttribute : Attribute
    {
        public OverloadResolutionPriorityAttribute(int priority) {}
    }

    [System.AttributeUsage(System.AttributeTargets.Class |
      System.AttributeTargets.Field | System.AttributeTargets.Property |
      System.AttributeTargets.Struct, AllowMultiple=false, Inherited=false)]
    public sealed class RequiredMemberAttribute : Attribute
    {
        public RequiredMemberAttribute() {}
    }

    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();
    }

    [System.AttributeUsage(System.AttributeTargets.Method, Inherited=false)]
    public sealed class UnmanagedCallersOnlyAttribute : Attribute
    {
        public UnmanagedCallersOnlyAttribute ();
        public Type[]? CallConvs;
        public string? EntryPoint;
    }

    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();
    }
}

namespace System.Threading
{
    public class CancellationTokenSource : IDisposable
    {
        public CancellationTokenSource();
        public System.Threading.CancellationToken Token { get; }
        public void Cancel();
        public static CancellationTokenSource CreateLinkedTokenSource
                                             (CancellationToken token1,
                                              CancellationToken token2);
    }

    public readonly struct CancellationToken : IEquatable<CancellationToken>
    {
        public bool IsCancellationRequested { get; }
    }

    public sealed class Lock
    {
        public Lock();
        public System.Threading.Lock.Scope EnterScope();
        public ref struct Lock.Scope
        {
            public void Dispose();
        }
    }
}

namespace System.Threading.Tasks
{
    public class Task
    {
        public System.Runtime.CompilerServices.TaskAwaiter GetAwaiter();
    }

    public class Task<TResult> : Task
    {
        public new System.Runtime.CompilerServices.TaskAwaiter<TResult> 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の説明から次のテキストがコピーされます。

このテキストは有益です。

format は、オブジェクトが文字列に変換されたときの外観を表す文字列です。 標準形式またはカスタム形式を使用できます。 標準形式は Axx という形式になります。ここで、 A は format specifier と呼ばれる 1 文字の英字で、 xx は 0 から 99 までの整数で、 precision 指定子と呼ばれます。 書式指定子は、文字列として表される値に適用される書式設定の種類を制御します。 precision 指定子は、文字列内の有効桁数または小数点以下桁数 (該当する場合) を制御します。

注: 標準書式指定子の一覧については、次の表を参照してください。 System.Int32などの特定のデータ型では、1 つ以上の標準書式指定子がサポートされない場合があることに注意してください。 注釈

注: 書式にカルチャによって異なる記号 ('C' 形式や 'c' 形式に含まれる currencysymbol など) が含まれている場合、書式設定オブジェクトは文字列表現で使用される実際の文字を提供します。 メソッドには、書式設定オブジェクトを提供する System.IFormatProvider オブジェクトを渡すパラメーターが含まれている場合や、現在のカルチャのシンボル定義を含む既定の書式設定オブジェクトを使用する場合があります。 現在のカルチャでは、通常、既定でシステム全体で使用されているのと同じシンボル セットが使用されます。 基本クラス ライブラリでは、システム指定の数値型の書式設定オブジェクトは System.Globalization.NumberFormatInfo インスタンスです。 System.DateTimeインスタンスの場合は、System.Globalization.DateTimeFormatInfoが使用されます。 注釈

次の表では、基本クラス ライブラリの数値データ型で使用される標準書式指定子と関連する書式設定オブジェクト メンバーについて説明します。

数値がSystem.Single、System.Double、またはNaNの値を持つPositiveInfinityまたはNegativeInfinityの場合、書式指定子は無視され、System.Globalization.NumberFormatInfo.NaNSymbol、System.Globalization.NumberFormatInfo.PositiveInfinitySymbol、またはSystem.Globalization.NumberFormatInfo.NegativeInfinitySymbolのいずれかが返されます。

カスタム書式は、上記の標準書式指定文字列 (Axx) の形式ではない書式として指定された任意の文字列です。 次の表では、カスタム形式の構築に使用される文字について説明します。

固定小数点書式指定文字列 ('E0'、'E+0'、'E-0'、'e0'、'e+0'、または 'e-0' を含まない文字列) の場合、小数点区切り記号の右側にゼロまたは桁のプレースホルダーがある数の小数点以下に数値が丸められます。 ユーザー設定の書式に小数点が含まれていない場合、数値は最も近い整数に丸められます。 数値の桁数が、小数点の左側にゼロまたは数字のプレースホルダーよりも多い場合、余分な数字は、最初のゼロまたは数字のプレースホルダーの直前の出力文字列にコピーされます。

カスタム書式には、セクション区切り文字で区切られた最大 3 つのセクションを含めることができます。正、負、ゼロの値に異なる書式を指定できます。 セクションは次のように解釈されます。

• 1 つのセクション: カスタム形式はすべての値 (正、負、ゼロ) に適用されます。 負の値には負の符号が含まれます。

• 2 つのセクション: 最初のセクションは正の値と 0 に適用され、2 番目のセクションは負の値に適用されます。 書式設定する値が負の値で、2 番目のセクションの書式に従って丸めた後に 0 になる場合、結果の 0 は最初のセクションに従って書式設定されます。 負の値には、負の値の表現を完全に制御するための負の符号は含まれません。 たとえば、負の値は、'####.# のようなカスタム形式を使用してかっこで表すことができます。(####.####)’.

• 3 つのセクション: 最初のセクションは正の値に適用され、2 番目のセクションは負の値に適用され、3 番目のセクションはゼロに適用されます。 2 番目のセクションは空にすることができます (セミコロンの間には何も表示されません)。この場合、最初のセクションはすべての 0 以外の値に適用され、負の値には負の符号が含まれます。 書式設定する数値が 0 以外で、1 番目または 2 番目のセクションの書式に従って丸めた後に 0 になる場合、結果の 0 は 3 番目のセクションに従って書式設定されます。

System.Enum型とSystem.DateTime型では、書式指定子を使用して値の文字列形式を書式設定することもできます。 特定の書式指定子の意味は、書式設定されるデータの種類 (数値、日付/時刻、列挙) によって異なります。 各型でサポートされている書式指定子の包括的な一覧については、 System.Enum と System.Globalization.DateTimeFormatInfo を参照してください。

C.5 ライブラリの種類の省略形

この仕様では、次のライブラリの種類が参照されています。 グローバル名前空間修飾子を含む、これらの型の完全な名前を次に示します。 この仕様では、これらの型は完全修飾名として表示されます。グローバル名前空間修飾子を省略した場合。または単純な非修飾型名として、名前空間も省略します。 たとえば、この仕様で使用する場合、型 ICollection<T>は常に型 global::System.Collections.Generic.ICollection<T>を意味します。

• global::System.Action
• global::System.ArgumentException
• global::System.ArgumentOutOfRangeException
• global::System.ArithmeticException
• global::System.Array
• global::System.ArrayTypeMismatchException
• global::System.Attribute
• global::System.AttributeTargets
• global::System.AttributeUsageAttribute
• global::System.Boolean
• global::System.Byte
• global::System.Char
• global::System.Decimal
• global::System.Delegate
• global::System.DivideByZeroException
• global::System.Double
• global::System.Enum
• global::System.Exception
• global::System.FormattableString
• global::System.GC
• global::System.IAsyncDisposable
• global::System.IDisposable
• global::System.IEquatable<T>
• global::System.IFormattable
• global::System.Index
• global::System.IndexOutOfRangeException
• global::System.Int16
• global::System.Int32
• global::System.Int64
• global::System.IntPtr
• global::System.InvalidCastException
• global::System.InvalidOperationException
• global::System.MemoryExtensions
• global::System.NotSupportedException
• global::System.Nullable<T>
• global::System.NullReferenceException
• global::System.Object
• global::System.ObsoleteAttribute
• global::System.OperationCanceledException
• global::System.OutOfMemoryException
• global::System.OverflowException
• global::System.Range
• global::System.ReadOnlySpan
• global::System.SByte
• global::System.Single
• global::System.Span
• global::System.StackOverflowException
• global::System.String
• global::System.SystemException
• global::System.Type
• global::System.TypeInitializationException
• global::System.UInt16
• global::System.UInt32
• global::System.UInt64
• global::System.UIntPtr
• global::System.ValueTuple<T1>
• global::System.ValueTuple<T1, T2>
• global::System.ValueTuple<T1, T2, T3>
• global::System.ValueTuple<T1, T2, T3, T4>
• global::System.ValueTuple<T1, T2, T3, T4, T5>
• global::System.ValueTuple<T1, T2, T3, T4, T5, T6>
• global::System.ValueTuple<T1, T2, T3, T4, T5, T6, T7>
• global::System.ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest>
• global::System.ValueType
• global::System.Collections.ICollection
• global::System.Collections.IEnumerable
• global::System.Collections.IEnumerator
• global::System.Collections.IList
• global::System.Collections.Generic.IAsyncEnumerable<out T>
• global::System.Collections.Generic.IAsyncEnumerator<out T>
• global::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.Diagnostics.ConditionalAttribute
• global::System.Diagnostics.CodeAnalysis.AllowNullAttribute
• global::System.Diagnostics.CodeAnalysis.DisallowNullAttribute
• global::System.Diagnostics.CodeAnalysis.DoesNotReturnAttribute
• global::System.Diagnostics.CodeAnalysis.DoesNotReturnIfAttribute
• global::System.Diagnostics.CodeAnalysis.MaybeNullAttribute
• global::System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute
• global::System.Diagnostics.CodeAnalysis.MemberNotNullAttribute
• global::System.Diagnostics.CodeAnalysis.MemberNotNullWhenAttribute
• global::System.Diagnostics.CodeAnalysis.NotNullAttribute
• global::System.Diagnostics.CodeAnalysis.NotNullIfNotNullAttribute
• global::System.Diagnostics.CodeAnalysis.NotNullWhenAttribute
• global::System.Diagnostics.CodeAnalysis.UnscopedRefAttribute
• global::System.Diagnostics.CodeAnalysis.SetsRequiredMembersAttribute
• global::System.Linq.Expressions.Expression<TDelegate>
• global::System.Reflection.MemberInfo
• global::System.Runtime.CompilerServices.AsyncMethodBuilderAttribute
• global::System.Runtime.CompilerServices.CallerArgumentExpressionAttribute
• global::System.Runtime.CompilerServices.CallerFilePathAttribute
• global::System.Runtime.CompilerServices.CallerLineNumberAttribute
• global::System.Runtime.CompilerServices.CallerMemberNameAttribute
• global::System.Runtime.CompilerServices.CollectionBuilderAttribute
• global::System.Runtime.CompilerServices.DefaultInterpolatedStringHandler
• global::System.Runtime.CompilerServices.FormattableStringFactory
• global::System.Runtime.CompilerServices.ICriticalNotifyCompletion
• global::System.Runtime.CompilerServices.IndexerNameAttribute
• global::System.Runtime.CompilerServices.InlineArrayAttribute
• global::System.Runtime.CompilerServices.INotifyCompletion
• global::System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute
• global::System.Runtime.CompilerServices.InterpolatedStringHandlerAttribute
• global::System.Runtime.CompilerServices.ITuple
• global::System.Runtime.CompilerServices.ModuleInitializerAttribute
• global::System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute
• global::System.Runtime.CompilerServices.RequiredMemberAttribute
• global::System.Runtime.CompilerServices.TaskAwaiter
• global::System.Runtime.CompilerServices.TaskAwaiter<TResult>
• global::System.Runtime.CompilerServices.ValueTaskAwaiter
• global::System.Runtime.CompilerServices.ValueTaskAwaiter<TResult>
• global::System.Runtime.CompilerServices.Unsafe
• global::System.Runtime.InteropServices.UnmanagedCallersOnlyAttribute
• global::System.Threading.Lock
• global::System.Threading.Lock.Scope
• global::System.Threading.Monitor
• global::System.Threading.Tasks.Task
• global::System.Threading.Tasks.Task<TResult>

情報テキストの末尾。