Libreria Standard allegato C

Articolo
11/21/2024

C.1 Generale

Un'implementazione C# conforme deve fornire un set minimo di tipi con semantica specifica. Questi tipi e i relativi membri sono elencati qui, in ordine alfabetico in base allo spazio dei nomi e al tipo. Per una definizione formale di questi tipi e dei relativi membri, vedere ISO/IEC 23271:2012 Common Language Infrastructure (CLI), Partition IV; Libreria di classi base (BCL), libreria numerica estesa e libreria di matrici estese, incluse per riferimento in questa specifica.

Questo testo è informativo.

La libreria standard deve essere il set minimo di tipi e membri richiesti da un'implementazione C# conforme. Di conseguenza, contiene solo i membri richiesti in modo esplicito dalla specifica del linguaggio C#.

È previsto che un'implementazione C# conforme fornirà una libreria significativamente più estesa che consente la scrittura di programmi utili. Ad esempio, un'implementazione conforme potrebbe estendere questa libreria tramite

Aggiunta di spazi dei nomi.
Aggiunta di tipi.
Aggiunta di membri a tipi non di interfaccia.
Aggiunta di classi o interfacce di base intermedie.
La presenza di struct e tipi di classe implementa interfacce aggiuntive.
Aggiunta di attributi (diversi da ConditionalAttribute) a tipi e membri esistenti.

Fine del testo informativo.

Tipi di libreria standard C.2 definiti in ISO/IEC 23271

Nota: alcuni struct tipi seguenti hanno il readonly modificatore. Questo modificatore non era disponibile quando è stato rilasciato ISO/IEC 23271, ma è necessario per le implementazioni conformi di questa specifica. nota finale

namespace System
{
    public delegate void Action();

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

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

    public abstract class Array : IList, ICollection, IEnumerable
    {
        public int Length { get; }
        public int Rank { get; }
        public int GetLength(int dimension);
    }

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

    [AttributeUsageAttribute(AttributeTargets.All, Inherited = true,
        AllowMultiple = false)]
    public abstract class Attribute
    {
        protected Attribute();
    }

    public enum AttributeTargets
    {
        Assembly = 0x1,
        Module = 0x2,
        Class = 0x4,
        Struct = 0x8,
        Enum = 0x10,
        Constructor = 0x20,
        Method = 0x40,
        Property = 0x80,
        Field = 0x100,
        Event = 0x200,
        Interface = 0x400,
        Parameter = 0x800,
        Delegate = 0x1000,
        ReturnValue = 0x2000,
        GenericParameter = 0x4000,
        All = 0x7FFF
    }

    [AttributeUsageAttribute(AttributeTargets.Class, Inherited = true)]
    public sealed class AttributeUsageAttribute : Attribute
    {
        public AttributeUsageAttribute(AttributeTargets validOn);
        public bool AllowMultiple { get; set; }
        public bool Inherited { get; set; }
        public AttributeTargets ValidOn { get; }
    }

    public readonly struct Boolean { }
    public readonly struct Byte { }
    public readonly struct Char { }
    public readonly struct Decimal { }
    public abstract class Delegate { }

    public class DivideByZeroException : ArithmeticException
    {
        public DivideByZeroException();
        public DivideByZeroException(string message);
        public DivideByZeroException(string message, Exception innerException);
    }

    public readonly struct Double { }

    public abstract class Enum : ValueType
    {
        protected Enum();
    }

    public class Exception
    {
        public Exception();
        public Exception(string message);
        public Exception(string message, Exception innerException);
        public sealed Exception InnerException { get; }
        public virtual string Message { get; }
    }

    public class GC { }

    public interface IDisposable
    {
        void Dispose();
    }

    public interface IFormattable { }

    public sealed class IndexOutOfRangeException : Exception
    {
        public IndexOutOfRangeException();
        public IndexOutOfRangeException(string message);
        public IndexOutOfRangeException(string message,
            Exception innerException);
    }

    public readonly struct Int16 { }
    public readonly struct Int32 { }
    public readonly struct Int64 { }
    public readonly struct IntPtr { }

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

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

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

    public struct Nullable<T>
    {
        public bool HasValue { get; }
        public T Value { get; }
    }

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

    public class Object
    {
        public Object();
        ~Object();
        public virtual bool Equals(object obj);
        public virtual int GetHashCode();
        public Type GetType();
        public virtual string ToString();
    }

    [AttributeUsageAttribute(AttributeTargets.Class | AttributeTargets.Struct |
        AttributeTargets.Enum | AttributeTargets.Interface |
        AttributeTargets.Constructor | AttributeTargets.Method |
        AttributeTargets.Property | AttributeTargets.Field |
        AttributeTargets.Event | AttributeTargets.Delegate, Inherited = false)]
    public sealed class ObsoleteAttribute : Attribute
    {
        public ObsoleteAttribute();
        public ObsoleteAttribute(string message);
        public ObsoleteAttribute(string message, bool error);
        public bool IsError { get; }
        public string Message { get; }
    }

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

    public class OverflowException : ArithmeticException
    {
        public OverflowException();
        public OverflowException(string message);
        public OverflowException(string message, Exception innerException);
    }

    public readonly struct SByte { }
    public readonly struct Single { }

    public sealed class StackOverflowException : Exception
    {
        public StackOverflowException();
        public StackOverflowException(string message);
        public StackOverflowException(string message, Exception innerException);
    }

    public sealed class String : IEnumerable<Char>, IEnumerable
    {
        public int Length { get; }
        public char this [int index] { get; }
        public static string Format(string format, params object[] args);
    }

    public abstract class Type : MemberInfo { }

    public sealed class TypeInitializationException : Exception
    {
        public TypeInitializationException(string fullTypeName,
            Exception innerException);
    }

    public readonly struct UInt16 { }
    public readonly struct UInt32 { }
    public readonly struct UInt64 { }
    public readonly struct UIntPtr { }

