Anexo C Biblioteca normalizada

Artigo
02/06/2025

C.1 Generalidades

Uma implementação C# em conformidade deve fornecer um conjunto mínimo de tipos com semântica específica. Esses tipos e seus membros são listados aqui, em ordem alfabética por namespace e tipo. Para uma definição formal desses tipos e seus membros, consulte ISO/IEC 23271:2012 Common Language Infrastructure (CLI), Partition IV; Base Class Library (BCL), Extended Numerics Library e Extended Array Library, que estão incluídas por referência nesta especificação.

Este texto é informativo.

A biblioteca padrão destina-se a ser o conjunto mínimo de tipos e membros exigidos por uma implementação C# em conformidade. Como tal, ele contém apenas os membros que são explicitamente exigidos pela especificação da linguagem C#.

Espera-se que uma implementação C# em conformidade forneça uma biblioteca significativamente mais extensa que permita a escrita de programas úteis. Por exemplo, uma implementação em conformidade pode estender essa biblioteca por

Adicionando namespaces.
Adicionando tipos.
Adicionando membros a tipos que não são de interface.
Adicionar classes base ou interfaces intervenientes.
Ter os tipos struct e class implementa interfaces adicionais.
Adicionar atributos (diferentes do ConditionalAttribute) a tipos e membros existentes.

Fim do texto informativo.

C.2 Tipos de bibliotecas padrão definidos na ISO/IEC 23271

Nota: Alguns struct tipos abaixo têm o readonly modificador. Este modificador não estava disponível quando a ISO/IEC 23271 foi lançada, mas é necessário para implementações conformes desta especificação. Nota final

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

namespace System.Threading
{
    public static class Monitor
    {
        public static void Enter(object obj);
        public static void Exit(object obj);
    }
}

C.3 Tipos de bibliotecas normalizadas não definidos na ISO/IEC 23271

Os seguintes tipos, incluindo os membros enumerados, devem ser definidos numa biblioteca normalizada conforme. (Esses tipos podem ser definidos em uma edição futura da ISO/IEC 23271.) Espera-se que muitos desses tipos tenham mais membros disponíveis do que os listados.

Uma implementação conforme pode fornecer Task.GetAwaiter() e Task<TResult>.GetAwaiter() como métodos de extensão.

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

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 Especificações de formato

O significado dos formatos, tal como utilizados em expressões de cadeia interpoladas (§12.8.3), está definido na ISO/IEC 23271:2012. Por conveniência, o texto a seguir é copiado da descrição do System.IFormattable.

Este texto é informativo.

Um formato é uma cadeia de caracteres que descreve a aparência de um objeto quando ele é convertido em uma cadeia de caracteres. Podem ser utilizados formatos padrão ou personalizados. Um formato padrão assume a forma Axx, onde A é um único caractere alfabético chamado especificador de formato, e xx é um inteiro entre zero e 99 inclusive, chamado especificador de precisão. O especificador de formato controla o tipo de formatação aplicada ao valor que está sendo representado como uma cadeia de caracteres. O especificador de precisão controla o número de dígitos significativos ou casas decimais na cadeia de caracteres, se aplicável.

Nota: Para a lista de especificadores de formato padrão, consulte a tabela abaixo. Observe que um determinado tipo de dados, como System.Int32, pode não suportar um ou mais dos especificadores de formato padrão. Nota final

Nota: Quando um formato inclui símbolos que variam de acordo com a cultura, como o símbolo de moeda incluído pelos formatos 'C' e 'c', um objeto de formatação fornece os caracteres reais usados na representação da cadeia de caracteres. Um método pode incluir um parâmetro para passar um System.IFormatProvider objeto que fornece um objeto de formatação, ou o método pode usar o objeto de formatação padrão, que contém as definições de símbolo para a cultura atual. A cultura atual normalmente usa o mesmo conjunto de símbolos usados em todo o sistema por padrão. Na Biblioteca de Classes Base, o objeto de formatação para tipos numéricos fornecidos pelo sistema é uma System.Globalization.NumberFormatInfo instância. Por System.DateTime exemplo, um System.Globalization.DateTimeFormatInfo é usado. Nota final

