Bijlage C Standaardbibliotheek
C.1 Algemeen
Een conforme C#-implementatie biedt een minimumset typen met specifieke semantiek. Deze typen en hun leden worden hier weergegeven, in alfabetische volgorde op naamruimte en type. Voor een formele definitie van deze typen en hun leden raadpleegt u ISO/IEC 23271:2012 Common Language Infrastructure (CLI), Partition IV; Base Class Library (BCL), Extended Numerics Library en Extended Array Library, die zijn opgenomen in deze specificatie.
Deze tekst is informatief.
De standaardbibliotheek is bedoeld als de minimale set typen en leden die vereist zijn voor een conforme C#-implementatie. Als zodanig bevat het alleen de leden die expliciet zijn vereist voor de C#-taalspecificatie.
Er wordt verwacht dat een conforme C#-implementatie een aanzienlijk uitgebreidere bibliotheek levert waarmee nuttige programma's kunnen worden geschreven. Een conforme implementatie kan deze bibliotheek bijvoorbeeld uitbreiden door
- Naamruimten toevoegen.
- Typen toevoegen.
- Leden toevoegen aan niet-interfacetypen.
- Tussenliggende basisklassen of interfaces toevoegen.
- Met struct- en klassetypen worden extra interfaces geïmplementeerd.
- Kenmerken (anders dan de
ConditionalAttribute) toevoegen aan bestaande typen en leden.
Einde van informatieve tekst.
C.2 Standaardbibliotheektypen gedefinieerd in ISO/IEC 23271
Opmerking: Sommige
structtypen hieronder hebben dereadonlywijzigingsfunctie. Deze wijzigingsfunctie was niet beschikbaar toen ISO/IEC 23271 werd uitgebracht, maar is vereist voor het voldoen aan implementaties van deze specificatie. eindnotitie
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 Standaardbibliotheektypen die niet zijn gedefinieerd in ISO/IEC 23271
De volgende typen, met inbegrip van de vermelde leden, worden gedefinieerd in een conforme standaardbibliotheek. (Deze typen kunnen worden gedefinieerd in een toekomstige editie van ISO/IEC 23271.) Er wordt verwacht dat veel van deze typen meer leden beschikbaar zullen hebben dan vermeld.
Een conforme implementatie kan en Task.GetAwaiter() als uitbreidingsmethoden biedenTask<TResult>.GetAwaiter().
namespace System
{
public class FormattableString : IFormattable { }
public class OperationCanceledException : Exception
{
public OperationCanceledException();
public OperationCanceledException(string message);
public OperationCanceledException(string message, Exception innerException);
}
public readonly ref struct ReadOnlySpan<T>
{
public int Length { get; }
public ref readonly T this[int index] { get; }
}
public readonly ref struct Span<T>
{
public int Length { get; }
public ref T this[int index] { get; }
public static implicit operator ReadOnlySpan<T>(Span<T> span);
}
public struct ValueTuple<T1>
{
public T1 Item1;
public ValueTuple(T1 item1);
}
public struct ValueTuple<T1, T2>
{
public T1 Item1;
public T2 Item2;
public ValueTuple(T1 item1, T2 item2);
}
public struct ValueTuple<T1, T2, T3>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public ValueTuple(T1 item1, T2 item2, T3 item3);
}
public struct ValueTuple<T1, T2, T3, T4>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public T4 Item4;
public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4);
}
public struct ValueTuple<T1, T2, T3, T4, T5>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public T4 Item4;
public T5 Item5;
public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5);
}
public struct ValueTuple<T1, T2, T3, T4, T5, T6>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public T4 Item4;
public T5 Item5;
public T6 Item6;
public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5,
T6 item6);
}
public struct ValueTuple<T1, T2, T3, T4, T5, T6, T7>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public T4 Item4;
public T5 Item5;
public T6 Item6;
public T7 Item7;
public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5,
T6 item6, T7 item7);
}
public struct ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public T4 Item4;
public T5 Item5;
public T6 Item6;
public T7 Item7;
public TRest Rest;
public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5,
T6 item6, T7 item7, TRest rest);
}
}
namespace System.Collections.Generic
{
public interface IReadOnlyCollection<out T> : IEnumerable<T>
{
int Count { get; }
}
public interface IReadOnlyList<out T> : IReadOnlyCollection<T>
{
T this [int index] { get; }
}
}
namespace System.Linq.Expressions
{
public sealed class Expression<TDelegate>
{
public TDelegate Compile();
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct |
AttributeTargets.Interface,
Inherited = false, AllowMultiple = false)]
public sealed class AsyncMethodBuilderAttribute : Attribute
{
public AsyncMethodBuilderAttribute(Type builderType) {}
public Type BuilderType { get; }
}
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
public sealed class CallerFilePathAttribute : Attribute
{
public CallerFilePathAttribute() { }
}
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
public sealed class CallerLineNumberAttribute : Attribute
{
public CallerLineNumberAttribute() { }
}
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
public sealed class CallerMemberNameAttribute : Attribute
{
public CallerMemberNameAttribute() { }
}
public static class FormattableStringFactory
{
public static FormattableString Create(string format,
params object[] arguments);
}
public interface ICriticalNotifyCompletion : INotifyCompletion
{
void UnsafeOnCompleted(Action continuation);
}
public interface INotifyCompletion
{
void OnCompleted(Action continuation);
}
public readonly struct TaskAwaiter : ICriticalNotifyCompletion,
INotifyCompletion
{
public bool IsCompleted { get; }
public void GetResult();
}
public readonly struct TaskAwaiter<TResult> : ICriticalNotifyCompletion,
INotifyCompletion
{
public bool IsCompleted { get; }
public TResult GetResult();
}
public readonly struct ValueTaskAwaiter : ICriticalNotifyCompletion,
INotifyCompletion
{
public bool IsCompleted { get; }
public void GetResult();
}
public readonly struct ValueTaskAwaiter<TResult>
: ICriticalNotifyCompletion, INotifyCompletion
{
public bool IsCompleted { get; }
public TResult GetResult();
}
[System.AttributeUsage(System.AttributeTargets.Field |
System.AttributeTargets.Parameter | System.AttributeTargets.Property,
Inherited=false)]
public sealed class AllowNullAttribute : Attribute
{
public AllowNullAttribute() { }
}
[System.AttributeUsage(System.AttributeTargets.Field |
System.AttributeTargets.Parameter | System.AttributeTargets.Property,
Inherited=false)]
public sealed class DisallowNullAttribute : Attribute
{
public DisallowNullAttribute() {}
}
[System.AttributeUsage(System.AttributeTargets.Method, Inherited=false)]
public sealed class DoesNotReturnAttribute : Attribute
{
public DoesNotReturnAttribute() {}
}
[System.AttributeUsage(System.AttributeTargets.Parameter, Inherited=false)]
public sealed class DoesNotReturnIfAttribute : Attribute
{
public DoesNotReturnIfAttribute(bool parameterValue) {}
}
[System.AttributeUsage(System.AttributeTargets.Field |
System.AttributeTargets.Parameter | System.AttributeTargets.Property |
System.AttributeTargets.ReturnValue, Inherited=false)]
public sealed class MaybeNullAttribute : Attribute
{
public MaybeNullAttribute() {}
}
[System.AttributeUsage(System.AttributeTargets.Parameter, Inherited=false)]
public sealed class MaybeNullWhenAttribute : Attribute
{
public MaybeNullWhenAttribute(bool returnValue) {}
}
[System.AttributeUsage(System.AttributeTargets.Field |
System.AttributeTargets.Parameter | System.AttributeTargets.Property |
System.AttributeTargets.ReturnValue, Inherited=false)]
public sealed class NotNullAttribute : Attribute
{
public NotNullAttribute() {}
}
[System.AttributeUsage(System.AttributeTargets.Parameter |
System.AttributeTargets.Property | System.AttributeTargets.ReturnValue,
AllowMultiple=true, Inherited=false)]
public sealed class NotNullIfNotNullAttribute : Attribute
{
public NotNullIfNotNullAttribute(string parameterName) {}
}
[System.AttributeUsage(System.AttributeTargets.Parameter, Inherited=false)]
public sealed class NotNullWhenAttribute : Attribute
{
public NotNullWhenAttribute(bool returnValue) {}
}
}
namespace System.Threading.Tasks
{
public class Task
{
public System.Runtime.CompilerServices.TaskAwaiter GetAwaiter();
}
public class Task<TResult> : Task
{
public new System.Runtime.CompilerServices.TaskAwaiter<T> GetAwaiter();
}
public readonly struct ValueTask : System.IEquatable<ValueTask>
{
public System.Runtime.CompilerServices.ValueTaskAwaiter GetAwaiter();
}
public readonly struct ValueTask<TResult>
: System.IEquatable<ValueTask<TResult>>
{
public new System.Runtime.CompilerServices.ValueTaskAwaiter<TResult>
GetAwaiter();
}
}
Specificaties voor C.4-indeling
De betekenis van de notaties, zoals wordt gebruikt in geïnterpoleerde tekenreeksexpressies (§12.8.3), zijn gedefinieerd in ISO/IEC 23271:2012. Voor het gemak wordt de volgende tekst gekopieerd uit de beschrijving van System.IFormattable.
Deze tekst is informatief.
Een indeling is een tekenreeks die het uiterlijk van een object beschrijft wanneer het wordt geconverteerd naar een tekenreeks. Standaard- of aangepaste indelingen kunnen worden gebruikt. Een standaardindeling heeft de vorm Axx, waarbij A één alfabetisch teken is dat de notatieaanduiding wordt genoemd en xx een geheel getal is tussen nul en 99 inclusief, de precisieaanduiding. De opmaakaanduiding bepaalt het type opmaak dat wordt toegepast op de waarde die wordt weergegeven als een tekenreeks. De precisieaanduiding bepaalt het aantal significante cijfers of decimalen in de tekenreeks, indien van toepassing.
Opmerking: Zie de onderstaande tabel voor de lijst met standaardopmaakaanduidingen. Houd er rekening mee dat een bepaald gegevenstype, zoals
System.Int32, mogelijk geen ondersteuning biedt voor een of meer standaardindelingsaanduidingen. eindnotitie
Opmerking: Wanneer een notatie symbolen bevat die variëren per cultuur, zoals de valutasymbol die is opgenomen in de notatie 'C' en 'c', levert een opmaakobject de werkelijke tekens die worden gebruikt in de tekenreeksweergave. Een methode kan een parameter bevatten om een
System.IFormatProviderobject door te geven dat een opmaakobject levert, of de methode kan het standaardopmaakobject gebruiken, dat de symbooldefinities voor de huidige cultuur bevat. De huidige cultuur gebruikt doorgaans dezelfde set symbolen die standaard in het hele systeem worden gebruikt. In de basisklassebibliotheek is het opmaakobject voor door het systeem geleverde numerieke typen eenSystem.Globalization.NumberFormatInfoexemplaar. Er wordt bijvoorbeeldSystem.DateTimeeenSystem.Globalization.DateTimeFormatInfogebruikt. eindnotitie
In de volgende tabel worden de standaardopmaakaanduidingen en de gekoppelde leden van het opmaakobject beschreven die worden gebruikt met numerieke gegevenstypen in de Basisklassebibliotheek.
| Opmaakaanduiding | Beschrijving |
|---|---|
|
Valutanotatie: wordt gebruikt voor tekenreeksen die een monetaire waarde bevatten. De
Als de precisieaanduiding wordt weggelaten, |
|
Decimale notatie: (Deze notatie is alleen geldig wanneer deze is opgegeven met integrale gegevenstypen.) Wordt gebruikt voor tekenreeksen die gehele getallen bevatten. Negatieve getallen worden voorafgegaan door het negatieve getalsymbool dat is opgegeven door de De precisieaanduiding bepaalt het minimumaantal cijfers dat in de tekenreeks wordt weergegeven. Als voor de opgegeven precisie meer cijfers zijn vereist dan de waarde bevat, wordt de tekenreeks links opgevuld met nullen. Als de precisieaanduiding minder cijfers opgeeft dan de waarde bevat, wordt de precisieaanduiding genegeerd. |
|
Wetenschappelijke indeling (engineering): wordt gebruikt voor tekenreeksen in een van de volgende vormen: +m.dddddE+xxx +m.ddddddE-xxx +m.ddddde+xxx +m.ddddde-xxx Het negatieve getalsymbool ('-') wordt alleen weergegeven als de waarde negatief is en wordt opgegeven door de Precies één niet-nul decimaalteken (m) voorafgaat aan het decimaalteken ('.'), dat wordt opgegeven door de De precisieaanduiding bepaalt het aantal decimalen (dddddd) in de tekenreeks. Als de precisieaanduiding wordt weggelaten, worden er zes decimalen in de tekenreeks opgenomen. De exponent (+/-xxx) bestaat uit een positief of negatief getalsymbool gevolgd door een minimum van drie cijfers (xxx). De exponent wordt indien nodig links opgevuld met nullen. Het geval van de notatieaanduiding ('E' of 'e') bepaalt het hoofdlettergebruik voor het exponentvoorvoegsel (E of e) in de tekenreeks. Resultaten worden zo nodig afgerond op de dichtstbijzijnde vertegenwoordigbare waarde. Het positieve getalsymbool wordt door de |
|
Vaste-puntnotatie: wordt gebruikt voor tekenreeksen in de volgende vorm: +m.dd... d Ten minste één niet-nul decimale cijfer (m) voorafgaat aan het decimaalteken ('.'), dat door de Een symboolteken voor een negatief getal ('-') gaat alleen vooraf als de waarde negatief is. Dit symbool wordt geleverd door de De precisieaanduiding bepaalt het aantal decimalen (dd... d) in de tekenreeks. Als de precisieaanduiding wordt weggelaten, |
|
Algemene notatie: De tekenreeks is opgemaakt in vaste-puntnotatie ('F' of 'f') of wetenschappelijke notatie ('E' of 'e'). Voor integrale typen: Waarden worden opgemaakt met vaste-puntnotatie als exponent< precisieaanduiding, waarbij exponent de exponent is van de waarde in wetenschappelijke notatie. Voor alle andere waarden wordt de wetenschappelijke notatie gebruikt. Als de precisieaanduiding wordt weggelaten, wordt een standaardprecisie gelijk aan de veldbreedte die is vereist om de maximumwaarde voor het gegevenstype weer te geven, wat resulteert in de waarde die wordt opgemaakt in vaste-puntnotatie. De standaardprecisie voor integrale typen zijn als volgt:
Voor typen Enkel, Decimaal en Dubbel: Waarden worden opgemaakt met vaste-puntnotatie als exponent ≥ -4 en < precisieaanduiding, waarbij exponent de exponent is van de waarde in wetenschappelijke indeling. Voor alle andere waarden wordt de wetenschappelijke notatie gebruikt. Resultaten worden zo nodig afgerond op de dichtstbijzijnde vertegenwoordigbare waarde. Als de precisieaanduiding wordt weggelaten, worden de volgende standaardprecisies gebruikt:
Voor alle typen:
|
|
Getalnotatie: wordt gebruikt voor tekenreeksen in de volgende vorm: +d,ddd,ddd.dd... d De weergave van negatieve waarden wordt bepaald door de Ten minste één niet-nul decimale cijfer (d) voorafgaat aan het decimaalteken ('.'), dat wordt opgegeven door de De precisieaanduiding bepaalt het aantal decimalen (dd... d). Als de precisieaanduiding wordt weggelaten, |
|
Percentagenotatie: wordt gebruikt voor tekenreeksen die een percentage bevatten. De
Als er geen precisie is opgegeven, wordt het aantal decimalen in het resultaat bepaald door Het resultaat wordt geschaald met 100 (,99 wordt 99%). |
|
Retourindeling: (Deze indeling is alleen geldig wanneer deze is opgegeven met System.Double of System.Single.) Wordt gebruikt om ervoor te zorgen dat de precisie van de tekenreeksweergave van een drijvende-kommawaarde zodanig is dat het parseren van de tekenreeks geen verlies van precisie oplevert in vergelijking met de oorspronkelijke waarde. Als de maximale precisie van het gegevenstype (7 voor System.Singleen 15 voor System.Double) tot verlies van precisie zou leiden, wordt de precisie met twee decimalen verhoogd. Als een precisieaanduiding wordt geleverd met deze indelingsaanduiding, wordt deze genegeerd. Deze indeling is anders identiek aan de indeling met vaste punten. |
|
Hexadecimale notatie: (Deze indeling is alleen geldig wanneer deze is opgegeven met integrale gegevenstypen.) Wordt gebruikt voor tekenreeksweergaven van getallen in basis 16. De precisie bepaalt het minimumaantal cijfers in de tekenreeks. Als de precisie meer cijfers opgeeft dan het getal bevat, wordt het getal links opgevuld met nullen. Het geval van de notatieaanduiding ('X' of 'x') bepaalt of hoofdletters of kleine letters worden gebruikt in de hexadecimale weergave. |
Als de numerieke waarde een System.Single of System.Double met een waarde van NaN, PositiveInfinityof NegativeInfinity, de notatieaanduiding wordt genegeerd en een van de volgende wordt geretourneerd: System.Globalization.NumberFormatInfo.NaNSymbol, System.Globalization.NumberFormatInfo.PositiveInfinitySymbol, of System.Globalization.NumberFormatInfo.NegativeInfinitySymbol.
Een aangepaste notatie is een tekenreeks die is opgegeven als een indeling die niet de vorm heeft van een standaardnotatietekenreeks (Axx) die hierboven wordt beschreven. In de volgende tabel worden de tekens beschreven die worden gebruikt bij het maken van aangepaste indelingen.
| Opmaakaanduiding | Beschrijving |
|---|---|
0 (nul) |
Tijdelijke aanduiding voor nul: als de waarde die wordt opgemaakt een cijfer heeft op de positie waar een '0' wordt weergegeven in de aangepaste notatie, wordt dat cijfer gekopieerd naar de uitvoertekenreeks; anders wordt er een nul opgeslagen op die positie in de uitvoertekenreeks. De positie van de meest linkse '0' vóór het decimaalteken en het meest rechtse '0' na het decimaalteken bepaalt het bereik van cijfers die altijd aanwezig zijn in de uitvoertekenreeks. Het aantal tijdelijke aanduidingen nul en/of cijfer na het decimaalteken bepaalt het aantal cijfers dat na het decimaalteken wordt weergegeven. Waarden worden zo nodig afgerond. |
# |
Tijdelijke aanduiding voor cijfers: als de waarde die wordt opgemaakt een cijfer heeft op de positie waar een #wordt weergegeven in de aangepaste notatie, wordt dat cijfer gekopieerd naar de uitvoertekenreeks. Anders wordt er niets opgeslagen op die positie in de uitvoertekenreeks. Houd er rekening mee dat met deze aanduiding nooit het teken 0 wordt opgeslagen als het geen significant cijfer is, zelfs als '0' het enige cijfer in de tekenreeks is. (Het teken '0' wordt wel weergegeven in de uitvoertekenreeks als het een significant cijfer is.) Het aantal tijdelijke aanduidingen nul en/of cijfer na het decimaalteken bepaalt het aantal cijfers dat na het decimaalteken wordt weergegeven. Waarden worden zo nodig afgerond. |
. (punt) |
Decimaalteken: het meest linkse '.'
teken in de notatietekenreeks bepaalt de locatie van het decimaalteken in de opgemaakte waarde; eventuele extra '.' tekens worden genegeerd. De System.Globalization.NumberFormatInfo.NumberDecimalSeparator eigenschap bepaalt het symbool dat wordt gebruikt als het decimaalteken. |
, (komma) |
Groepsscheidingsteken en nummerschalen: het teken ',' dient twee doeleinden. Als de aangepaste notatie dit teken bevat tussen twee tijdelijke aanduidingen nul of cijfer (0 of #) en links van het decimaalteken als deze aanwezig is, worden in de uitvoer groepsscheidingstekens ingevoegd tussen elke groep cijfers links van het decimaalteken. De Als de notatietekenreeks direct links van het decimaalteken een of meer tekens bevat, wordt het getal geschaald. De schaalfactor wordt bepaald door het aantal groepsscheidingstekens direct links van het decimaalteken. Als er x-tekens zijn, wordt de waarde gedeeld door 1000X voordat deze wordt opgemaakt. De notatietekenreeks '0' deelt bijvoorbeeld een waarde met één miljoen. Houd er rekening mee dat de aanwezigheid van het teken ',' om aan te geven dat het schalen geen groepsscheidingstekens in de uitvoertekenreeks invoegt. Als u dus een getal wilt schalen met 1 miljoen en groepsscheidingstekens wilt invoegen, gebruikt u een aangepaste notatie die vergelijkbaar is met #,##0,,. |
% (percentage) |
Tijdelijke aanduiding percentage: De aanwezigheid van een %-teken in een aangepaste notatie zorgt ervoor dat een getal wordt vermenigvuldigd met 100 voordat het wordt opgemaakt. Het procentsymbool wordt ingevoegd in de uitvoertekenreeks op de locatie waar %wordt weergegeven in de notatietekenreeks. De System.Globalization.NumberFormatInfo.PercentSymbol eigenschap bepaalt het procentsymbool. |
|
Technische indeling: Als een van de tekenreeksen 'E', 'E+', 'E-', 'e', 'e+' of 'e-' aanwezig is in een aangepaste indeling en onmiddellijk wordt gevolgd door ten minste één '0'-teken, wordt de waarde opgemaakt met behulp van wetenschappelijke notatie. Het aantal '0' tekens na het exponentvoorvoegsel (E of e) bepaalt het minimumaantal cijfers in de exponent. De notatie 'E+' en 'e+' geven aan dat een positief of negatief getalsymbool altijd voorafgaat aan de exponent. De notatie 'E', 'E-', 'e' of 'e-' geeft aan dat een negatief getalsymbool voorafgaat aan negatieve exponenten; er wordt geen symbool voorafgegaan aan positieve exponenten. Het positieve getalsymbool wordt door de System.Globalization.NumberFormatInfo.PositiveSign eigenschap opgegeven. Het negatieve getalsymbool wordt door de System.Globalization.NumberFormatInfo.NegativeSign eigenschap opgegeven. |
\ (backslash) |
Escape-teken: In sommige talen, zoals C#, zorgt het backslash-teken ervoor dat het volgende teken in de aangepaste indeling wordt geïnterpreteerd als een escape-reeks. Deze wordt gebruikt met C-taalopmaakreeksen, zoals '\n' (newline). In sommige talen moet het escapeteken zelf worden voorafgegaan door een escape-teken wanneer het als letterlijke teken wordt gebruikt. Anders interpreteert een compiler het teken als een escape-sequentie. Dit escapeteken hoeft niet te worden ondersteund in alle programmeertalen. |
|
Letterlijke tekenreeks: tekens tussen enkele of dubbele aanhalingstekens worden letterlijk gekopieerd naar de uitvoertekenreeks en hebben geen invloed op de opmaak. |
; (puntkomma) |
Sectiescheidingsteken: het teken ';' wordt gebruikt om secties te scheiden voor positieve, negatieve en nul getallen in de notatietekenreeks. (Deze functie wordt hieronder uitgebreid beschreven.) |
| Overige | Alle andere tekens: alle andere tekens worden opgeslagen in de uitvoertekenreeks als letterlijke waarden op de positie waarin ze worden weergegeven. |
Houd er rekening mee dat voor tekenreeksen met vaste punten (tekenreeksen die geen 'E0', 'E+0', 'E-0', 'e+0' of 'e-0' bevatten), getallen worden afgerond op zoveel decimalen als er tijdelijke aanduidingen nul of cijfers rechts van het decimaalteken zijn. Als de aangepaste notatie geen decimaalteken bevat, wordt het getal afgerond op het dichtstbijzijnde gehele getal. Als het getal meer cijfers heeft dan er tijdelijke aanduidingen voor nul of cijfers links van het decimaalteken zijn, worden de extra cijfers direct vóór de eerste tijdelijke aanduiding nul of cijfer gekopieerd naar de uitvoertekenreeks.
Een aangepaste indeling kan maximaal drie secties bevatten, gescheiden door sectiescheidingstekens, om verschillende opmaak op te geven voor positieve, negatieve en nulwaarden. De secties worden als volgt geïnterpreteerd:
Eén sectie: De aangepaste notatie is van toepassing op alle waarden (positief, negatief en nul). Negatieve waarden bevatten een negatief teken.
Twee secties: De eerste sectie is van toepassing op positieve waarden en nullen, en de tweede sectie is van toepassing op negatieve waarden. Als de waarde die moet worden opgemaakt negatief is, maar nul wordt na afronding volgens de notatie in de tweede sectie, wordt de resulterende nul opgemaakt volgens de eerste sectie. Negatieve waarden bevatten geen negatief teken om volledige controle over weergaven van negatieve waarden toe te staan. Een negatief kan bijvoorbeeld tussen haakjes worden weergegeven met behulp van een aangepaste indeling die vergelijkbaar is met '###.######;; (####.####)’.
Drie secties: De eerste sectie is van toepassing op positieve waarden, de tweede sectie is van toepassing op negatieve waarden en de derde sectie is van toepassing op nullen. De tweede sectie kan leeg zijn (er wordt niets weergegeven tussen de puntkomma's), in welk geval de eerste sectie van toepassing is op alle niet-nulwaarden en negatieve waarden een negatief teken bevatten. Als het getal dat moet worden opgemaakt niet-nul is, maar nul wordt na afronding volgens de notatie in de eerste of tweede sectie, wordt de resulterende nul opgemaakt volgens de derde sectie.
De System.Enum en System.DateTime typen ondersteunen ook het gebruik van opmaakaanduidingen om tekenreeksweergaven van waarden op te maken. De betekenis van een specifieke notatieaanduiding varieert afhankelijk van het soort gegevens (numeriek, datum/tijd, opsomming) dat wordt opgemaakt. Zie System.Enum en System.Globalization.DateTimeFormatInfo voor een uitgebreide lijst van de indelingsaanduidingen die door elk type worden ondersteund.
Afkortingen van C.5-bibliotheektypen
In deze specificatie worden naar de volgende bibliotheektypen verwezen. De volledige namen van deze typen, inclusief de algemene naamruimtescheidingsteken, worden hieronder vermeld. In deze specificatie worden deze typen weergegeven als de volledig gekwalificeerde naam; met de algemene naamruimtescheidingsteken weggelaten; of als een eenvoudige niet-gekwalificeerde typenaam, waarbij ook de naamruimte wordt weggelaten. Het type ICollection<T>, bijvoorbeeld, wanneer in deze specificatie wordt gebruikt, betekent altijd het type global::System.Collections.Generic.ICollection<T>.
global::System.Actionglobal::System.ArgumentExceptionglobal::System.ArithmeticExceptionglobal::System.Arrayglobal::System.ArrayTypeMisMatchExceptionglobal::System.Attributeglobal::System.AttributeTargetsglobal::System.AttributeUsageAttributeglobal::System.Booleanglobal::System.Byteglobal::System.Charglobal::System.Collections.Generic.ICollection<T>global::System.Collections.Generic.IEnumerable<T>global::System.Collections.Generic.IEnumerator<T>global::System.Collections.Generic.IList<T>global::System.Collections.Generic.IReadonlyCollection<out T>global::System.Collections.Generic.IReadOnlyList<out T>global::System.Collections.ICollectionglobal::System.Collections.IEnumerableglobal::System.Collections.IListglobal::System.Collections.IEnumeratorglobal::System.Decimalglobal::System.Delegateglobal::System.Diagnostics.ConditionalAttributeglobal::System.DivideByZeroExceptionglobal::System.Doubleglobal::System.Enumglobal::System.Exceptionglobal::System.GCglobal::System.ICollectionglobal::System.IDisposableglobal::System.IEnumerableglobal::System.IEnumerable<out T>global::System.IListglobal::System.IndexOutOfRangeExceptionglobal::System.Int16global::System.Int32global::System.Int64global::System.IntPtrglobal::System.InvalidCastExceptionglobal::System.InvalidOperationExceptionglobal::System.Linq.Expressions.Expression<TDelegate>global::System.MemberInfoglobal::System.NotSupportedExceptionglobal::System.Nullable<T>global::System.NullReferenceExceptionglobal::System.Objectglobal::System.ObsoleteAttributeglobal::System.OutOfMemoryExceptionglobal::System.OverflowExceptionglobal::System.Runtime.CompilerServices.CallerFileAttributeglobal::System.Runtime.CompilerServices.CallerLineNumberAttributeglobal::System.Runtime.CompilerServices.CallerMemberNameAttributeglobal::System.Runtime.CompilerServices.ICriticalNotifyCompletionglobal::System.Runtime.CompilerServices.IndexerNameAttributeglobal::System.Runtime.CompilerServices.INotifyCompletionglobal::System.Runtime.CompilerServices.TaskAwaiterglobal::System.Runtime.CompilerServices.TaskAwaiter<T>global::System.SByteglobal::System.Singleglobal::System.StackOverflowExceptionglobal::System.Stringglobal::System.SystemExceptionglobal::System.Threading.Monitorglobal::System.Threading.Tasks.Taskglobal::System.Threading.Tasks.Task<TResult>global::System.Typeglobal::System.TypeInitializationExceptionglobal::System.UInt16global::System.UInt32global::System.UInt64global::System.UIntPtrglobal::System.ValueType
Einde van informatieve tekst.
ECMA C# draft specification