    public abstract class ValueType
    {
        protected ValueType();
    }
}

namespace System.Collections
{
    public interface ICollection : IEnumerable
    {
        int Count { get; }
        bool IsSynchronized { get; }
        object SyncRoot { get; }
        void CopyTo(Array array, int index);
    }

    public interface IEnumerable
    {
        IEnumerator GetEnumerator();
    }

    public interface IEnumerator
    {
        object Current { get; }
        bool MoveNext();
        void Reset();
    }

    public interface IList : ICollection, IEnumerable
    {
        bool IsFixedSize { get; }
        bool IsReadOnly { get; }
        object this [int index] { get; set; }
        int Add(object value);
        void Clear();
        bool Contains(object value);
        int IndexOf(object value);
        void Insert(int index, object value);
        void Remove(object value);
        void RemoveAt(int index);
    }
}

namespace System.Collections.Generic
{
    public interface ICollection<T> : IEnumerable<T>
    {
        int Count { get; }
        bool IsReadOnly { get; }
        void Add(T item);
        void Clear();
        bool Contains(T item);
        void CopyTo(T[] array, int arrayIndex);
        bool Remove(T item);
    }

    public interface IEnumerable<T> : IEnumerable
    {
        IEnumerator<T> GetEnumerator();
    }

    public interface IEnumerator<T> : IDisposable, IEnumerator
    {
        T Current { get; }
    }

    public interface IList<T> : ICollection<T>
    {
        T this [int index] { get; set; }
        int IndexOf(T item);
        void Insert(int index, T item);
        void RemoveAt(int index);
    }
}

namespace System.Diagnostics
{
    [AttributeUsageAttribute(AttributeTargets.Method | AttributeTargets.Class,
                             AllowMultiple = true)]
    public sealed class ConditionalAttribute : Attribute
    {
        public ConditionalAttribute(string conditionString);
        public string ConditionString { get; }
    }
}

namespace System.Reflection
{
    public abstract class MemberInfo
    {
        protected MemberInfo();
    }
}

namespace System.Runtime.CompilerServices
{
    public sealed class IndexerNameAttribute : Attribute
    {
        public IndexerNameAttribute(String indexerName);
    }

    public static class Unsafe
    {
        public static ref T NullRef<T>();
    }
}

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

C.3 Tipi di libreria standard non definiti in ISO/IEC 23271

I tipi seguenti, inclusi i membri elencati, devono essere definiti in una libreria standard conforme. Questi tipi potrebbero essere definiti in una futura edizione di ISO/IEC 23271. È previsto che molti di questi tipi abbiano più membri disponibili rispetto a quelli elencati.

Un'implementazione conforme può fornire Task.GetAwaiter() e Task<TResult>.GetAwaiter() come metodi di estensione.

namespace System
{
    public class FormattableString : IFormattable { }

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

    public readonly ref struct ReadOnlySpan<T>
    {
        public int Length { get; }
        public ref readonly T this[int index] { get; }
    }

    public readonly ref struct Span<T>
    {
        public int Length { get; }
        public ref T this[int index] { get; }
        public static implicit operator ReadOnlySpan<T>(Span<T> span);
    }

    public struct ValueTuple<T1>
    {
        public T1 Item1;
        public ValueTuple(T1 item1);
    }

    public struct ValueTuple<T1, T2>
    {
        public T1 Item1;
        public T2 Item2;
        public ValueTuple(T1 item1, T2 item2);
    }

    public struct ValueTuple<T1, T2, T3>
    {
        public T1 Item1;
        public T2 Item2;
        public T3 Item3;
        public ValueTuple(T1 item1, T2 item2, T3 item3);
    }

    public struct ValueTuple<T1, T2, T3, T4>
    {
        public T1 Item1;
        public T2 Item2;
        public T3 Item3;
        public T4 Item4;
        public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4);
    }

    public struct ValueTuple<T1, T2, T3, T4, T5>
    {
        public T1 Item1;
        public T2 Item2;
        public T3 Item3;
        public T4 Item4;
        public T5 Item5;
        public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5);
    }

    public struct ValueTuple<T1, T2, T3, T4, T5, T6>
    {
        public T1 Item1;
        public T2 Item2;
        public T3 Item3;
        public T4 Item4;
        public T5 Item5;
        public T6 Item6;
        public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5,
            T6 item6);
    }

    public struct ValueTuple<T1, T2, T3, T4, T5, T6, T7>
    {
        public T1 Item1;
        public T2 Item2;
        public T3 Item3;
        public T4 Item4;
        public T5 Item5;
        public T6 Item6;
        public T7 Item7;
        public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5,
            T6 item6, T7 item7);
    }

    public struct ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest>
    {
        public T1 Item1;
        public T2 Item2;
        public T3 Item3;
        public T4 Item4;
        public T5 Item5;
        public T6 Item6;
        public T7 Item7;
        public TRest Rest;
        public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5,
            T6 item6, T7 item7, TRest rest);
    }
}

namespace System.Collections.Generic
{
    public interface IReadOnlyCollection<out T> : IEnumerable<T>
    {
        int Count { get; }
    }

    public interface IReadOnlyList<out T> : IReadOnlyCollection<T>
    {
        T this [int index] { get; }
    }
}