A tabela a seguir descreve os especificadores de formato padrão e os membros do objeto de formatação associados que são usados com tipos de dados numéricos na Biblioteca de Classes Base.

Especificador de formato Description

Especificador de formato	Description
`C` `c`	Formato da moeda: Usado para cadeias de caracteres que contêm um valor monetário. O `System.Globalization.NumberFormatInfo.CurrencySymbol`, `System.Globalization.NumberFormatInfo.CurrencyGroupSizes`, `System.Globalization.NumberFormatInfo.CurrencyGroupSeparator`e `System.Globalization.NumberFormatInfo.CurrencyDecimalSeparator` os membros de um `System.Globalization.NumberFormatInfo` fornecem o símbolo de moeda, tamanho e separador para agrupamentos de dígitos e separador decimal, respectivamente. `System.Globalization.NumberFormatInfo.CurrencyNegativePattern` e `System.Globalization.NumberFormatInfo.CurrencyPositivePattern` determinar os símbolos utilizados para representar valores negativos e positivos. Por exemplo, um valor negativo pode ser prefixado com um sinal de menos ou entre parênteses. Se o especificador de precisão for omitido, `System.Globalization.NumberFormatInfo.CurrencyDecimalDigits` determina o número de casas decimais na cadeia de caracteres. Os resultados são arredondados para o valor representável mais próximo quando necessário.
`D` `d`	Formato decimal: (Este formato é válido somente quando especificado com tipos de dados integrais.) Usado para cadeias de caracteres que contêm valores inteiros. Os números negativos são prefixados com o símbolo de número negativo especificado pela `System.Globalization.NumberFormatInfo.NegativeSign` propriedade. O especificador de precisão determina o número mínimo de dígitos que aparecem na cadeia de caracteres. Se a precisão especificada exigir mais dígitos do que o valor contém, a cadeia de caracteres será preenchida à esquerda com zeros. Se o especificador de precisão especificar menos dígitos do que os do valor, o especificador de precisão será ignorado.
`E` `e`	Formato Científico (Engenharia): Usado para cordas em uma das seguintes formas: [-]m.ddddddE+xxx [-]m.ddddddE-xxx [-]m.dddddde+xxx [-]M.ddddddE-xxx O símbolo de número negativo ('-') aparece apenas se o valor for negativo e for fornecido pela `System.Globalization.NumberFormatInfo.NegativeSign` propriedade. Exatamente um dígito decimal diferente de zero (m) precede o separador decimal ('.'), que é fornecido pela `System.Globalization.NumberFormatInfo.NumberDecimalSeparator` propriedade. O especificador de precisão determina o número de casas decimais (dddddd) na cadeia de caracteres. Se o especificador de precisão for omitido, seis casas decimais serão incluídas na cadeia de caracteres. O expoente (+/-xxx) consiste num símbolo numérico positivo ou negativo seguido de um mínimo de três dígitos (xxx). O expoente é acolchoado à esquerda com zeros, se necessário. O caso do especificador de formato ('E' ou 'e') determina o caso usado para o prefixo expoente (E ou e) na cadeia de caracteres. Os resultados são arredondados para o valor representável mais próximo quando necessário. O símbolo de `System.Globalization.NumberFormatInfo.PositiveSign` número positivo é fornecido pela propriedade.
`F` `f`	Formato de ponto fixo: Usado para cadeias de caracteres na seguinte forma: [-]M.dd... d Pelo menos um dígito decimal diferente de zero (m) precede o separador decimal ('.'), que é fornecido pela `System.Globalization.NumberFormatInfo.NumberDecimalSeparator` propriedade. Um sinal de símbolo numérico negativo ('-') precede m apenas se o valor for negativo. Este símbolo é fornecido pela `System.Globalization.NumberFormatInfo.NegativeSign` propriedade. O especificador de precisão determina o número de casas decimais (dd... d) na corda. Se o especificador de precisão for omitido, `System.Globalization.NumberFormatInfo.NumberDecimalDigits` determina o número de casas decimais na cadeia de caracteres. Os resultados são arredondados para o valor representável mais próximo quando necessário.
`G` `g`	Formato geral: A cadeia de caracteres é formatada em formato de ponto fixo ('F' ou 'f') ou em formato científico ('E' ou 'e'). Para tipos integrais: Os valores são formatados usando o formato de ponto fixo se especificador de precisão expoente< , onde expoente é o expoente do valor em formato científico. Para todos os outros valores, é utilizado o formato científico. Se o especificador de precisão for omitido, será usada uma precisão padrão igual à largura do campo necessária para exibir o valor máximo para o tipo de dados, o que resulta na formatação do valor no formato de ponto fixo. As precisões padrão para tipos integrais são as seguintes: `System.Int16`, `System.UInt16` : 5 `System.Int32`, `System.UInt32` : 10 `System.Int64`, `System.UInt64` : 19 Para os tipos Simples, Decimais e Duplos: Os valores são formatados usando o formato de ponto fixo se o expoente ≥ -4 e <, onde expoente é o expoente do valor em formato científico. Para todos os outros valores, é utilizado o formato científico. Os resultados são arredondados para o valor representável mais próximo quando necessário. Se o especificador de precisão for omitido, as seguintes precisões padrão serão usadas: `System.Single` : 7 `System.Double` : 15 `System.Decimal` : 29 Para todos os tipos: O número de algarismos que aparecem no resultado (não incluindo o expoente) não excederá o valor do especificador de precisão; os valores são arredondados conforme necessário. O ponto decimal e quaisquer zeros à direita após o ponto decimal são removidos sempre que possível. O caso do especificador de formato ('G' ou 'g') determina se 'E' ou 'e' prefixa o expoente do formato científico.
`N` `n`	Formato de número: Usado para cadeias de caracteres no seguinte formato: [-]d,ddd,ddd.dd... d A representação de valores negativos é determinada pela `System.Globalization.NumberFormatInfo.NumberNegativePattern` propriedade. Se o padrão incluir um símbolo de número negativo ('-'), esse símbolo é fornecido pela `System.Globalization.NumberFormatInfo.NegativeSign` propriedade. Pelo menos um dígito decimal diferente de zero (d) precede o separador decimal ('.'), que é fornecido pela `System.Globalization.NumberFormatInfo.NumberDecimalSeparator` propriedade. Os dígitos entre o ponto decimal e o dígito mais significativo no valor são agrupados usando o tamanho do grupo especificado pela `System.Globalization.NumberFormatInfo.NumberGroupSizes` propriedade. O separador de grupo (',') é inserido `System.Globalization.NumberFormatInfo.NumberGroupSeparator` entre cada grupo de dígitos e é fornecido pela propriedade. O especificador de precisão determina o número de casas decimais (dd... d). Se o especificador de precisão for omitido, `System.Globalization.NumberFormatInfo.NumberDecimalDigits` determina o número de casas decimais na cadeia de caracteres. Os resultados são arredondados para o valor representável mais próximo quando necessário.
`P` `p`	Formato de porcentagem: usado para cadeias de caracteres que contêm uma porcentagem. O `System.Globalization.NumberFormatInfo.PercentSymbol`, `System.Globalization.NumberFormatInfo.PercentGroupSizes`, `System.Globalization.NumberFormatInfo.PercentGroupSeparator`e `System.Globalization.NumberFormatInfo.PercentDecimalSeparator` os membros de um `System.Globalization.NumberFormatInfo` fornecem o símbolo de porcentagem, tamanho e separador para agrupamentos de dígitos e separador decimal, respectivamente. `System.Globalization.NumberFormatInfo.PercentNegativePattern` e `System.Globalization.NumberFormatInfo.PercentPositivePattern` determinar os símbolos utilizados para representar valores negativos e positivos. Por exemplo, um valor negativo pode ser prefixado com um sinal de menos ou entre parênteses. Se não for especificada qualquer precisão, o número de casas decimais no resultado é determinado por `System.Globalization.NumberFormatInfo.PercentDecimalDigits`. Os resultados são arredondados para o valor representável mais próximo quando necessário. O resultado é dimensionado por 100 (0,99 passa a ser 99%).
`R` `r`	Formato de ida e volta: (Este formato é válido apenas quando especificado com `System.Double` ou `System.Single`.) Usado para garantir que a precisão da representação da cadeia de caracteres de um valor de vírgula flutuante seja tal que a análise da cadeia de caracteres não resulte em uma perda de precisão quando comparada ao valor original. Se a precisão máxima do tipo de dados (7 para `System.Single`, e 15 para `System.Double`) resultar em uma perda de precisão, a precisão é aumentada em duas casas decimais. Se um especificador de precisão for fornecido com este especificador de formato, ele será ignorado. Este formato é idêntico ao formato de ponto fixo.
`X` `x`	Formato hexadecimal: (Este formato é válido somente quando especificado com tipos de dados integrais.) Usado para representações de cadeia de caracteres de números na Base 16. A precisão determina o número mínimo de dígitos na cadeia de caracteres. Se a precisão especificar mais dígitos do que o número contém, o número será acolchoado à esquerda com zeros. O caso do especificador de formato ('X' ou 'x') determina se letras maiúsculas ou minúsculas são usadas na representação hexadecimal.

