Note
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de vous connecter ou de modifier les répertoires.
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de changer de répertoire.
C.1 Général
Une implémentation C# conforme doit fournir un ensemble minimal de types ayant une sémantique spécifique. Ces types et leurs membres sont répertoriés ici, par ordre alphabétique par espace de noms et par type. Pour obtenir une définition formelle des types et de leurs membres identifiés dans (§C.2), reportez-vous à iso/IEC 23271:2012 Common Language Infrastructure (CLI), Partition IV ; Bibliothèque de classes de base (BCL), bibliothèque numérique étendue et bibliothèque de tableaux étendus, qui sont incluses par référence dans cette spécification. Pour obtenir la liste des types et de leurs membres requis au-delà de ceux identifiés dans le §C.2, consultez le §C.3.
Remarque : L’adoption d’un sous-ensemble de l’API de bibliothèque de l’interface CLI ne crée pas de dépendance sur l’interface CLI elle-même ; Une implémentation conforme n’a pas besoin d’être générée ou cible, l’interface CLI.
Ce texte est informatif.
La bibliothèque standard est destinée à être l’ensemble minimal de types et de membres requis par une implémentation C# conforme. Par conséquent, il contient uniquement les membres qui sont explicitement requis par la spécification du langage C#.
On s’attend à ce qu’une implémentation C# conforme fournisse une bibliothèque beaucoup plus étendue qui permet aux programmes utiles d’être écrits. Par exemple, une implémentation conforme peut étendre cette bibliothèque par
- Ajout d’espaces de noms.
- Ajout de types.
- Ajout de membres à des types non-interface.
- Ajout de classes de base ou d’interfaces intermédiaires.
- Le fait d’avoir des types de struct et de classe implémente des interfaces supplémentaires.
- Ajout d’attributs (autres que le
ConditionalAttribute) aux types et membres existants.
Fin du texte informatif.
C.2 Types de bibliothèque standard définis dans ISO/IEC 23271
Remarque : Certains
structtypes ci-dessous ont lereadonlymodificateur. Ce modificateur n’était pas disponible lorsque la norme ISO/IEC 23271 a été publiée, mais elle est requise pour la conformité des implémentations de cette spécification. Note de fin
namespace System
{
public delegate void Action();
public class ArgumentException : SystemException
{
public ArgumentException();
public ArgumentException(string? message);
public ArgumentException(string? message, Exception? innerException);
}
public class ArgumentOutOfRangeException : ArgumentException
{
public ArgumentOutOfRangeException(string? paramName);
public ArgumentOutOfRangeException(string? paramName, string? message);
}
public class ArithmeticException : Exception
{
public ArithmeticException();
public ArithmeticException(string? message);
public ArithmeticException(string? message, Exception? innerException);
}
public abstract class Array : IList, ICollection, IEnumerable
{
public int Length { get; }
public int Rank { get; }
public int GetLength(int dimension);
}
public class ArrayTypeMismatchException : Exception
{
public ArrayTypeMismatchException();
public ArrayTypeMismatchException(string? message);
public ArrayTypeMismatchException(string? message,
Exception? innerException);
}
[AttributeUsageAttribute(AttributeTargets.All, Inherited = true,
AllowMultiple = false)]
public abstract class Attribute
{
protected Attribute();
}
public enum AttributeTargets
{
Assembly = 0x1,
Module = 0x2,
Class = 0x4,
Struct = 0x8,
Enum = 0x10,
Constructor = 0x20,
Method = 0x40,
Property = 0x80,
Field = 0x100,
Event = 0x200,
Interface = 0x400,
Parameter = 0x800,
Delegate = 0x1000,
ReturnValue = 0x2000,
GenericParameter = 0x4000,
All = 0x7FFF
}
[AttributeUsageAttribute(AttributeTargets.Class, Inherited = true)]
public sealed class AttributeUsageAttribute : Attribute
{
public AttributeUsageAttribute(AttributeTargets validOn);
public bool AllowMultiple { get; set; }
public bool Inherited { get; set; }
public AttributeTargets ValidOn { get; }
}
public readonly struct Boolean { }
public readonly struct Byte { }
public readonly struct Char { }
public readonly struct Decimal { }
public abstract class Delegate { }
public class DivideByZeroException : ArithmeticException
{
public DivideByZeroException();
public DivideByZeroException(string? message);
public DivideByZeroException(string? message, Exception? innerException);
}
public readonly struct Double { }
public abstract class Enum : ValueType
{
protected Enum();
}
public class Exception
{
public Exception();
public Exception(string? message);
public Exception(string? message, Exception? innerException);
public Exception? InnerException { get; }
public virtual string Message { get; }
}
public static class GC { }
public interface IDisposable
{
void Dispose();
}
public interface IEquatable<T>
{
bool Equals(T? other);
}
public interface IFormattable { }
public sealed class IndexOutOfRangeException : Exception
{
public IndexOutOfRangeException();
public IndexOutOfRangeException(string? message);
public IndexOutOfRangeException(string? message,
Exception? innerException);
}
public readonly struct Int16 { }
public readonly struct Int32 { }
public readonly struct Int64 { }
public readonly struct IntPtr { }
public class InvalidCastException : Exception
{
public InvalidCastException();
public InvalidCastException(string? message);
public InvalidCastException(string? message, Exception? innerException);
}
public class InvalidOperationException : Exception
{
public InvalidOperationException();
public InvalidOperationException(string? message);
public InvalidOperationException(string? message,
Exception? innerException);
}
public class NotSupportedException : Exception
{
public NotSupportedException();
public NotSupportedException(string? message);
public NotSupportedException(string? message,
Exception? innerException);
}
public struct Nullable<T> where T : struct
{
public bool HasValue { get; }
public T Value { get; }
}
public class NullReferenceException : Exception
{
public NullReferenceException();
public NullReferenceException(string? message);
public NullReferenceException(string? message, Exception? innerException);
}
public class Object
{
public Object();
~Object();
public virtual bool Equals(object? obj);
public virtual int GetHashCode();
public Type GetType();
public virtual string? ToString();
}
[AttributeUsageAttribute(AttributeTargets.Class | AttributeTargets.Struct |
AttributeTargets.Enum | AttributeTargets.Interface |
AttributeTargets.Constructor | AttributeTargets.Method |
AttributeTargets.Property | AttributeTargets.Field |
AttributeTargets.Event | AttributeTargets.Delegate, Inherited = false)]
public sealed class ObsoleteAttribute : Attribute
{
public ObsoleteAttribute();
public ObsoleteAttribute(string? message);
public ObsoleteAttribute(string? message, bool error);
public bool IsError { get; }
public string? Message { get; }
}
public class OutOfMemoryException : Exception
{
public OutOfMemoryException();
public OutOfMemoryException(string? message);
public OutOfMemoryException(string? message, Exception? innerException);
}
public class OverflowException : ArithmeticException
{
public OverflowException();
public OverflowException(string? message);
public OverflowException(string? message, Exception? innerException);
}
public readonly struct SByte { }
public readonly struct Single { }
public sealed class StackOverflowException : Exception
{
public StackOverflowException();
public StackOverflowException(string? message);
public StackOverflowException(string? message, Exception? innerException);
}
public sealed class String : IEnumerable<char>, IEnumerable
{
public int Length { get; }
public char this [int index] { get; }
public static string Format(string format, params object?[] args);
System.Collections.IEnumerator IEnumerable.GetEnumerator();
System.Collections.Generic.IEnumerator<char> IEnumerable<char>.GetEnumerator();
}
public class SystemException : Exception
{
public SystemException();
public SystemException(string? message);
public SystemException(string? message, Exception? innerException);
}
public abstract class Type : MemberInfo { }
public sealed class TypeInitializationException : Exception
{
public TypeInitializationException(string fullTypeName,
Exception? innerException);
}
public readonly struct UInt16 { }
public readonly struct UInt32 { }
public readonly struct UInt64 { }
public readonly struct UIntPtr { }
public abstract class ValueType
{
protected ValueType();
}
}
namespace System.Collections
{
public interface ICollection : IEnumerable
{
int Count { get; }
bool IsSynchronized { get; }
object SyncRoot { get; }
void CopyTo(Array array, int index);
}
public interface IEnumerable
{
IEnumerator GetEnumerator();
}
public interface IEnumerator
{
object Current { get; }
bool MoveNext();
void Reset();
}
public interface IList : ICollection, IEnumerable
{
bool IsFixedSize { get; }
bool IsReadOnly { get; }
object? this [int index] { get; set; }
int Add(object? value);
void Clear();
bool Contains(object? value);
int IndexOf(object? value);
void Insert(int index, object? value);
void Remove(object? value);
void RemoveAt(int index);
}
}
namespace System.Collections.Generic
{
public interface ICollection<T> : IEnumerable<T>
{
int Count { get; }
bool IsReadOnly { get; }
void Add(T item);
void Clear();
bool Contains(T item);
void CopyTo(T[] array, int arrayIndex);
bool Remove(T item);
}
public interface IEnumerable<T> : IEnumerable
{
IEnumerator<T> GetEnumerator();
}
public interface IEnumerator<T> : IDisposable, IEnumerator
{
T Current { get; }
}
public interface IList<T> : ICollection<T>
{
T this [int index] { get; set; }
int IndexOf(T item);
void Insert(int index, T item);
void RemoveAt(int index);
}
}
namespace System.Diagnostics
{
[AttributeUsageAttribute(AttributeTargets.Method | AttributeTargets.Class,
AllowMultiple = true)]
public sealed class ConditionalAttribute : Attribute
{
public ConditionalAttribute(string conditionString);
public string ConditionString { get; }
}
}
namespace System.Reflection
{
public abstract class MemberInfo
{
protected MemberInfo();
}
}
namespace System.Runtime.CompilerServices
{
public sealed class IndexerNameAttribute : Attribute
{
public IndexerNameAttribute(string indexerName);
}
public static class Unsafe
{
public static ref T NullRef<T>();
}
}
namespace System.Threading
{
public static class Monitor
{
public static void Enter(object obj);
public static void Exit(object obj);
}
}
C.3 Types de bibliothèque standard non définis dans ISO/IEC 23271
Les types suivants, y compris les membres répertoriés, doivent être définis dans une bibliothèque standard conforme. (Ces types peuvent être définis dans une prochaine édition de iso/IEC 23271.) On s’attend à ce que la plupart de ces types aient plus de membres disponibles que ceux répertoriés.
Une implémentation conforme peut fournir et Task.GetAwaiter() en Task<TResult>.GetAwaiter() tant que méthodes d’extension.
namespace System
{
public interface IAsyncDisposable
{
ValueTask DisposeAsync();
}
public class FormattableString : IFormattable { }
public class OperationCanceledException : Exception
{
public OperationCanceledException();
public OperationCanceledException(string? message);
public OperationCanceledException(string? message, Exception? innerException);
}
/// <summary>
/// A read-only value type which represents an abstract
/// index to be used with collections.
/// - The Index can be relative to the start or end of a
/// collection.
/// - An Index can be converted to a zero-based concrete
/// from-start index to be used with a collection
/// of some specified length.
/// - Equality between Index values is provided, however
/// unlike concrete indices they are not ordered.
/// - Array and String element access support indexing
/// with Index values.
/// </summary>
public readonly struct Index : IEquatable<Index>
{
/// <summary>
/// Construct an Index from an integer value and a
/// boolean indicating whether the value is relative
/// to the end (true) or start (false).
/// </summary>
/// <param name="value">
/// The value, must be ≥ 0.
/// </param>
/// <param name="fromEnd">
/// Optional boolean indicating whether the Index is
/// relative to the end (true) or start (false).
/// The default value is false.
/// </param>
/// <exception cref="ArgumentOutOfRangeException">
/// Thrown if value < 0.
/// </exception>
/// <remarks>
/// If the Index is relative to the start then:
/// - the value 0 refers to the first element.
/// If the Index is relative to the end then:
/// - the value 1 refers to the last element; and
/// - the value 0 refers to beyond last element.
/// </remarks>
public Index(int value, bool fromEnd = false);
/// <summary>
/// Implicit conversion from integer to a
/// from-start Index.
/// </summary>
/// <remarks>
/// The predefined operator:
/// <c>Index operator ^(int value);</c>
/// is provided to convert from integer to a
/// from-end Index.
/// </remarks>
public static implicit operator Index(int value);
/// <summary>
/// Return the value.
/// </summary>
public int Value { get; }
/// <summary>
/// Return whether the Index is relative to
/// the end (true) or start (false).
/// </summary>
public bool IsFromEnd { get; }
/// <summary>
/// Return a concrete from-start index for a
/// given collection length.
/// </summary>
/// <param name="length">
/// The length of the collection that the index
/// will be used with.
/// </param>
/// <remarks>
/// This method performs no sanity checking and
/// will never throw an IndexOutOfRangeException.
/// It is expected that the returned index will be
/// used with a collection which will do validation.
/// </remarks>
public int GetOffset(int length);
/// <summary>
/// Indicates whether the current Index value is
/// equal to another Index value.
/// </summary>
/// <param name="other">
/// The value to compare with this Index.
/// </param>
public bool Equals(Index other);
}
/// <summary>
/// A read-only value type which represents a range of
/// abstract indices to be used with collections.
/// - The Range has two Index properties, Start and End.
/// - A Range can be converted to a concrete index from
/// the start and a length value to be used with a
/// collection of some specified length.
/// - Equality between Range values is provided,
/// however they are not ordered.
/// - Array and String element access supports indexing
/// with Range values, returning a sub-array/substring
/// of the indexed value respectively.
/// </summary>
public readonly struct Range : IEquatable<Index>
{
/// <summary>
/// Construct a Range from two Index values.
/// </summary>
/// <param name="start">
/// The inclusive Index value for the start
/// of the range.
/// </param>
/// <param name="end">
/// The exclusive Index value for the end
/// of the range.</param>
/// <remarks>
/// As Index values represent unordered abstract
/// indices no sanity checking can be performed
/// on the resultant Range value,
/// <see cref="GetOffsetAndLength">".
///
/// The predefined operator:
/// <c>Range operator ..(Index start, Index end);</c>
/// also exists to create a Range value.
/// </remarks>
public Range(Index start, Index end);
/// <summary>Return the starting Index.</summary>
public Index Start { get; }
/// <summary>Return the ending Index.</summary>
public Index End { get; }
/// <summary>
/// Return a concrete from-start index and the
/// range length for a given collection length.
/// </summary>
/// <param name="length">
/// The length of the collection that the result
/// will be used with.
/// </param>
/// <exception cref="ArgumentOutOfRangeException">
/// Thrown if the range is not valid wrt length.
/// </exception>
/// <returns>
/// A tuple consisting of an index value and range length
/// </returns>
public (int Offset, int Length) GetOffsetAndLength(int length);
/// <summary>
/// Indicates whether the current Range value is equal
/// to another Range value.
/// </summary>
/// <param name="other">
/// The value to compare with this Range.
/// </param>
public bool Equals(Range other);
}
public readonly ref struct ReadOnlySpan<T>
{
public int Length { get; }
public ref readonly T this[int index] { get; }
}
public readonly ref struct Span<T>
{
public int Length { get; }
public ref T this[int index] { get; }
public static implicit operator ReadOnlySpan<T>(Span<T> span);
}
public struct ValueTuple<T1>
{
public T1 Item1;
public ValueTuple(T1 item1);
}
public struct ValueTuple<T1, T2>
{
public T1 Item1;
public T2 Item2;
public ValueTuple(T1 item1, T2 item2);
}
public struct ValueTuple<T1, T2, T3>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public ValueTuple(T1 item1, T2 item2, T3 item3);
}
public struct ValueTuple<T1, T2, T3, T4>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public T4 Item4;
public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4);
}
public struct ValueTuple<T1, T2, T3, T4, T5>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public T4 Item4;
public T5 Item5;
public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5);
}
public struct ValueTuple<T1, T2, T3, T4, T5, T6>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public T4 Item4;
public T5 Item5;
public T6 Item6;
public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5,
T6 item6);
}
public struct ValueTuple<T1, T2, T3, T4, T5, T6, T7>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public T4 Item4;
public T5 Item5;
public T6 Item6;
public T7 Item7;
public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5,
T6 item6, T7 item7);
}
public struct ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public T4 Item4;
public T5 Item5;
public T6 Item6;
public T7 Item7;
public TRest Rest;
public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5,
T6 item6, T7 item7, TRest rest);
}
public interface IAsyncDisposable
{
public System.Threading.Tasks.ValueTask DisposeAsync();
}
}
namespace System.Collections.Generic
{
public interface IReadOnlyCollection<out T> : IEnumerable<T>
{
int Count { get; }
}
public interface IReadOnlyList<out T> : IReadOnlyCollection<T>
{
T this [int index] { get; }
}
public interface IAsyncEnumerable<out T>
{
IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken token = default);
}
public interface IAsyncEnumerator<out T> : IAsyncDisposable
{
ValueTask<bool> MoveNextAsync();
T Current { get; }
}
}
namespace System.Diagnostics.CodeAnalysis
{
[System.AttributeUsage(System.AttributeTargets.Field |
System.AttributeTargets.Parameter | System.AttributeTargets.Property,
Inherited=false)]
public sealed class AllowNullAttribute : Attribute
{
public AllowNullAttribute() { }
}
[System.AttributeUsage(System.AttributeTargets.Field |
System.AttributeTargets.Parameter | System.AttributeTargets.Property,
Inherited=false)]
public sealed class DisallowNullAttribute : Attribute
{
public DisallowNullAttribute() {}
}
[System.AttributeUsage(System.AttributeTargets.Method, Inherited=false)]
public sealed class DoesNotReturnAttribute : Attribute
{
public DoesNotReturnAttribute() {}
}
[System.AttributeUsage(System.AttributeTargets.Parameter, Inherited=false)]
public sealed class DoesNotReturnIfAttribute : Attribute
{
public DoesNotReturnIfAttribute(bool parameterValue) {}
}
[System.AttributeUsage(System.AttributeTargets.Field |
System.AttributeTargets.Parameter | System.AttributeTargets.Property |
System.AttributeTargets.ReturnValue, Inherited=false)]
public sealed class MaybeNullAttribute : Attribute
{
public MaybeNullAttribute() {}
}
[System.AttributeUsage(System.AttributeTargets.Parameter, Inherited=false)]
public sealed class MaybeNullWhenAttribute : Attribute
{
public MaybeNullWhenAttribute(bool returnValue) {}
}
[System.AttributeUsage(System.AttributeTargets.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() { }
}
[System.AttributeUsage(System.AttributeTargets.Parameter, Inherited=false)]
public sealed class EnumeratorCancellationAttribute : Attribute
{
public EnumeratorCancellationAttribute() {}
}
public static class FormattableStringFactory
{
public static FormattableString Create(string format,
params object?[] arguments);
}
public interface ICriticalNotifyCompletion : INotifyCompletion
{
void UnsafeOnCompleted(Action continuation);
}
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
{
public class CancellationTokenSource : IDisposable
{
public CancellationTokenSource();
public System.Threading.CancellationToken Token { get; }
public void Cancel();
public static CancellationTokenSource CreateLinkedTokenSource
(CancellationToken token1,
CancellationToken token2);
}
public readonly struct CancellationToken : IEquatable<CancellationToken>
{
public bool IsCancellationRequested { get; }
}
}
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();
}
}
Spécifications de format C.4
La signification des formats, tel qu’utilisé dans les expressions de chaîne interpolées (§12.8.3), est définie dans la norme ISO/IEC 23271:2012. Pour plus de commodité, le texte suivant est copié à partir de la description de System.IFormattable.
Ce texte est informatif.
Un format est une chaîne qui décrit l’apparence d’un objet lorsqu’il est converti en chaîne. Les formats standard ou personnalisés peuvent être utilisés. Un format standard prend la forme Axx, où A est un caractère alphabétique unique appelé spécificateur de format, et xx est un entier compris entre zéro et 99 inclus, appelé spécificateur de précision. Le spécificateur de format contrôle le type de mise en forme appliqué à la valeur représentée sous forme de chaîne. Le spécificateur de précision contrôle le nombre de chiffres significatifs ou de décimales dans la chaîne, le cas échéant.
Remarque : Pour obtenir la liste des spécificateurs de format standard, consultez le tableau ci-dessous. Notez qu’un type de données donné, tel que
System.Int32, peut ne pas prendre en charge un ou plusieurs spécificateurs de format standard. Note de fin
Remarque : Lorsqu’un format inclut des symboles qui varient selon la culture, tels que les devises incluses par les formats « C » et « c », un objet de mise en forme fournit les caractères réels utilisés dans la représentation sous forme de chaîne. Une méthode peut inclure un paramètre pour passer un
System.IFormatProviderobjet qui fournit un objet de mise en forme, ou la méthode peut utiliser l’objet de mise en forme par défaut, qui contient les définitions de symboles de la culture actuelle. La culture actuelle utilise généralement le même ensemble de symboles que celui utilisé à l’échelle du système par défaut. Dans la bibliothèque de classes de base, l’objet de mise en forme pour les types numériques fournis par le système est uneSystem.Globalization.NumberFormatInfoinstance. PourSystem.DateTimeles instances, unSystem.Globalization.DateTimeFormatInfoest utilisé. Note de fin
Le tableau suivant décrit les spécificateurs de format standard et les membres d’objet de mise en forme associés utilisés avec des types de données numériques dans la bibliothèque de classes de base.
| Spécificateur de format | Description |
|---|---|
|
Format monétaire : utilisé pour les chaînes contenant une valeur monétaire. Les
Si le spécificateur de précision est omis, |
|
Format décimal : (Ce format est valide uniquement lorsqu’il est spécifié avec des types de données intégraux.) Utilisé pour les chaînes contenant des valeurs entières. Les nombres négatifs sont précédés du symbole de nombre négatif spécifié par la Le spécificateur de précision détermine le nombre minimal de chiffres qui apparaissent dans la chaîne. Si la précision spécifiée nécessite plus de chiffres que la valeur contient, la chaîne est à gauche avec des zéros. Si le spécificateur de précision spécifie moins de chiffres que ce qui se trouve dans la valeur, le spécificateur de précision est ignoré. |
|
Format scientifique (ingénierie) : utilisé pour les chaînes dans l’une des formes suivantes : [-]m.dddddd E+xxx [-]m.dddddddE-xxx [-]m.dddddde+xxx [-]m.dddddd e-xxx Le symbole de nombre négatif ('-') apparaît uniquement si la valeur est négative et est fournie par la Exactement un chiffre décimal non zéro (m) précède le séparateur décimal ('.'), fourni par la Le spécificateur de précision détermine le nombre de décimales (dddd) dans la chaîne. Si le spécificateur de précision est omis, six décimales sont incluses dans la chaîne. L’exposant (+/-xxx) se compose d’un symbole de nombre positif ou négatif suivi d’un minimum de trois chiffres (xxx). L’exposant est rembourré à gauche avec des zéros, si nécessaire. Le cas du spécificateur de format ('E' ou 'e') détermine le cas utilisé pour le préfixe d’exposant (E ou e) dans la chaîne. Les résultats sont arrondis à la valeur représentée la plus proche si nécessaire. Le symbole de nombre positif est fourni par la |
|
Format de point fixe : utilisé pour les chaînes sous la forme suivante : [-]m.dd... d Au moins un chiffre décimal non nul (m) précède le séparateur décimal ('.'), fourni par la Un signe de symbole numérique négatif ('-') précède m uniquement si la valeur est négative. Ce symbole est fourni par la Le spécificateur de précision détermine le nombre de décimales (dd... d) dans la chaîne. Si le spécificateur de précision est omis, |
|
Format général : la chaîne est mise en forme au format à virgule fixe ('F' ou 'f') ou au format scientifique ('E' ou 'e'). Pour les types intégraux : Les valeurs sont mises en forme à l’aide du format à virgule fixe si le spécificateur de précision d’exposant< , où l’exposant est l’exposant de la valeur au format scientifique. Pour toutes les autres valeurs, le format scientifique est utilisé. Si le spécificateur de précision est omis, une précision par défaut égale à la largeur de champ requise pour afficher la valeur maximale du type de données est utilisée, ce qui entraîne la mise en forme de la valeur au format à virgule fixe. Les précisions par défaut pour les types intégraux sont les suivantes :
Pour les types Single, Decimal et Double : Les valeurs sont mises en forme à l’aide d’un format à point fixe si l’exposant ≥ -4 et <, où l’exposant est l’exposant de la valeur au format scientifique. Pour toutes les autres valeurs, le format scientifique est utilisé. Les résultats sont arrondis à la valeur représentée la plus proche si nécessaire. Si le spécificateur de précision est omis, les précisions par défaut suivantes sont utilisées :
Pour tous les types :
|
|
Format numérique : utilisé pour les chaînes sous la forme suivante : [-]d,ddd,ddd.dd... d La représentation des valeurs négatives est déterminée par la Au moins un chiffre décimal non nul (d) précède le séparateur décimal ('.'), fourni par la Le spécificateur de précision détermine le nombre de décimales (dd... d). Si le spécificateur de précision est omis, |
|
Format de pourcentage : utilisé pour les chaînes contenant un pourcentage. Les
Si aucune précision n’est spécifiée, le nombre de décimales dans le résultat est déterminé par Le résultat est mis à l’échelle de 100 (.99 devient 99 %). |
|
Format aller-retour : (ce format est valide uniquement quand il est spécifié avec System.Double ou System.Single.) Utilisé pour garantir que la précision de la représentation sous forme de chaîne d’une valeur à virgule flottante est telle que l’analyse de la chaîne n’entraîne pas de perte de précision par rapport à la valeur d’origine. Si la précision maximale du type de données (7 pour System.Single, et 15 pour System.Double) entraînerait une perte de précision, la précision est augmentée par deux décimales. Si un spécificateur de précision est fourni avec ce spécificateur de format, il est ignoré. Ce format est sinon identique au format de point fixe. |
|
Format hexadécimal : (Ce format est valide uniquement lorsqu’il est spécifié avec des types de données intégraux.) Utilisé pour les représentations sous forme de chaîne de nombres dans base 16. La précision détermine le nombre minimal de chiffres dans la chaîne. Si la précision spécifie plus de chiffres que le nombre contient, le nombre est rembourré à gauche avec des zéros. La casse du spécificateur de format ('X' ou 'x') détermine si les majuscules ou minuscules sont utilisées dans la représentation hexadécimale. |
Si la valeur numérique est une System.Single ou System.Double avec une valeur de , NaNou PositiveInfinitysi le spécificateur de NegativeInfinityformat est ignoré et que l’une des valeurs suivantes est retournée : System.Globalization.NumberFormatInfo.NaNSymbol, System.Globalization.NumberFormatInfo.PositiveInfinitySymbolou System.Globalization.NumberFormatInfo.NegativeInfinitySymbol.
Un format personnalisé est une chaîne spécifiée en tant que format qui n’est pas sous la forme d’une chaîne de format standard (Axx) décrite ci-dessus. Le tableau suivant décrit les caractères utilisés dans la construction de formats personnalisés.
| Spécificateur de format | Description |
|---|---|
0 (zéro) |
Espace réservé zéro : si la valeur mise en forme a un chiffre dans la position où un « 0 » apparaît dans le format personnalisé, ce chiffre est copié dans la chaîne de sortie ; sinon, un zéro est stocké dans cette position dans la chaîne de sortie. Position du séparateur le plus à gauche avant le séparateur décimal et le séparateur le plus à droite après le séparateur décimal déterminent la plage de chiffres toujours présents dans la chaîne de sortie. Le nombre d’espaces réservés Zéro et/ou Chiffre après le séparateur décimal détermine le nombre de chiffres qui apparaissent après le séparateur décimal. Les valeurs sont arrondies si nécessaire. |
# |
Espace réservé numérique : si la valeur mise en forme a un chiffre dans la position où un « # » apparaît dans le format personnalisé, ce chiffre est copié dans la chaîne de sortie ; sinon, rien n’est stocké dans cette position dans la chaîne de sortie. Notez que ce spécificateur ne stocke jamais le caractère « 0 » s’il n’est pas un chiffre significatif, même si « 0 » est le seul chiffre de la chaîne. (Il affiche le caractère « 0 » dans la chaîne de sortie s’il s’agit d’un chiffre significatif.) Le nombre d’espaces réservés Zéro et/ou Chiffre après le séparateur décimal détermine le nombre de chiffres qui apparaissent après le séparateur décimal. Les valeurs sont arrondies si nécessaire. |
. (période) |
Séparateur décimal : le plus à gauche « . »
caractère dans la chaîne de format détermine l’emplacement du séparateur décimal dans la valeur mise en forme ; tout autre '.' les caractères sont ignorés. La System.Globalization.NumberFormatInfo.NumberDecimalSeparator propriété détermine le symbole utilisé comme séparateur décimal. |
, (virgule) |
Séparateur de groupe et mise à l’échelle des nombres : le caractère « , » sert à deux fins. Tout d’abord, si le format personnalisé contient ce caractère entre deux espaces réservés Zéro ou Chiffre (0 ou #) et à gauche du séparateur décimal s’il en existe un, la sortie aura des séparateurs de groupe insérés entre chaque groupe de chiffres à gauche du séparateur décimal. Les Si la chaîne de format contient un ou plusieurs caractères « », immédiatement à gauche du séparateur décimal, le nombre sera mis à l’échelle. Le facteur d’échelle est déterminé par le nombre de caractères de séparateur de groupe immédiatement à gauche du séparateur décimal. S’il existe des caractères x, la valeur est divisée par 1 000X avant sa mise en forme. Par exemple, la chaîne de format « 0 », divise une valeur d’un million. Notez que la présence du caractère « , » pour indiquer que la mise à l’échelle n’insère pas de séparateurs de groupe dans la chaîne de sortie. Par conséquent, pour mettre à l’échelle un nombre de 1 million et insérer des séparateurs de groupes, utilisez un format personnalisé similaire à « #,##0 », |
% (pourcentage) |
Espace réservé de pourcentage : la présence d’un caractère « % » dans un format personnalisé entraîne la multiplication d’un nombre par 100 avant d’être mis en forme. Le symbole de pourcentage est inséré dans la chaîne de sortie à l’emplacement où « % » apparaît dans la chaîne de format. La System.Globalization.NumberFormatInfo.PercentSymbol propriété détermine le symbole de pourcentage. |
|
Format d’ingénierie : si l’une des chaînes 'E', 'E+', 'E-', 'e', 'e+' ou 'e-' sont présentes dans un format personnalisé et est suivie immédiatement d’au moins un caractère '0', la valeur est mise en forme à l’aide de la notation scientifique. Le nombre de caractères « 0 » suivant le préfixe d’exposant (E ou e) détermine le nombre minimal de chiffres dans l’exposant. Les formats « E+ » et « e+ » indiquent qu’un symbole de nombre positif ou négatif précède toujours l’exposant. Les formats 'E', 'E-', 'e' ou 'e-' indiquent qu’un symbole de nombre négatif précède les exposants négatifs ; aucun symbole ne précède les exposants positifs. Le symbole de nombre positif est fourni par la System.Globalization.NumberFormatInfo.PositiveSign propriété. Le symbole de nombre négatif est fourni par la System.Globalization.NumberFormatInfo.NegativeSign propriété. |
\ (barre oblique inverse) |
Caractère d’échappement : dans certaines langues, telles que C#, le caractère de barre oblique inverse entraîne l’interprétation du caractère suivant dans le format personnalisé comme une séquence d’échappement. Il est utilisé avec des séquences de mise en forme de langage C, telles que « \n » (nouvelle ligne). Dans certaines langues, le caractère d’échappement lui-même doit être précédé d’un caractère d’échappement lorsqu’il est utilisé comme littéral. Sinon, un compilateur interprète le caractère comme une séquence d’échappement. Ce caractère d’échappement n’est pas nécessaire pour être pris en charge dans tous les langages de programmation. |
|
Chaîne littérale : les caractères placés entre guillemets simples ou doubles sont copiés dans la chaîne de sortie littéralement et n’affectent pas la mise en forme. |
; (point-virgule) |
Séparateur de section : le caractère « ; » est utilisé pour séparer les sections pour les nombres positifs, négatifs et zéro dans la chaîne de format. (Cette fonctionnalité est décrite en détail ci-dessous.) |
| Other | Tous les autres caractères : tous les autres caractères sont stockés dans la chaîne de sortie en tant que littéraux dans la position dans laquelle ils apparaissent. |
Notez que pour les chaînes de format de point fixe (chaînes ne contenant pas de « E0 », « E+0 », « E-0 », « e0 », « e +0 » ou « e-0 »), les nombres sont arrondis à autant de décimales qu’il y a des espaces réservés zéro ou chiffre à droite du séparateur décimal. Si le format personnalisé ne contient pas de séparateur décimal, le nombre est arrondi à l’entier le plus proche. Si le nombre comporte plus de chiffres qu’il y a des espaces réservés Zéro ou Chiffre à gauche du séparateur décimal, les chiffres supplémentaires sont copiés dans la chaîne de sortie immédiatement avant le premier espace réservé Zéro ou Chiffre.
Un format personnalisé peut contenir jusqu’à trois sections séparées par des caractères de séparation de section, pour spécifier une mise en forme différente pour les valeurs positives, négatives et nulles. Les sections sont interprétées comme suit :
Une section : Le format personnalisé s’applique à toutes les valeurs (positif, négatif et zéro). Les valeurs négatives incluent un signe négatif.
Deux sections : La première section s’applique aux valeurs positives et zéros, et la deuxième section s’applique aux valeurs négatives. Si la valeur à mettre en forme est négative, mais devient zéro après l’arrondi en fonction du format de la deuxième section, le zéro obtenu est mis en forme en fonction de la première section. Les valeurs négatives n’incluent pas de signe négatif pour permettre un contrôle total sur les représentations des valeurs négatives. Par exemple, un négatif peut être représenté entre parenthèses à l’aide d’un format personnalisé similaire à '##.## ; (####.####)’.
Trois sections : La première section s’applique aux valeurs positives, la deuxième section s’applique aux valeurs négatives et la troisième section s’applique aux zéros. La deuxième section peut être vide (rien n’apparaît entre les points-virgules), auquel cas la première section s’applique à toutes les valeurs non nulles et les valeurs négatives incluent un signe négatif. Si le nombre à mettre en forme est différent de zéro, mais devient zéro après l’arrondi en fonction du format dans la première ou la deuxième section, le zéro obtenu est mis en forme conformément à la troisième section.
Les types et System.Enum les System.DateTime types prennent également en charge l’utilisation de spécificateurs de format pour mettre en forme des représentations sous forme de chaîne de valeurs. La signification d’un spécificateur de format spécifique varie en fonction du type de données (numérique, date/heure, énumération) mise en forme. Consultez System.Enum et System.Globalization.DateTimeFormatInfo pour obtenir une liste complète des spécificateurs de format pris en charge par chaque type.
Abréviations de type de bibliothèque C.5
Les types de bibliothèque suivants sont référencés dans cette spécification. Les noms complets de ces types, y compris le qualificateur d’espace de noms global sont répertoriés ci-dessous. Tout au long de cette spécification, ces types apparaissent sous la forme du nom complet ; avec le qualificateur d’espace de noms global omis ; ou comme nom de type non qualifié simple, avec également l’espace de noms omis. Par exemple, le type ICollection<T>, lorsqu’il est utilisé dans cette spécification, signifie toujours le type global::System.Collections.Generic.ICollection<T>.
global::System.Actionglobal::System.ArgumentExceptionglobal::System.ArgumentOutOfRangeExceptionglobal::System.ArithmeticExceptionglobal::System.Arrayglobal::System.ArrayTypeMisMatchExceptionglobal::System.Attributeglobal::System.AttributeTargetsglobal::System.AttributeUsageAttributeglobal::System.Booleanglobal::System.Byteglobal::System.Charglobal::System.Decimalglobal::System.Delegateglobal::System.DivideByZeroExceptionglobal::System.Doubleglobal::System.Enumglobal::System.Exceptionglobal::System.FormattableStringglobal::System.GCglobal::System.IAsyncDisposableglobal::System.IDisposableglobal::System.IEquatable<T>global::System.IFormattableglobal::System.Indexglobal::System.IndexOutOfRangeExceptionglobal::System.Int16global::System.Int32global::System.Int64global::System.IntPtrglobal::System.InvalidCastExceptionglobal::System.InvalidOperationExceptionglobal::System.NotSupportedExceptionglobal::System.Nullable<T>global::System.NullReferenceExceptionglobal::System.Objectglobal::System.ObsoleteAttributeglobal::System.OperationCanceledExceptionglobal::System.OutOfMemoryExceptionglobal::System.OverflowExceptionglobal::System.Rangeglobal::System.ReadOnlySpanglobal::System.SByteglobal::System.Singleglobal::System.Spanglobal::System.StackOverflowExceptionglobal::System.Stringglobal::System.SystemExceptionglobal::System.Typeglobal::System.TypeInitializationExceptionglobal::System.UInt16global::System.UInt32global::System.UInt64global::System.UIntPtrglobal::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.ValueTypeglobal::System.Collections.ICollectionglobal::System.Collections.IEnumerableglobal::System.Collections.IEnumeratorglobal::System.Collections.IListglobal::System.Collections.Generic.IAsyncEnumerable<out T>global::System.Collections.Generic.IAsyncEnumerator<out T>global::System.Collections.Generic.ICollection<T>global::System.Collections.Generic.IEnumerable<T>global::System.Collections.Generic.IEnumerator<T>global::System.Collections.Generic.IList<T>global::System.Collections.Generic.IReadonlyCollection<out T>global::System.Collections.Generic.IReadOnlyList<out T>global::System.Diagnostics.ConditionalAttributeglobal::System.Diagnostics.CodeAnalysis.AllowNullAttributeglobal::System.Diagnostics.CodeAnalysis.DisallowNullAttributeglobal::System.Diagnostics.CodeAnalysis.DoesNotReturnAttributeglobal::System.Diagnostics.CodeAnalysis.DoesNotReturnIfAttributeglobal::System.Diagnostics.CodeAnalysis.MaybeNullAttributeglobal::System.Diagnostics.CodeAnalysis.MaybeNullWhenAttributeglobal::System.Diagnostics.CodeAnalysis.NotNullAttributeglobal::System.Diagnostics.CodeAnalysis.NotNullIfNotNullAttributeglobal::System.Diagnostics.CodeAnalysis.NotNullWhenAttributeglobal::System.Linq.Expressions.Expression<TDelegate>global::System.Reflection.MemberInfoglobal::System.Runtime.CompilerServices.AsyncMethodBuilderAttributeglobal::System.Runtime.CompilerServices.CallerFileAttributeglobal::System.Runtime.CompilerServices.CallerLineNumberAttributeglobal::System.Runtime.CompilerServices.CallerMemberNameAttributeglobal::System.Runtime.CompilerServices.FormattableStringFactoryglobal::System.Runtime.CompilerServices.ICriticalNotifyCompletionglobal::System.Runtime.CompilerServices.IndexerNameAttributeglobal::System.Runtime.CompilerServices.INotifyCompletionglobal::System.Runtime.CompilerServices.TaskAwaiterglobal::System.Runtime.CompilerServices.TaskAwaiter<T>global::System.Runtime.CompilerServices.ValueTaskAwaiterglobal::System.Runtime.CompilerServices.ValueTaskAwaiter<TResult>global::System.Runtime.CompilerServices.Unsafeglobal::System.Threading.Monitorglobal::System.Threading.Tasks.Taskglobal::System.Threading.Tasks.Task<TResult>
Fin du texte informatif.
Collaborez avec nous sur GitHub
La source de ce contenu se trouve sur GitHub, où vous pouvez également créer et examiner des problèmes et des demandes de tirage. Pour plus d’informations, consultez notre guide du contributeur.
ECMA C# draft specification