namespace System.Linq.Expressions
{
    public sealed class Expression<TDelegate>
    {
        public TDelegate Compile();
    }
}

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

    [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
    public sealed class CallerFilePathAttribute : Attribute
    {
        public CallerFilePathAttribute() { }
    }

    [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
    public sealed class CallerLineNumberAttribute : Attribute
    {
        public CallerLineNumberAttribute() { }
    }

    [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
    public sealed class CallerMemberNameAttribute : Attribute
    {
        public CallerMemberNameAttribute() { }
    }

    public static class FormattableStringFactory
    {
        public static FormattableString Create(string format,
            params object[] arguments);
    }

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

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

    public readonly struct TaskAwaiter : ICriticalNotifyCompletion,
        INotifyCompletion
    {
        public bool IsCompleted { get; }
        public void GetResult();
    }

    public readonly struct TaskAwaiter<TResult> : ICriticalNotifyCompletion,
        INotifyCompletion
    {
        public bool IsCompleted { get; }
        public TResult GetResult();
    }

    public readonly struct ValueTaskAwaiter : ICriticalNotifyCompletion,
        INotifyCompletion
    {
        public bool IsCompleted { get; }
        public void GetResult();
    }

    public readonly struct ValueTaskAwaiter<TResult>
        : ICriticalNotifyCompletion, INotifyCompletion
    {
        public bool IsCompleted { get; }
        public TResult GetResult();
    }

    [System.AttributeUsage(System.AttributeTargets.Field |
      System.AttributeTargets.Parameter | System.AttributeTargets.Property,
      Inherited=false)]
    public sealed class AllowNullAttribute : Attribute
    {
        public AllowNullAttribute() { }
    }

    [System.AttributeUsage(System.AttributeTargets.Field |
      System.AttributeTargets.Parameter | System.AttributeTargets.Property,
      Inherited=false)]
    public sealed class DisallowNullAttribute : Attribute
    {
        public DisallowNullAttribute() {}
    }

    [System.AttributeUsage(System.AttributeTargets.Method, Inherited=false)]
    public sealed class DoesNotReturnAttribute : Attribute
    {
        public DoesNotReturnAttribute() {}
    }

    [System.AttributeUsage(System.AttributeTargets.Parameter, Inherited=false)]
    public sealed class DoesNotReturnIfAttribute : Attribute
    {
        public DoesNotReturnIfAttribute(bool parameterValue) {}
    }

    [System.AttributeUsage(System.AttributeTargets.Field | 
      System.AttributeTargets.Parameter | System.AttributeTargets.Property | 
      System.AttributeTargets.ReturnValue, Inherited=false)]
    public sealed class MaybeNullAttribute : Attribute
    {
        public MaybeNullAttribute() {}
    }

    [System.AttributeUsage(System.AttributeTargets.Parameter, Inherited=false)]
    public sealed class MaybeNullWhenAttribute : Attribute
    {
        public MaybeNullWhenAttribute(bool returnValue) {}
    }

    [System.AttributeUsage(System.AttributeTargets.Field |
      System.AttributeTargets.Parameter | System.AttributeTargets.Property | 
      System.AttributeTargets.ReturnValue, Inherited=false)]
    public sealed class NotNullAttribute : Attribute
    {
        public NotNullAttribute() {}
    }

    [System.AttributeUsage(System.AttributeTargets.Parameter | 
      System.AttributeTargets.Property | System.AttributeTargets.ReturnValue, 
      AllowMultiple=true, Inherited=false)]
    public sealed class NotNullIfNotNullAttribute : Attribute
    {
        public NotNullIfNotNullAttribute(string parameterName) {}
    }

    [System.AttributeUsage(System.AttributeTargets.Parameter, Inherited=false)]
    public sealed class NotNullWhenAttribute : Attribute
    {
        public NotNullWhenAttribute(bool returnValue) {}
    }
}

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

    public class Task<TResult> : Task
    {
        public new System.Runtime.CompilerServices.TaskAwaiter<T> GetAwaiter();
    }

    public readonly struct ValueTask : System.IEquatable<ValueTask>
    {
        public System.Runtime.CompilerServices.ValueTaskAwaiter GetAwaiter();
    }

    public readonly struct ValueTask<TResult>
        : System.IEquatable<ValueTask<TResult>>
    {
        public new System.Runtime.CompilerServices.ValueTaskAwaiter<TResult>
            GetAwaiter();
    }
}

Specifiche di formato C.4

Il significato dei formati, come usato nelle espressioni di stringa interpolate (§12.8.3), è definito in ISO/IEC 23271:2012. Per praticità, il testo seguente viene copiato dalla descrizione di System.IFormattable.

Questo testo è informativo.

Un formato è una stringa che descrive l'aspetto di un oggetto quando viene convertito in una stringa. È possibile usare formati standard o personalizzati. Un formato standard assume il formato Axx, dove A è un singolo carattere alfabetico denominato identificatore di formato e xx è un numero intero compreso tra zero e 99 inclusi, denominato identificatore di precisione. L'identificatore di formato controlla il tipo di formattazione applicato al valore rappresentato come stringa. L'identificatore di precisione controlla il numero di cifre significative o posizioni decimali nella stringa, se applicabile.

Nota: per l'elenco degli identificatori di formato standard, vedere la tabella seguente. Si noti che un determinato tipo di dati, ad esempio System.Int32, potrebbe non supportare uno o più identificatori di formato standard. nota finale

Nota: quando un formato include simboli che variano in base alle impostazioni cultura, ad esempio la valutasymbol inclusa nei formati 'C' e 'c', un oggetto di formattazione fornisce i caratteri effettivi utilizzati nella rappresentazione di stringa. Un metodo può includere un parametro per passare un System.IFormatProvider oggetto che fornisce un oggetto di formattazione oppure il metodo potrebbe utilizzare l'oggetto di formattazione predefinito, che contiene le definizioni dei simboli per le impostazioni cultura correnti. Le impostazioni cultura correnti usano in genere lo stesso set di simboli utilizzati a livello di sistema per impostazione predefinita. Nella libreria di classi di base l'oggetto di formattazione per i tipi numerici forniti dal sistema è un'istanza System.Globalization.NumberFormatInfo di . Per System.DateTime le istanze viene usato un System.Globalization.DateTimeFormatInfo oggetto . nota finale

Nella tabella seguente vengono descritti gli identificatori di formato standard e i membri dell'oggetto di formattazione associati usati con i tipi di dati numerici nella libreria di classi di base.

Identificatore di formato Descrizione

Identificatore di formato	Descrizione
`C` `c`	Formato valuta: usato per le stringhe contenenti un valore monetario. I `System.Globalization.NumberFormatInfo.CurrencySymbol`membri , `System.Globalization.NumberFormatInfo.CurrencyGroupSizes`, `System.Globalization.NumberFormatInfo.CurrencyGroupSeparator`e `System.Globalization.NumberFormatInfo.CurrencyDecimalSeparator` di un `System.Globalization.NumberFormatInfo` oggetto forniscono rispettivamente il simbolo di valuta, le dimensioni e il separatore separatore per i raggruppamenti di cifre e il separatore decimale. `System.Globalization.NumberFormatInfo.CurrencyNegativePattern` e `System.Globalization.NumberFormatInfo.CurrencyPositivePattern` determinare i simboli usati per rappresentare valori negativi e positivi. Ad esempio, un valore negativo può essere preceduto da un segno meno o racchiuso tra parentesi. Se l'identificatore di precisione viene omesso, `System.Globalization.NumberFormatInfo.CurrencyDecimalDigits` determina il numero di posizioni decimali nella stringa. Quando necessario, i risultati vengono arrotondati al valore rappresentabile più vicino.
`D` `d`	Formato decimale: questo formato è valido solo se specificato con tipi di dati integrali. Utilizzata per le stringhe contenenti valori integer. I numeri negativi sono preceduti dal simbolo di numero negativo specificato dalla `System.Globalization.NumberFormatInfo.NegativeSign` proprietà . L'identificatore di precisione determina il numero minimo di cifre visualizzate nella stringa. Se la precisione specificata richiede più cifre rispetto al valore contenuto, la stringa viene riempita a sinistra con zeri. Se l'identificatore di precisione specifica un numero inferiore di cifre rispetto al valore , l'identificatore di precisione viene ignorato.
`E` `e`	Formato scientifico (ingegneria): utilizzato per le stringhe in una delle forme seguenti: ^m.ddddddE+xxx ^m.ddddddE-xxx ^m.dddddde+xxx ^m.dddddde-xxx Il simbolo di numero negativo ('-') viene visualizzato solo se il valore è negativo e viene fornito dalla `System.Globalization.NumberFormatInfo.NegativeSign` proprietà . Esattamente una cifra decimale diversa da zero (m) precede il separatore decimale ('.'), fornito dalla `System.Globalization.NumberFormatInfo.NumberDecimalSeparator` proprietà . L'identificatore di precisione determina il numero di posizioni decimali (ddddddd) nella stringa. Se l'identificatore di precisione viene omesso, nella stringa vengono incluse sei posizioni decimali. L'esponente (+/-xxx) è costituito da un simbolo di numero positivo o negativo seguito da almeno tre cifre (xxx). L'esponente viene riempito a sinistra con zeri, se necessario. Il caso dell'identificatore di formato ('E' o 'e') determina il caso usato per il prefisso esponente (E o e) nella stringa. Quando necessario, i risultati vengono arrotondati al valore rappresentabile più vicino. Il simbolo di numero positivo viene fornito dalla `System.Globalization.NumberFormatInfo.PositiveSign` proprietà .
`F` `f`	Formato a virgola fissa: usato per le stringhe nel formato seguente: ^m.dd... d Almeno una cifra decimale diversa da zero (m) precede il separatore decimale ('.'), fornito dalla `System.Globalization.NumberFormatInfo.NumberDecimalSeparator` proprietà . Un segno di simbolo di numero negativo ('-') precede m solo se il valore è negativo. Questo simbolo viene fornito dalla `System.Globalization.NumberFormatInfo.NegativeSign` proprietà . L'identificatore di precisione determina il numero di posizioni decimali (dd... d) nella stringa. Se l'identificatore di precisione viene omesso, `System.Globalization.NumberFormatInfo.NumberDecimalDigits` determina il numero di posizioni decimali nella stringa. Quando necessario, i risultati vengono arrotondati al valore rappresentabile più vicino.
`G` `g`	Formato generale: la stringa è formattata in formato a virgola fissa ('F' o 'f') o in formato scientifico ('E' o 'e'). Per i tipi integrali: I valori vengono formattati usando il formato a virgola fissa se l'identificatore di precisione dell'esponente< , dove esponente è l'esponente del valore in formato scientifico. Per tutti gli altri valori, viene usato il formato scientifico. Se l'identificatore di precisione viene omesso, viene utilizzata una precisione predefinita uguale alla larghezza del campo necessaria per visualizzare il valore massimo per il tipo di dati, che determina la formattazione del valore in formato a virgola fissa. Di seguito sono riportate le precisioni predefinite per i tipi integrali: `System.Int16`, `System.UInt16` : 5 `System.Int32`, : `System.UInt32` 10 `System.Int64`, `System.UInt64` : 19 Per i tipi Single, Decimal e Double: I valori vengono formattati usando il formato a virgola fissa se esponente ≥ -4 e identificatore di precisione dell'esponente<, dove esponente è l'esponente del valore in formato scientifico. Per tutti gli altri valori, viene usato il formato scientifico. Quando necessario, i risultati vengono arrotondati al valore rappresentabile più vicino. Se l'identificatore di precisione viene omesso, vengono utilizzate le precisioni predefinite seguenti: `System.Single` : 7 `System.Double` : 15 `System.Decimal` : 29 Per tutti i tipi: Il numero di cifre visualizzate nel risultato (non incluso l'esponente) non supererà il valore dell'identificatore di precisione; i valori vengono arrotondati in base alle esigenze. Il separatore decimale e gli eventuali zeri finali dopo la rimozione del separatore decimale quando possibile. Il caso dell'identificatore di formato ('G' o 'g') determina se 'E' o 'e' prefissi l'esponente del formato scientifico.
`N` `n`	Formato numero: utilizzato per le stringhe nel formato seguente: ^d,ddd,ddd.dd... d La rappresentazione dei valori negativi è determinata dalla `System.Globalization.NumberFormatInfo.NumberNegativePattern` proprietà . Se il criterio include un simbolo di numero negativo ('-'), questo simbolo viene fornito dalla `System.Globalization.NumberFormatInfo.NegativeSign` proprietà . Almeno una cifra decimale diversa da zero (d) precede il separatore decimale ('.'), fornito dalla `System.Globalization.NumberFormatInfo.NumberDecimalSeparator` proprietà . Le cifre tra il separatore decimale e la cifra più significativa del valore vengono raggruppate usando le dimensioni del gruppo specificate dalla `System.Globalization.NumberFormatInfo.NumberGroupSizes` proprietà . Il separatore di gruppo (',') viene inserito tra ogni gruppo di cifre e viene fornito dalla `System.Globalization.NumberFormatInfo.NumberGroupSeparator` proprietà . L'identificatore di precisione determina il numero di posizioni decimali (dd... d). Se l'identificatore di precisione viene omesso, `System.Globalization.NumberFormatInfo.NumberDecimalDigits` determina il numero di posizioni decimali nella stringa. Quando necessario, i risultati vengono arrotondati al valore rappresentabile più vicino.
`P` `p`	Formato percentuale: usato per le stringhe contenenti una percentuale. I `System.Globalization.NumberFormatInfo.PercentSymbol`membri , `System.Globalization.NumberFormatInfo.PercentGroupSizes`, `System.Globalization.NumberFormatInfo.PercentGroupSeparator`e `System.Globalization.NumberFormatInfo.PercentDecimalSeparator` di un `System.Globalization.NumberFormatInfo` oggetto forniscono rispettivamente il simbolo percentuale, le dimensioni e il separatore separatore per i raggruppamenti di cifre e il separatore decimale. `System.Globalization.NumberFormatInfo.PercentNegativePattern` e `System.Globalization.NumberFormatInfo.PercentPositivePattern` determinare i simboli usati per rappresentare valori negativi e positivi. Ad esempio, un valore negativo può essere preceduto da un segno meno o racchiuso tra parentesi. Se non viene specificata alcuna precisione, il numero di posizioni decimali nel risultato viene determinato da `System.Globalization.NumberFormatInfo.PercentDecimalDigits`. Quando necessario, i risultati vengono arrotondati al valore rappresentabile più vicino. Il risultato è ridimensionato di 100 (il 99 diventa 99%).
`R` `r`	Formato round trip: ( questo formato è valido solo se specificato con `System.Double` o `System.Single`. ) Usato per garantire che la precisione della rappresentazione di stringa di un valore a virgola mobile sia tale che l'analisi della stringa non comporti una perdita di precisione rispetto al valore originale. Se la precisione massima del tipo di dati (7 per `System.Single`e 15 per `System.Double`) comporta una perdita di precisione, la precisione viene aumentata di due posizioni decimali. Se un identificatore di precisione viene fornito con questo identificatore di formato, viene ignorato. Questo formato è altrimenti identico al formato a virgola fissa.
`X` `x`	Formato esadecimale: questo formato è valido solo se specificato con tipi di dati integrali. Usato per le rappresentazioni di stringa di numeri in Base 16. La precisione determina il numero minimo di cifre nella stringa. Se la precisione specifica più cifre del numero contenuto, il numero viene riempito a sinistra con zeri. Il caso dell'identificatore di formato ('X' o 'x') determina se le lettere maiuscole o minuscole vengono utilizzate nella rappresentazione esadecimale.