C

c

Formato da moeda: Usado para cadeias de caracteres que contêm um valor monetário. O System.Globalization.NumberFormatInfo.CurrencySymbol, System.Globalization.NumberFormatInfo.CurrencyGroupSizes, System.Globalization.NumberFormatInfo.CurrencyGroupSeparatore System.Globalization.NumberFormatInfo.CurrencyDecimalSeparator os membros de um System.Globalization.NumberFormatInfo fornecem o símbolo de moeda, tamanho e separador para agrupamentos de dígitos e separador decimal, respectivamente.

System.Globalization.NumberFormatInfo.CurrencyNegativePattern e System.Globalization.NumberFormatInfo.CurrencyPositivePattern determinar os símbolos utilizados para representar valores negativos e positivos. Por exemplo, um valor negativo pode ser prefixado com um sinal de menos ou entre parênteses.

Se o especificador de precisão for omitido, System.Globalization.NumberFormatInfo.CurrencyDecimalDigits determina o número de casas decimais na cadeia de caracteres. Os resultados são arredondados para o valor representável mais próximo quando necessário.

D

d

Formato decimal: (Este formato é válido somente quando especificado com tipos de dados integrais.) Usado para cadeias de caracteres que contêm valores inteiros. Os números negativos são prefixados com o símbolo de número negativo especificado pela System.Globalization.NumberFormatInfo.NegativeSign propriedade.