C

c

Formato valuta: usato per le stringhe contenenti un valore monetario. I System.Globalization.NumberFormatInfo.CurrencySymbolmembri , System.Globalization.NumberFormatInfo.CurrencyGroupSizes, System.Globalization.NumberFormatInfo.CurrencyGroupSeparatore System.Globalization.NumberFormatInfo.CurrencyDecimalSeparator di un System.Globalization.NumberFormatInfo oggetto forniscono rispettivamente il simbolo di valuta, le dimensioni e il separatore separatore per i raggruppamenti di cifre e il separatore decimale.

System.Globalization.NumberFormatInfo.CurrencyNegativePattern e System.Globalization.NumberFormatInfo.CurrencyPositivePattern determinare i simboli usati per rappresentare valori negativi e positivi. Ad esempio, un valore negativo può essere preceduto da un segno meno o racchiuso tra parentesi.

Se l'identificatore di precisione viene omesso, System.Globalization.NumberFormatInfo.CurrencyDecimalDigits determina il numero di posizioni decimali nella stringa. Quando necessario, i risultati vengono arrotondati al valore rappresentabile più vicino.

D

d

Formato decimale: questo formato è valido solo se specificato con tipi di dati integrali. Utilizzata per le stringhe contenenti valori integer. I numeri negativi sono preceduti dal simbolo di numero negativo specificato dalla System.Globalization.NumberFormatInfo.NegativeSign proprietà .

L'identificatore di precisione determina il numero minimo di cifre visualizzate nella stringa. Se la precisione specificata richiede più cifre rispetto al valore contenuto, la stringa viene riempita a sinistra con zeri. Se l'identificatore di precisione specifica un numero inferiore di cifre rispetto al valore , l'identificatore di precisione viene ignorato.

E

e

Formato scientifico (ingegneria): utilizzato per le stringhe in una delle forme seguenti:

^m.ddddddE+xxx

^m.ddddddE-xxx

^m.dddddde+xxx

^m.dddddde-xxx

Il simbolo di numero negativo ('-') viene visualizzato solo se il valore è negativo e viene fornito dalla System.Globalization.NumberFormatInfo.NegativeSign proprietà .

Esattamente una cifra decimale diversa da zero (m) precede il separatore decimale ('.'), fornito dalla System.Globalization.NumberFormatInfo.NumberDecimalSeparator proprietà .

L'identificatore di precisione determina il numero di posizioni decimali (ddddddd) nella stringa. Se l'identificatore di precisione viene omesso, nella stringa vengono incluse sei posizioni decimali.

L'esponente (+/-xxx) è costituito da un simbolo di numero positivo o negativo seguito da almeno tre cifre (xxx). L'esponente viene riempito a sinistra con zeri, se necessario. Il caso dell'identificatore di formato ('E' o 'e') determina il caso usato per il prefisso esponente (E o e) nella stringa. Quando necessario, i risultati vengono arrotondati al valore rappresentabile più vicino. Il simbolo di numero positivo viene fornito dalla System.Globalization.NumberFormatInfo.PositiveSign proprietà .