O especificador de precisão determina o número mínimo de dígitos que aparecem na cadeia de caracteres. Se a precisão especificada exigir mais dígitos do que o valor contém, a cadeia de caracteres será preenchida à esquerda com zeros. Se o especificador de precisão especificar menos dígitos do que os do valor, o especificador de precisão será ignorado.

E

e

Formato Científico (Engenharia): Usado para cordas em uma das seguintes formas:

[-]m.ddddddE+xxx

[-]m.ddddddE-xxx

[-]m.dddddde+xxx

[-]M.ddddddE-xxx

O símbolo de número negativo ('-') aparece apenas se o valor for negativo e for fornecido pela System.Globalization.NumberFormatInfo.NegativeSign propriedade.

Exatamente um dígito decimal diferente de zero (m) precede o separador decimal ('.'), que é fornecido pela System.Globalization.NumberFormatInfo.NumberDecimalSeparator propriedade.

O especificador de precisão determina o número de casas decimais (dddddd) na cadeia de caracteres. Se o especificador de precisão for omitido, seis casas decimais serão incluídas na cadeia de caracteres.

O expoente (+/-xxx) consiste num símbolo numérico positivo ou negativo seguido de um mínimo de três dígitos (xxx). O expoente é acolchoado à esquerda com zeros, se necessário. O caso do especificador de formato ('E' ou 'e') determina o caso usado para o prefixo expoente (E ou e) na cadeia de caracteres. Os resultados são arredondados para o valor representável mais próximo quando necessário. O símbolo de System.Globalization.NumberFormatInfo.PositiveSign número positivo é fornecido pela propriedade.

F

f

Formato de ponto fixo: Usado para cadeias de caracteres na seguinte forma:

[-]M.dd... d

Pelo menos um dígito decimal diferente de zero (m) precede o separador decimal ('.'), que é fornecido pela System.Globalization.NumberFormatInfo.NumberDecimalSeparator propriedade.

Um sinal de símbolo numérico negativo ('-') precede m apenas se o valor for negativo. Este símbolo é fornecido pela System.Globalization.NumberFormatInfo.NegativeSign propriedade.

O especificador de precisão determina o número de casas decimais (dd... d) na corda. Se o especificador de precisão for omitido, System.Globalization.NumberFormatInfo.NumberDecimalDigits determina o número de casas decimais na cadeia de caracteres. Os resultados são arredondados para o valor representável mais próximo quando necessário.

G

g

Formato geral: A cadeia de caracteres é formatada em formato de ponto fixo ('F' ou 'f') ou em formato científico ('E' ou 'e').

Para tipos integrais:

Os valores são formatados usando o formato de ponto fixo se especificador de precisão expoente< , onde expoente é o expoente do valor em formato científico. Para todos os outros valores, é utilizado o formato científico.

Se o especificador de precisão for omitido, será usada uma precisão padrão igual à largura do campo necessária para exibir o valor máximo para o tipo de dados, o que resulta na formatação do valor no formato de ponto fixo. As precisões padrão para tipos integrais são as seguintes:

System.Int16, System.UInt16 : 5

System.Int32, System.UInt32 : 10

System.Int64, System.UInt64 : 19

Para os tipos Simples, Decimais e Duplos:

Os valores são formatados usando o formato de ponto fixo se o expoente ≥ -4 e <, onde expoente é o expoente do valor em formato científico. Para todos os outros valores, é utilizado o formato científico. Os resultados são arredondados para o valor representável mais próximo quando necessário.

Se o especificador de precisão for omitido, as seguintes precisões padrão serão usadas:

System.Single : 7

System.Double : 15

System.Decimal : 29

Para todos os tipos:

O número de algarismos que aparecem no resultado (não incluindo o expoente) não excederá o valor do especificador de precisão; os valores são arredondados conforme necessário.
O ponto decimal e quaisquer zeros à direita após o ponto decimal são removidos sempre que possível.
O caso do especificador de formato ('G' ou 'g') determina se 'E' ou 'e' prefixa o expoente do formato científico.

N

n

Formato de número: Usado para cadeias de caracteres no seguinte formato:

[-]d,ddd,ddd.dd... d

A representação de valores negativos é determinada pela System.Globalization.NumberFormatInfo.NumberNegativePattern propriedade. Se o padrão incluir um símbolo de número negativo ('-'), esse símbolo é fornecido pela System.Globalization.NumberFormatInfo.NegativeSign propriedade.

Pelo menos um dígito decimal diferente de zero (d) precede o separador decimal ('.'), que é fornecido pela System.Globalization.NumberFormatInfo.NumberDecimalSeparator propriedade. Os dígitos entre o ponto decimal e o dígito mais significativo no valor são agrupados usando o tamanho do grupo especificado pela System.Globalization.NumberFormatInfo.NumberGroupSizes propriedade. O separador de grupo (',') é inserido System.Globalization.NumberFormatInfo.NumberGroupSeparator entre cada grupo de dígitos e é fornecido pela propriedade.

O especificador de precisão determina o número de casas decimais (dd... d). Se o especificador de precisão for omitido, System.Globalization.NumberFormatInfo.NumberDecimalDigits determina o número de casas decimais na cadeia de caracteres. Os resultados são arredondados para o valor representável mais próximo quando necessário.

P

p

Formato de porcentagem: usado para cadeias de caracteres que contêm uma porcentagem. O System.Globalization.NumberFormatInfo.PercentSymbol, System.Globalization.NumberFormatInfo.PercentGroupSizes, System.Globalization.NumberFormatInfo.PercentGroupSeparatore System.Globalization.NumberFormatInfo.PercentDecimalSeparator os membros de um System.Globalization.NumberFormatInfo fornecem o símbolo de porcentagem, tamanho e separador para agrupamentos de dígitos e separador decimal, respectivamente.