F

f

Formato a virgola fissa: usato per le stringhe nel formato seguente:

^m.dd... d

Almeno una cifra decimale diversa da zero (m) precede il separatore decimale ('.'), fornito dalla System.Globalization.NumberFormatInfo.NumberDecimalSeparator proprietà .

Un segno di simbolo di numero negativo ('-') precede m solo se il valore è negativo. Questo simbolo viene fornito dalla System.Globalization.NumberFormatInfo.NegativeSign proprietà .

L'identificatore di precisione determina il numero di posizioni decimali (dd... d) nella stringa. Se l'identificatore di precisione viene omesso, System.Globalization.NumberFormatInfo.NumberDecimalDigits determina il numero di posizioni decimali nella stringa. Quando necessario, i risultati vengono arrotondati al valore rappresentabile più vicino.

G

g

Formato generale: la stringa è formattata in formato a virgola fissa ('F' o 'f') o in formato scientifico ('E' o 'e').

Per i tipi integrali:

I valori vengono formattati usando il formato a virgola fissa se l'identificatore di precisione dell'esponente< , dove esponente è l'esponente del valore in formato scientifico. Per tutti gli altri valori, viene usato il formato scientifico.

Se l'identificatore di precisione viene omesso, viene utilizzata una precisione predefinita uguale alla larghezza del campo necessaria per visualizzare il valore massimo per il tipo di dati, che determina la formattazione del valore in formato a virgola fissa. Di seguito sono riportate le precisioni predefinite per i tipi integrali:

System.Int16, System.UInt16 : 5

System.Int32, : System.UInt32 10

System.Int64, System.UInt64 : 19

Per i tipi Single, Decimal e Double:

I valori vengono formattati usando il formato a virgola fissa se esponente ≥ -4 e identificatore di precisione dell'esponente<, dove esponente è l'esponente del valore in formato scientifico. Per tutti gli altri valori, viene usato il formato scientifico. Quando necessario, i risultati vengono arrotondati al valore rappresentabile più vicino.

Se l'identificatore di precisione viene omesso, vengono utilizzate le precisioni predefinite seguenti:

System.Single : 7

System.Double : 15

System.Decimal : 29

Per tutti i tipi:

Il numero di cifre visualizzate nel risultato (non incluso l'esponente) non supererà il valore dell'identificatore di precisione; i valori vengono arrotondati in base alle esigenze.
Il separatore decimale e gli eventuali zeri finali dopo la rimozione del separatore decimale quando possibile.
Il caso dell'identificatore di formato ('G' o 'g') determina se 'E' o 'e' prefissi l'esponente del formato scientifico.

N

n

Formato numero: utilizzato per le stringhe nel formato seguente:

^d,ddd,ddd.dd... d

La rappresentazione dei valori negativi è determinata dalla System.Globalization.NumberFormatInfo.NumberNegativePattern proprietà . Se il criterio include un simbolo di numero negativo ('-'), questo simbolo viene fornito dalla System.Globalization.NumberFormatInfo.NegativeSign proprietà .

Almeno una cifra decimale diversa da zero (d) precede il separatore decimale ('.'), fornito dalla System.Globalization.NumberFormatInfo.NumberDecimalSeparator proprietà . Le cifre tra il separatore decimale e la cifra più significativa del valore vengono raggruppate usando le dimensioni del gruppo specificate dalla System.Globalization.NumberFormatInfo.NumberGroupSizes proprietà . Il separatore di gruppo (',') viene inserito tra ogni gruppo di cifre e viene fornito dalla System.Globalization.NumberFormatInfo.NumberGroupSeparator proprietà .

L'identificatore di precisione determina il numero di posizioni decimali (dd... d). Se l'identificatore di precisione viene omesso, System.Globalization.NumberFormatInfo.NumberDecimalDigits determina il numero di posizioni decimali nella stringa. Quando necessario, i risultati vengono arrotondati al valore rappresentabile più vicino.

P

p

Formato percentuale: usato per le stringhe contenenti una percentuale. I System.Globalization.NumberFormatInfo.PercentSymbolmembri , System.Globalization.NumberFormatInfo.PercentGroupSizes, System.Globalization.NumberFormatInfo.PercentGroupSeparatore System.Globalization.NumberFormatInfo.PercentDecimalSeparator di un System.Globalization.NumberFormatInfo oggetto forniscono rispettivamente il simbolo percentuale, le dimensioni e il separatore separatore per i raggruppamenti di cifre e il separatore decimale.

System.Globalization.NumberFormatInfo.PercentNegativePattern e System.Globalization.NumberFormatInfo.PercentPositivePattern determinare i simboli usati per rappresentare valori negativi e positivi. Ad esempio, un valore negativo può essere preceduto da un segno meno o racchiuso tra parentesi.

Se non viene specificata alcuna precisione, il numero di posizioni decimali nel risultato viene determinato da System.Globalization.NumberFormatInfo.PercentDecimalDigits. Quando necessario, i risultati vengono arrotondati al valore rappresentabile più vicino.

Il risultato è ridimensionato di 100 (il 99 diventa 99%).

R

r

Formato round trip: ( questo formato è valido solo se specificato con System.Double o System.Single. ) Usato per garantire che la precisione della rappresentazione di stringa di un valore a virgola mobile sia tale che l'analisi della stringa non comporti una perdita di precisione rispetto al valore originale. Se la precisione massima del tipo di dati (7 per System.Singlee 15 per System.Double) comporta una perdita di precisione, la precisione viene aumentata di due posizioni decimali. Se un identificatore di precisione viene fornito con questo identificatore di formato, viene ignorato. Questo formato è altrimenti identico al formato a virgola fissa.

X

x

Formato esadecimale: questo formato è valido solo se specificato con tipi di dati integrali. Usato per le rappresentazioni di stringa di numeri in Base 16. La precisione determina il numero minimo di cifre nella stringa. Se la precisione specifica più cifre del numero contenuto, il numero viene riempito a sinistra con zeri. Il caso dell'identificatore di formato ('X' o 'x') determina se le lettere maiuscole o minuscole vengono utilizzate nella rappresentazione esadecimale.

Se il valore numerico è o System.Single con un valore , NaNPositiveInfinityo NegativeInfinity, l'identificatore di formato viene ignorato e viene restituito uno dei valori seguenti: System.Globalization.NumberFormatInfo.NaNSymbol, System.Globalization.NumberFormatInfo.PositiveInfinitySymbolo System.Globalization.NumberFormatInfo.NegativeInfinitySymbol.System.Double

Un formato personalizzato è qualsiasi stringa specificata come formato non sotto forma di stringa di formato standard (Axx) descritta in precedenza. Nella tabella seguente vengono descritti i caratteri utilizzati per la costruzione di formati personalizzati.

Identificatore di formato	Descrizione
`0` (zero)	Segnaposto zero: se il valore formattato ha una cifra nella posizione in cui viene visualizzato un '0' nel formato personalizzato, tale cifra viene copiata nella stringa di output; in caso contrario, nella stringa di output viene archiviato uno zero. La posizione del separatore più a sinistra '0' prima del separatore decimale e del separatore più a destra '0' dopo il separatore decimale determina l'intervallo di cifre che sono sempre presenti nella stringa di output. Il numero di segnaposto Zero e/o Digit dopo il separatore decimale determina il numero di cifre visualizzate dopo il separatore decimale. I valori vengono arrotondati in base alle esigenze.
`#`	Segnaposto cifre: se il valore formattato ha una cifra nella posizione in cui viene visualizzato un '#' nel formato personalizzato, tale cifra viene copiata nella stringa di output; in caso contrario, non viene archiviato nulla in tale posizione nella stringa di output. Si noti che questo identificatore non archivia mai il carattere '0' se non è una cifra significativa, anche se '0' è l'unica cifra nella stringa. Visualizza il carattere '0' nella stringa di output se è una cifra significativa. Il numero di segnaposto Zero e/o Digit dopo il separatore decimale determina il numero di cifre visualizzate dopo il separatore decimale. I valori vengono arrotondati in base alle esigenze.
`.` (periodo)	Separatore decimale: il più a sinistra '.' carattere nella stringa di formato determina la posizione del separatore decimale nel valore formattato; qualsiasi '.' aggiuntivo. i caratteri vengono ignorati. La `System.Globalization.NumberFormatInfo.NumberDecimalSeparator` proprietà determina il simbolo utilizzato come separatore decimale.
`,` (virgola)	Separatore di gruppo e ridimensionamento dei numeri: il carattere ',' serve due scopi. Innanzitutto, se il formato personalizzato contiene questo carattere tra due segnaposto Zero o Digit (0 o #) e a sinistra del separatore decimale, se presente, l'output avrà separatori di gruppo inseriti tra ogni gruppo di cifre a sinistra del separatore decimale. Le `System.Globalization.NumberFormatInfo.NumberGroupSeparator` proprietà e `System.Globalization.NumberFormatInfo.NumberGroupSizes` determinano il simbolo utilizzato rispettivamente come separatore di gruppo e il numero di cifre in ogni gruppo. Se la stringa di formato contiene uno o più caratteri ',' immediatamente a sinistra del separatore decimale, il numero verrà ridimensionato. Il fattore di scala è determinato dal numero di caratteri separatori di gruppo immediatamente a sinistra del separatore decimale. Se sono presenti caratteri x, il valore viene diviso per 1000^X prima che venga formattato. Ad esempio, la stringa di formato '0,' dividerà un valore per un milione. Si noti che la presenza del carattere ',' per indicare che il ridimensionamento non inserisce i separatori di gruppo nella stringa di output. Pertanto, per ridimensionare un numero di 1 milione e inserire separatori di gruppo, usare un formato personalizzato simile a '#,##0,'.
`%` (percentuale)	Segnaposto percentuale: la presenza di un carattere '%' in un formato personalizzato fa sì che un numero venga moltiplicato per 100 prima che venga formattato. Il simbolo percentuale viene inserito nella stringa di output nella posizione in cui viene visualizzato '%' nella stringa di formato. La `System.Globalization.NumberFormatInfo.PercentSymbol` proprietà determina il simbolo di percentuale.
`E0` `E+0` `E-0` `e0` `e+0` `e-0`	Formato di progettazione: se una delle stringhe 'E', 'E+', 'E-', 'e', 'e+' o 'e-' è presente in un formato personalizzato e viene seguita immediatamente da almeno un carattere '0', il valore viene formattato utilizzando la notazione scientifica. Il numero di caratteri '0' che seguono il prefisso dell'esponente (E o e) determina il numero minimo di cifre nell'esponente. I formati 'E+' e 'e+' indicano che un simbolo di numero positivo o negativo precede sempre l'esponente. I formati 'E', 'E-', 'e' o 'e-' indicano che un simbolo di numero negativo precede esponenti negativi; nessun simbolo precede esponenti positivi. Il simbolo di numero positivo viene fornito dalla `System.Globalization.NumberFormatInfo.PositiveSign` proprietà . Il simbolo di numero negativo viene fornito dalla `System.Globalization.NumberFormatInfo.NegativeSign` proprietà .
`\` (barra rovesciata)	Carattere di escape: in alcuni linguaggi, ad esempio C#, il carattere barra rovesciata fa in modo che il carattere successivo nel formato personalizzato venga interpretato come sequenza di escape. Viene usato con le sequenze di formattazione del linguaggio C, ad esempio '\n' (nuova riga). In alcune lingue, il carattere di escape stesso deve essere preceduto da un carattere di escape quando viene usato come valore letterale. In caso contrario, il compilatore interpreta il carattere come sequenza di escape. Questo carattere di escape non deve essere supportato in tutti i linguaggi di programmazione.
`'ABC'` `"ABC"`	Stringa letterale: i caratteri racchiusi tra virgolette singole o doppie vengono copiati nella stringa di output letteralmente e non influiscono sulla formattazione.
`;` (punto e virgola)	Separatore di sezione: il carattere ';' viene usato per separare le sezioni per numeri positivi, negativi e zero nella stringa di formato. Questa funzionalità è descritta in dettaglio di seguito.
Altro	Tutti gli altri caratteri: tutti gli altri caratteri vengono archiviati nella stringa di output come valori letterali nella posizione in cui vengono visualizzati.

Si noti che per le stringhe di formato a virgola fissa (stringhe che non contengono 'E0', 'E+0', 'E-0', 'e+0' o 'e-0'), i numeri vengono arrotondati a tutte le posizioni decimali in cui sono presenti segnaposto Zero o Digit a destra del separatore decimale. Se il formato personalizzato non contiene un separatore decimale, il numero viene arrotondato all'intero più vicino. Se il numero dispone di più cifre rispetto ai segnaposto Zero o Digit a sinistra del separatore decimale, le cifre aggiuntive vengono copiate nella stringa di output immediatamente prima del primo segnaposto Zero o Digit.

Un formato personalizzato può contenere fino a tre sezioni separate da caratteri separatori di sezione, per specificare una formattazione diversa per valori positivi, negativi e zero. Le sezioni vengono interpretate come segue:

Una sezione: il formato personalizzato si applica a tutti i valori (positivi, negativi e zero). I valori negativi includono un segno negativo.
Due sezioni: la prima sezione si applica a valori positivi e zeri e la seconda sezione si applica ai valori negativi. Se il valore da formattare è negativo, ma diventa zero dopo l'arrotondamento in base al formato nella seconda sezione, lo zero risultante viene formattato in base alla prima sezione. I valori negativi non includono un segno negativo per consentire il controllo completo sulle rappresentazioni di valori negativi. Ad esempio, un valore negativo può essere rappresentato tra parentesi usando un formato personalizzato simile a '##.#;; (####.####)’.
Tre sezioni: la prima sezione si applica ai valori positivi, la seconda sezione si applica ai valori negativi e la terza sezione si applica agli zeri. La seconda sezione può essere vuota (non viene visualizzato nulla tra i punti e virgola), nel qual caso la prima sezione si applica a tutti i valori diversi da zero e i valori negativi includono un segno negativo. Se il numero da formattare è diverso da zero, ma diventa zero dopo l'arrotondamento in base al formato nella prima o nella seconda sezione, lo zero risultante viene formattato in base alla terza sezione.

I System.Enum tipi e System.DateTime supportano anche l'uso di identificatori di formato per formattare le rappresentazioni di stringa dei valori. Il significato di un identificatore di formato specifico varia in base al tipo di dati (numerico, data/ora, enumerazione). Vedere System.Enum e System.Globalization.DateTimeFormatInfo per un elenco completo degli identificatori di formato supportati da ogni tipo.

Abbreviazioni dei tipi di libreria C.5

In questa specifica viene fatto riferimento ai tipi di libreria seguenti. I nomi completi di questi tipi, incluso il qualificatore dello spazio dei nomi globale, sono elencati di seguito. In questa specifica, questi tipi vengono visualizzati come nome completo; con il qualificatore dello spazio dei nomi globale omesso; o come semplice nome di tipo non qualificato, con lo spazio dei nomi omesso. Ad esempio, il tipo ICollection<T>, se usato in questa specifica, significa sempre il 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.Collections.Generic.ICollection<T>
global::System.Collections.Generic.IEnumerable<T>
global::System.Collections.Generic.IEnumerator<T>
global::System.Collections.Generic.IList<T>
global::System.Collections.Generic.IReadonlyCollection<out T>
global::System.Collections.Generic.IReadOnlyList<out T>
global::System.Collections.ICollection
global::System.Collections.IEnumerable
global::System.Collections.IList
global::System.Collections.IEnumerator
global::System.Decimal
global::System.Delegate
global::System.Diagnostics.ConditionalAttribute
global::System.DivideByZeroException
global::System.Double
global::System.Enum
global::System.Exception
global::System.GC
global::System.ICollection
global::System.IDisposable
global::System.IEnumerable
global::System.IEnumerable<out T>
global::System.IList
global::System.IndexOutOfRangeException
global::System.Int16
global::System.Int32
global::System.Int64
global::System.IntPtr
global::System.InvalidCastException
global::System.InvalidOperationException
global::System.Linq.Expressions.Expression<TDelegate>
global::System.MemberInfo
global::System.NotSupportedException
global::System.Nullable<T>
global::System.NullReferenceException
global::System.Object
global::System.ObsoleteAttribute
global::System.OutOfMemoryException
global::System.OverflowException
global::System.Runtime.CompilerServices.CallerFileAttribute
global::System.Runtime.CompilerServices.CallerLineNumberAttribute
global::System.Runtime.CompilerServices.CallerMemberNameAttribute
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.SByte
global::System.Single
global::System.StackOverflowException
global::System.String
global::System.SystemException
global::System.Threading.Monitor
global::System.Threading.Tasks.Task
global::System.Threading.Tasks.Task<TResult>
global::System.Type
global::System.TypeInitializationException
global::System.UInt16
global::System.UInt32
global::System.UInt64
global::System.UIntPtr
global::System.ValueType