System.Globalization.NumberFormatInfo.PercentNegativePattern e System.Globalization.NumberFormatInfo.PercentPositivePattern determinar os símbolos utilizados para representar valores negativos e positivos. Por exemplo, um valor negativo pode ser prefixado com um sinal de menos ou entre parênteses.

Se não for especificada qualquer precisão, o número de casas decimais no resultado é determinado por System.Globalization.NumberFormatInfo.PercentDecimalDigits. Os resultados são arredondados para o valor representável mais próximo quando necessário.

O resultado é dimensionado por 100 (0,99 passa a ser 99%).

R

r

Formato de ida e volta: (Este formato é válido apenas quando especificado com System.Double ou System.Single.) Usado para garantir que a precisão da representação da cadeia de caracteres de um valor de vírgula flutuante seja tal que a análise da cadeia de caracteres não resulte em uma perda de precisão quando comparada ao valor original. Se a precisão máxima do tipo de dados (7 para System.Single, e 15 para System.Double) resultar em uma perda de precisão, a precisão é aumentada em duas casas decimais. Se um especificador de precisão for fornecido com este especificador de formato, ele será ignorado. Este formato é idêntico ao formato de ponto fixo.

X

x

Formato hexadecimal: (Este formato é válido somente quando especificado com tipos de dados integrais.) Usado para representações de cadeia de caracteres de números na Base 16. A precisão determina o número mínimo de dígitos na cadeia de caracteres. Se a precisão especificar mais dígitos do que o número contém, o número será acolchoado à esquerda com zeros. O caso do especificador de formato ('X' ou 'x') determina se letras maiúsculas ou minúsculas são usadas na representação hexadecimal.

Se o valor numérico for um System.Single ou System.Double com um valor de , NaNou PositiveInfinity, o especificador de NegativeInfinityformato será ignorado e uma das seguintes opções será retornada: System.Globalization.NumberFormatInfo.NaNSymbol, System.Globalization.NumberFormatInfo.PositiveInfinitySymbol, ou System.Globalization.NumberFormatInfo.NegativeInfinitySymbol.

Um formato personalizado é qualquer cadeia de caracteres especificada como um formato que não está na forma de uma cadeia de caracteres de formato padrão (Axx) descrita acima. A tabela a seguir descreve os caracteres usados na construção de formatos personalizados.

Especificador de formato	Description
`0` (zero)	Espaço reservado zero: Se o valor que está sendo formatado tiver um dígito na posição em que um '0' aparece no formato personalizado, esse dígito será copiado para a cadeia de caracteres de saída, caso contrário, um zero será armazenado nessa posição na cadeia de caracteres de saída. A posição do «0» mais à esquerda antes do separador decimal e do «0» mais à direita após o separador decimal determinam o intervalo de algarismos que estão sempre presentes na cadeia de saída. O número de espaços reservados para Zero e/ou Dígito após o separador decimal determina o número de dígitos que aparecem após o separador decimal. Os valores são arredondados conforme necessário.
`#`	Espaço reservado para dígitos: Se o valor que está sendo formatado tiver um dígito na posição em que um '#' aparece no formato personalizado, esse dígito será copiado para a cadeia de caracteres de saída, caso contrário, nada será armazenado nessa posição na cadeia de caracteres de saída. Observe que este especificador nunca armazena o caractere '0' se ele não for um dígito significativo, mesmo que '0' seja o único dígito na cadeia de caracteres. (Ele exibe o caractere '0' na cadeia de saída se for um dígito significativo.) O número de espaços reservados para Zero e/ou Dígito após o separador decimal determina o número de dígitos que aparecem após o separador decimal. Os valores são arredondados conforme necessário.
`.` (período)	Separador decimal: O mais à esquerda '.' caractere na cadeia de caracteres de formato determina a localização do separador decimal no valor formatado; qualquer « adicional «.» os caracteres são ignorados. A `System.Globalization.NumberFormatInfo.NumberDecimalSeparator` propriedade determina o símbolo usado como separador decimal.
`,` (vírgula)	Separador de grupo e dimensionamento de números: O caractere '' serve a dois propósitos. Primeiro, se o formato personalizado contiver esse caractere entre dois espaços reservados Zero ou Dígito (0 ou #) e à esquerda do separador decimal, se houver um, a saída terá separadores de grupo inseridos entre cada grupo de dígitos à esquerda do separador decimal. As `System.Globalization.NumberFormatInfo.NumberGroupSeparator` propriedades e `System.Globalization.NumberFormatInfo.NumberGroupSizes` determinam o símbolo usado como separador de grupo e o número de dígitos em cada grupo, respectivamente. Se a cadeia de caracteres de formato contiver um ou mais caracteres '' imediatamente à esquerda do separador decimal, o número será dimensionado. O fator de escala é determinado pelo número de caracteres separadores de grupo imediatamente à esquerda do separador decimal. Se houver x caracteres, o valor é dividido por 1000^X antes de ser formatado. Por exemplo, a cadeia de caracteres de formato '0,' dividirá um valor por um milhão. Observe que a presença do caractere '' para indicar o dimensionamento não insere separadores de grupo na cadeia de caracteres de saída. Assim, para dimensionar um número em 1 milhão e inserir separadores de grupo, use um formato personalizado semelhante a '#,##0,'.
`%` (percentagem)	Espaço reservado para porcentagem: a presença de um caractere '%' em um formato personalizado faz com que um número seja multiplicado por 100 antes de ser formatado. O símbolo de porcentagem é inserido na cadeia de caracteres de saída no local onde o '%' aparece na cadeia de caracteres de formato. A `System.Globalization.NumberFormatInfo.PercentSymbol` propriedade determina o símbolo de porcentagem.
`E0` `E+0` `E-0` `e0` `e+0` `e-0`	Formato de engenharia: Se qualquer uma das cadeias de caracteres 'E', 'E+', 'E-', 'e', 'e+' ou 'e-' estiver presente em um formato personalizado e for seguida imediatamente por pelo menos um caractere '0', então o valor é formatado usando notação científica. O número de caracteres «0» a seguir ao prefixo do expoente (E ou e) determina o número mínimo de algarismos no expoente. Os formatos «E+» e «e+» indicam que um símbolo numérico positivo ou negativo precede sempre o expoente. Os formatos 'E', 'E-', 'e' ou 'e-' indicam que um símbolo numérico negativo precede expoentes negativos; nenhum símbolo precede expoentes positivos. O símbolo de `System.Globalization.NumberFormatInfo.PositiveSign` número positivo é fornecido pela propriedade. O símbolo de `System.Globalization.NumberFormatInfo.NegativeSign` número negativo é fornecido pela propriedade.
`\` (barra invertida)	Caractere de escape: em alguns idiomas, como C#, o caractere de barra invertida faz com que o próximo caractere no formato personalizado seja interpretado como uma sequência de escape. Ele é usado com sequências de formatação de linguagem C, como '\n' (newline). Em alguns idiomas, o próprio caractere de escape deve ser precedido por um caractere de escape quando usado como literal. Caso contrário, um compilador interpreta o caractere como uma sequência de escape. Este caractere de escape não é necessário para ser suportado em todas as linguagens de programação.
`'ABC'` `"ABC"`	Cadeia de caracteres literal: os caracteres entre aspas simples ou duplas são copiados para a cadeia de caracteres de saída literalmente e não afetam a formatação.
`;` (ponto e vírgula)	Separador de seção: O caractere ';' é usado para separar seções para números positivos, negativos e zero na cadeia de caracteres de formato. (Este recurso é descrito em detalhes abaixo.)
Outro	Todos os outros caracteres: Todos os outros caracteres são armazenados na cadeia de caracteres de saída como literais na posição em que aparecem.

Observe que, para cadeias de caracteres de formato de ponto fixo (cadeias de caracteres que não contêm um 'E0', 'E+0', 'E-0', 'e0', 'e+0' ou 'e-0'), os números são arredondados para tantas casas decimais quantos os espaços reservados para Zero ou Dígito à direita do separador decimal. Se o formato personalizado não contiver um separador decimal, o número será arredondado para o número inteiro mais próximo. Se o número tiver mais dígitos do que os espaços reservados Zero ou Dígito à esquerda do separador decimal, os dígitos extras serão copiados para a cadeia de caracteres de saída imediatamente antes do primeiro espaço reservado Zero ou Dígito.

Um formato personalizado pode conter até três seções separadas por caracteres separadores de seção, para especificar formatação diferente para valores positivos, negativos e zero. As secções são interpretadas do seguinte modo:

Uma seção: O formato personalizado aplica-se a todos os valores (positivo, negativo e zero). Os valores negativos incluem um sinal negativo.
Duas secções: A primeira secção aplica-se a valores positivos e zeros, e a segunda secção aplica-se a valores negativos. Se o valor a ser formatado for negativo, mas se tornar zero após arredondamento de acordo com o formato na segunda seção, o zero resultante será formatado de acordo com a primeira seção. Os valores negativos não incluem um sinal negativo para permitir o controlo total sobre as representações de valores negativos. Por exemplo, um negativo pode ser representado entre parênteses usando um formato personalizado semelhante a '####.####; (####.####)’.
Três secções: A primeira secção aplica-se a valores positivos, a segunda secção aplica-se a valores negativos e a terceira secção aplica-se a zeros. A segunda seção pode estar vazia (nada aparece entre os ponto-e-vírgula), caso em que a primeira seção se aplica a todos os valores diferentes de zero, e os valores negativos incluem um sinal negativo. Se o número a ser formatado for diferente de zero, mas se tornar zero após arredondamento de acordo com o formato na primeira ou segunda seção, o zero resultante será formatado de acordo com a terceira seção.

Os System.Enum tipos e System.DateTime também suportam o uso de especificadores de formato para formatar representações de valores de cadeia de caracteres. O significado de um especificador de formato específico varia de acordo com o tipo de dados (numéricos, data/hora, enumeração) que estão sendo formatados. Consulte System.Enum e System.Globalization.DateTimeFormatInfo para obter uma lista abrangente dos especificadores de formato suportados por cada tipo.

C.5 Abreviaturas de tipo de biblioteca

Os seguintes tipos de biblioteca são referenciados nesta especificação. Os nomes completos desses tipos, incluindo o qualificador de namespace global, estão listados abaixo. Ao longo desta especificação, esses tipos aparecem como o nome totalmente qualificado; com o qualificador de namespace global omitido; ou como um nome de tipo simples não qualificado, com o namespace omitido também. Por exemplo, o tipo ICollection<T>, quando usado nesta especificação, sempre significa o tipo global::System.Collections.Generic.ICollection<T>.

global::System.Action
global::System.ArgumentException
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.IDisposable
global::System.IFormattable
global::System.IndexOutOfRangeException
global::System.Int16
global::System.Int32
global::System.Int64
global::System.IntPtr
global::System.InvalidCastException
global::System.InvalidOperationException
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.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.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.NotNullAttribute
global::System.Diagnostics.CodeAnalysis.NotNullIfNotNullAttribute
global::System.Diagnostics.CodeAnalysis.NotNullWhenAttribute
global::System.Linq.Expressions.Expression<TDelegate>
global::System.Reflection.MemberInfo
global::System.Runtime.CompilerServices.AsyncMethodBuilderAttribute
global::System.Runtime.CompilerServices.CallerFileAttribute
global::System.Runtime.CompilerServices.CallerLineNumberAttribute
global::System.Runtime.CompilerServices.CallerMemberNameAttribute
global::System.Runtime.CompilerServices.FormattableStringFactory
global::System.Runtime.CompilerServices.ICriticalNotifyCompletion
global::System.Runtime.CompilerServices.IndexerNameAttribute
global::System.Runtime.CompilerServices.INotifyCompletion
global::System.Runtime.CompilerServices.TaskAwaiter
global::System.Runtime.CompilerServices.TaskAwaiter<T>
global::System.Runtime.CompilerServices.ValueTaskAwaiter
global::System.Runtime.CompilerServices.ValueTaskAwaiter<TResult>
global::System.Runtime.CompilerServices.Unsafe
global::System.Threading.Monitor
global::System.Threading.Tasks.Task
global::System.Threading.Tasks.Task<TResult>