Hinweis
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, sich anzumelden oder das Verzeichnis zu wechseln.
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, das Verzeichnis zu wechseln.
C.1 General
Eine konforme C#-Implementierung muss eine Mindestmenge von Typen mit spezifischer Semantik bereitstellen. Diese Typen und ihre Member werden hier in alphabetischer Reihenfolge nach Namespace und Typ aufgeführt. Eine formale Definition der typen und deren Member, die in (§C.2) identifiziert wurden, finden Sie unter ISO/IEC 23271:2012 Common Language Infrastructure (CLI), Partition IV; Base Class Library (BCL), Extended Numerics Library, and Extended Array Library, which are included by reference in this specification. Eine Liste der Typen und deren Member, die über die in §C.2 angegebenen Elemente hinausgehen, finden Sie unter §C.3.
Hinweis: Die Übernahme einer Teilmenge der CLI-Bibliotheks-API erstellt keine Abhängigkeit von der CLI selbst; Eine konforme Implementierung muss nicht auf der CLI oder der Zielimplementierung erstellt werden.
Dieser Text ist informativ.
Die Standardbibliothek soll die Mindestmenge von Typen und Membern sein, die von einer konformen C#-Implementierung benötigt werden. Daher enthält sie nur die Member, die explizit von der C#-Sprachspezifikation benötigt werden.
Es wird erwartet, dass eine konforme C#-Implementierung eine wesentlich umfangreichere Bibliothek bereitstellen wird, mit der nützliche Programme geschrieben werden können. Beispielsweise kann eine konforme Implementierung diese Bibliothek um
- Hinzufügen von Namespaces.
- Hinzufügen von Typen.
- Hinzufügen von Membern zu Nicht-Schnittstellentypen.
- Hinzufügen von dazwischen liegenden Basisklassen oder Schnittstellen
- Durch Struktur- und Klassentypen werden zusätzliche Schnittstellen implementiert.
- Hinzufügen von Attributen (außer dem
ConditionalAttribute) zu vorhandenen Typen und Membern.
Ende des informativen Texts.
C.2 Standardbibliothekstypen, die in ISO/IEC 23271 definiert sind
Hinweis: Einige
structder folgenden Typen weisen denreadonlyModifizierer auf. Dieser Modifizierer war nicht verfügbar, als ISO/IEC 23271 veröffentlicht wurde, aber für die Einhaltung der Implementierungen dieser Spezifikation erforderlich ist. Endnote
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-Standardbibliothekstypen, die in ISO/IEC 23271 nicht definiert sind
Die folgenden Typen, einschließlich der aufgeführten Mitglieder, müssen in einer konformen Standardbibliothek definiert werden. (Diese Typen können in einer zukünftigen Ausgabe von ISO/IEC 23271 definiert werden.) Es wird erwartet, dass viele dieser Typen mehr Mitglieder zur Verfügung haben, als aufgeführt sind.
Eine konforme Implementierung kann als Erweiterungsmethoden bereitgestellt Task.GetAwaiter() werden Task<TResult>.GetAwaiter() .
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();
}
}
C.4-Formatspezifikationen
Die Bedeutung der Formate, die in interpolierten Zeichenfolgenausdrücken (§12.8.3) verwendet werden, werden in ISO/IEC 23271:2012 definiert. Aus Gründen der Einfachheit wird der folgende Text aus der Beschreibung kopiert System.IFormattable.
Dieser Text ist informativ.
Ein Format ist eine Zeichenfolge, die das Erscheinungsbild eines Objekts beschreibt, wenn es in eine Zeichenfolge konvertiert wird. Standard- oder benutzerdefinierte Formate können verwendet werden. Ein Standardformat verwendet das Format Axx, wobei A ein einzelnes alphabetisches Zeichen ist, das als Formatbezeichner bezeichnet wird, und xx ist eine ganze Zahl zwischen Null und 99 einschließlich, die als Genauigkeitsbezeichner bezeichnet wird. Der Formatbezeichner steuert den Formatierungstyp, der auf den Wert angewendet wird, der als Zeichenfolge dargestellt wird. Der Genauigkeitsbezeichner steuert ggf. die Anzahl der signifikanten Ziffern oder Dezimalstellen in der Zeichenfolge.
Hinweis: Eine Liste der Standardformatbezeichner finden Sie in der folgenden Tabelle. Beachten Sie, dass ein bestimmter Datentyp, z
System.Int32. B., einen oder mehrere der Standardformatbezeichner möglicherweise nicht unterstützt. Endnote
Hinweis: Wenn ein Format Symbole enthält, die je nach Kultur variieren, z. B. das Währungssymbol, das in den Formaten "C" und "c" enthalten ist, stellt ein Formatierungsobjekt die tatsächlichen Zeichen bereit, die in der Zeichenfolgendarstellung verwendet werden. Eine Methode kann einen Parameter enthalten, um ein
System.IFormatProviderObjekt zu übergeben, das ein Formatierungsobjekt bereitstellt, oder die Methode verwendet möglicherweise das Standardformatierungsobjekt, das die Symboldefinitionen für die aktuelle Kultur enthält. Die aktuelle Kultur verwendet in der Regel denselben Satz von Symbolen, die standardmäßig systemweit verwendet werden. In der Basisklassenbibliothek ist das Formatierungsobjekt für vom System bereitgestellte numerische Typen eineSystem.Globalization.NumberFormatInfoInstanz. BeispielsweiseSystem.DateTimewird eineSystem.Globalization.DateTimeFormatInfoverwendet. Endnote
In der folgenden Tabelle werden die Standardformatbezeichner und die zugehörigen Formatierungsobjektmmber beschrieben, die mit numerischen Datentypen in der Basisklassenbibliothek verwendet werden.
| Formatbezeichner | Beschreibung |
|---|---|
|
Währungsformat: Wird für Zeichenfolgen verwendet, die einen Geldwert enthalten.
Wenn der Genauigkeitsbezeichner nicht angegeben wird, |
|
Dezimalformat: (Dieses Format ist nur gültig, wenn es mit integralen Datentypen angegeben wird.) Wird für Zeichenfolgen verwendet, die ganze Zahlen enthalten. Negative Zahlen werden dem von der Der Genauigkeitsbezeichner bestimmt die Mindestanzahl von Ziffern, die in der Zeichenfolge angezeigt werden. Wenn für die angegebene Genauigkeit mehr Ziffern erforderlich sind, als der Wert enthält, wird die Zeichenfolge mit Nullen links gepolstert. Wenn der Genauigkeitsbezeichner weniger Ziffern als im Wert angibt, wird der Genauigkeitsbezeichner ignoriert. |
|
Scientific (Engineering) Format: Wird für Zeichenfolgen in einer der folgenden Formen verwendet: ...m.dddddE+xxx ...m.dddddddDE-xxx ...m.dddddde+xxx ...m.ddddd e-xxx Das Symbol für negative Zahlen ('-') wird nur angezeigt, wenn der Wert negativ ist und von der Genau eine Nicht-Null-Dezimalziffer (m) steht vor dem Dezimaltrennzeichen ('.'), das von der Der Genauigkeitsbezeichner bestimmt die Anzahl der Dezimalstellen (dddddd) in der Zeichenfolge. Wenn der Genauigkeitsbezeichner ausgelassen wird, werden sechs Dezimalstellen in der Zeichenfolge enthalten. Der Exponent (+/-xxx) besteht aus einem positiven oder negativen Zahlensymbol gefolgt von mindestens drei Ziffern (xxx). Der Exponent ist bei Bedarf mit Nullen links gepolstert. Der Fall des Formatbezeichners ('E' oder 'e') bestimmt den Fall, der für das Exponentenpräfix (E oder e) in der Zeichenfolge verwendet wird. Die Ergebnisse werden bei Bedarf auf den nächsten darstellbaren Wert gerundet. Das Symbol für positive Zahlen wird von der |
|
Festkommaformat: Wird für Zeichenfolgen in der folgenden Form verwendet: ...m.dd... d Mindestens eine Nicht-Null-Dezimalziffer (m) steht vor dem Dezimaltrennzeichen ('.'), das von der Ein negatives Zahlenzeichen ('-') vorangestellt ist nur, wenn der Wert negativ ist. Dieses Symbol wird von der Der Genauigkeitsbezeichner bestimmt die Anzahl der Dezimalstellen (dd... d) in der Zeichenfolge. Wenn der Genauigkeitsbezeichner nicht angegeben wird, |
|
Allgemeines Format: Die Zeichenfolge wird entweder im Festkommaformat ('F' oder 'f') oder im wissenschaftlichen Format ('E' oder 'e') formatiert. Für integrale Typen: Werte werden mit festem Punktformat formatiert, wenn exponenter< Genauigkeitsbezeichner, wobei exponent der Exponent des Werts im wissenschaftlichen Format ist. Für alle anderen Werte wird das wissenschaftliche Format verwendet. Wenn der Genauigkeitsbezeichner ausgelassen wird, wird eine Standardgenauigkeit gleich der Feldbreite verwendet, die zum Anzeigen des Maximalwerts für den Datentyp erforderlich ist, was dazu führt, dass der Wert im Festkommaformat formatiert wird. Die Standardgenauigkeiten für integrale Typen sind wie folgt:
Für Single-, Dezimal- und Double-Typen: Werte werden mithilfe des Festkommaformats formatiert, wenn exponent ≥ -4 und exponent< precision specifier, wobei exponent der Exponent des Werts im wissenschaftlichen Format ist. Für alle anderen Werte wird das wissenschaftliche Format verwendet. Die Ergebnisse werden bei Bedarf auf den nächsten darstellbaren Wert gerundet. Wenn der Genauigkeitsbezeichner nicht angegeben wird, werden die folgenden Standardgenauigkeiten verwendet:
Für alle Typen:
|
|
Zahlenformat: Wird für Zeichenfolgen in der folgenden Form verwendet: ...d,ddd,ddd.dd... d Die Darstellung negativer Werte wird durch die Mindestens eine Nicht-Null-Dezimalziffer (d) steht vor dem Dezimaltrennzeichen ('.'), das von der Der Genauigkeitsbezeichner bestimmt die Anzahl der Dezimalstellen (dd... d) Wenn der Genauigkeitsbezeichner nicht angegeben wird, |
|
Prozentformat: Wird für Zeichenfolgen verwendet, die einen Prozentsatz enthalten. Die
Wenn keine Genauigkeit angegeben wird, wird die Anzahl der Dezimalstellen im Ergebnis durch Das Ergebnis wird um 100 skaliert (99 wird zu 99%). |
|
Roundtrip-Format: (Dieses Format ist nur gültig, wenn mit System.Double oder System.Single.) Wird verwendet, um sicherzustellen, dass die Genauigkeit der Zeichenfolgendarstellung eines Gleitkommawerts so ist, dass die Analyse der Zeichenfolge nicht zu einem Genauigkeitsverlust im Vergleich zum ursprünglichen Wert führt. Wenn die maximale Genauigkeit des Datentyps (7 für und 15 für System.SingleSystem.Double) zu einem Genauigkeitsverlust führen würde, wird die Genauigkeit um zwei Dezimalstellen erhöht. Wenn ein Genauigkeitsbezeichner mit diesem Formatbezeichner bereitgestellt wird, wird er ignoriert. Dieses Format ist andernfalls identisch mit dem Festkommaformat. |
|
Hexadezimalformat: (Dieses Format ist nur gültig, wenn es mit integralen Datentypen angegeben wird.) Wird für Zeichenfolgendarstellungen von Zahlen in Base 16 verwendet. Die Genauigkeit bestimmt die Mindestanzahl von Ziffern in der Zeichenfolge. Wenn die Genauigkeit mehr Ziffern angibt, als die Zahl enthält, wird die Zahl mit Nullen aufgefüllt. Die Groß- oder Kleinschreibung des Formatbezeichners ('X' oder 'x') bestimmt, ob Groß- oder Kleinbuchstaben in der Hexadezimaldarstellung verwendet werden. |
Wenn der numerische Wert ein System.Single oder System.Double mit einem Wert von NaN, PositiveInfinityoder , oder NegativeInfinity, der Formatbezeichner wird ignoriert, und eine der folgenden wird zurückgegeben: System.Globalization.NumberFormatInfo.NaNSymbol, System.Globalization.NumberFormatInfo.PositiveInfinitySymbol, oder System.Globalization.NumberFormatInfo.NegativeInfinitySymbol.
Ein benutzerdefiniertes Format ist eine beliebige Zeichenfolge, die sich nicht in Form einer oben beschriebenen Standardformatzeichenfolge (Axx) befindet. In der folgenden Tabelle werden die Zeichen beschrieben, die beim Erstellen von benutzerdefinierten Formaten verwendet werden.
| Formatbezeichner | Beschreibung |
|---|---|
0 (Null) |
Nullplatzhalter: Wenn der formatierte Wert eine Ziffer an der Position aufweist, an der ein "0" im benutzerdefinierten Format angezeigt wird, wird diese Ziffer in die Ausgabezeichenfolge kopiert. Andernfalls wird an dieser Position in der Ausgabezeichenfolge eine Null gespeichert. Die Position der äußerst linken "0" vor dem Dezimaltrennzeichen und dem rechtssten "0" nach dem Dezimaltrennzeichen bestimmen den Bereich der Ziffern, die immer in der Ausgabezeichenfolge vorhanden sind. Die Anzahl der Platzhalter null und/oder ziffern nach dem Dezimaltrennzeichen bestimmt die Anzahl der Ziffern, die nach dem Dezimaltrennzeichen angezeigt werden. Werte werden nach Bedarf gerundet. |
# |
Ziffernplatzhalter: Wenn der formatierte Wert eine Ziffer an der Position aufweist, an der ein "#" im benutzerdefinierten Format angezeigt wird, wird diese Ziffer in die Ausgabezeichenfolge kopiert. Andernfalls wird nichts an dieser Position in der Ausgabezeichenfolge gespeichert. Beachten Sie, dass dieser Bezeichner niemals das Zeichen "0" speichert, wenn es sich nicht um eine signifikante Ziffer handelt, auch wenn "0" die einzige Ziffer in der Zeichenfolge ist. (Es wird das Zeichen "0" in der Ausgabezeichenfolge angezeigt, wenn es sich um eine signifikante Ziffer handelt.) Die Anzahl der Platzhalter null und/oder ziffern nach dem Dezimaltrennzeichen bestimmt die Anzahl der Ziffern, die nach dem Dezimaltrennzeichen angezeigt werden. Werte werden nach Bedarf gerundet. |
. (Zeitraum) |
Dezimaltrennzeichen: Die links am meisten '.'
Zeichen in der Formatzeichenfolge bestimmt die Position des Dezimaltrennzeichens im formatierten Wert; alle zusätzlichen '.' Zeichen werden ignoriert. Die System.Globalization.NumberFormatInfo.NumberDecimalSeparator Eigenschaft bestimmt das Symbol, das als Dezimaltrennzeichen verwendet wird. |
, (Komma) |
Gruppentrennzeichen und Zahlenskalierung: Das Zeichen "," dient zwei Zwecken. Wenn das benutzerdefinierte Format dieses Zeichen zwischen zwei Null- oder Ziffernplatzhaltern (0 oder #) und links neben dem Dezimaltrennzeichen enthält, falls vorhanden, enthält die Ausgabe Gruppentrennzeichen, die zwischen den einzelnen Zifferngruppen links neben dem Dezimaltrennzeichen eingefügt werden. Die Wenn die Formatzeichenfolge ein oder mehrere Zeichen "," unmittelbar links neben dem Dezimaltrennzeichen enthält, wird die Zahl skaliert. Der Skalierungsfaktor wird durch die Anzahl der Gruppentrennzeichen unmittelbar links neben dem Dezimaltrennzeichen bestimmt. Wenn x Zeichen vorhanden sind, wird der Wert durch 1000X geteilt, bevor er formatiert wird. Beispielsweise dividiert die Formatzeichenfolge "0," einen Wert um eine Million. Beachten Sie, dass das Vorhandensein des Zeichens "," zum Angeben der Skalierung keine Gruppentrennzeichen in die Ausgabezeichenfolge einfügt. Um eine Zahl um 1 Million zu skalieren und Gruppentrennzeichen einzufügen, verwenden Sie ein benutzerdefiniertes Format wie "#,##0,". |
% (Prozent) |
Prozentplatzhalter: Das Vorhandensein eines "%"-Zeichens in einem benutzerdefinierten Format bewirkt, dass eine Zahl mit 100 multipliziert wird, bevor sie formatiert wird. Das Prozentsymbol wird in die Ausgabezeichenfolge an der Stelle eingefügt, an der das "%" in der Formatzeichenfolge angezeigt wird. Die System.Globalization.NumberFormatInfo.PercentSymbol Eigenschaft bestimmt das Prozentsymbol. |
|
Engineering-Format: Wenn eine der Zeichenfolgen 'E', 'E+', 'E-', 'e', 'e+' oder 'e-' in einem benutzerdefinierten Format vorhanden ist und unmittelbar mit mindestens einem '0'-Zeichen gefolgt wird, wird der Wert mithilfe der wissenschaftlichen Schreibweise formatiert. Die Anzahl von "0" Zeichen nach dem Exponentenpräfix (E oder e) bestimmt die Mindestanzahl von Ziffern im Exponenten. Die Formate "E+" und "e+" geben an, dass dem Exponenten immer ein Symbol für positive oder negative Zahlen vorangestellt ist. Die Formate "E", "E-", "e" oder "e-" deuten darauf hin, dass ein negatives Zahlensymbol vor negativen Exponenten steht; kein Symbol steht vor positiven Exponenten. Das Symbol für positive Zahlen wird von der System.Globalization.NumberFormatInfo.PositiveSign Eigenschaft angegeben. Das Symbol für negative Zahlen wird von der System.Globalization.NumberFormatInfo.NegativeSign Eigenschaft angegeben. |
\ (umgekehrter Schrägstrich) |
Escapezeichen: In einigen Sprachen, z. B. C#, bewirkt das umgekehrte Schrägstrich, dass das nächste Zeichen im benutzerdefinierten Format als Escapesequenz interpretiert wird. Sie wird mit C-Sprachformatierungssequenzen verwendet, z. B. "\n" (Neue Zeile). In einigen Sprachen muss dem Escapezeichen selbst ein Escapezeichen vorangestellt werden, wenn es als Literal verwendet wird. Andernfalls interpretiert ein Compiler das Zeichen als Escapesequenz. Dieses Escapezeichen muss in allen Programmiersprachen nicht unterstützt werden. |
|
Literale Zeichenfolge: Zeichen, die in einfache oder doppelte Anführungszeichen eingeschlossen sind, werden buchstäblich in die Ausgabezeichenfolge kopiert und wirken sich nicht auf die Formatierung aus. |
; (Semikolon) |
Abschnittstrennzeichen: Das Zeichen ";" wird verwendet, um Abschnitte für positive, negative und null Zahlen in der Formatzeichenfolge zu trennen. (Dieses Feature wird unten ausführlich beschrieben.) |
| Andere | Alle anderen Zeichen: Alle anderen Zeichen werden in der Ausgabezeichenfolge als Literale an der Position gespeichert, an der sie angezeigt werden. |
Beachten Sie, dass Zahlen für Zeichenfolgen mit festem Punktformat (Zeichenfolgen, die keine "E0", "E+0", "E-0", "e+0" oder "e-0" enthalten, auf so viele Dezimalstellen gerundet werden, wie Null- oder Ziffernplatzhalter rechts neben dem Dezimaltrennzeichen vorhanden sind. Wenn das benutzerdefinierte Format kein Dezimaltrennzeichen enthält, wird die Zahl auf die nächste ganze Zahl gerundet. Wenn die Zahl mehr Ziffern enthält, als Null- oder Ziffernplatzhalter links neben dem Dezimaltrennzeichen vorhanden sind, werden die zusätzlichen Ziffern unmittelbar vor dem ersten Platzhalter Null oder Ziffern in die Ausgabezeichenfolge kopiert.
Ein benutzerdefiniertes Format kann bis zu drei Abschnitte enthalten, die durch Abschnittstrennzeichen getrennt sind, um unterschiedliche Formatierungen für positive, negative und Nullwerte anzugeben. Die Abschnitte werden wie folgt interpretiert:
Ein Abschnitt: Das benutzerdefinierte Format gilt für alle Werte (positiv, negativ und null). Negative Werte enthalten ein negatives Vorzeichen.
Zwei Abschnitte: Der erste Abschnitt gilt für positive Werte und Nullen, und der zweite Abschnitt gilt für negative Werte. Wenn der zu formatierende Wert negativ ist, aber nach dem Runden gemäß dem Format im zweiten Abschnitt null wird, wird die resultierende Null gemäß dem ersten Abschnitt formatiert. Negative Werte enthalten kein negatives Zeichen, um die vollständige Kontrolle über Darstellungen negativer Werte zu ermöglichen. Beispielsweise kann eine Negative in Klammern mit einem benutzerdefinierten Format wie "####.### dargestellt werden; (####.####)’.
Drei Abschnitte: Der erste Abschnitt gilt für positive Werte, der zweite Abschnitt gilt für negative Werte, und der dritte Abschnitt gilt für Nullen. Der zweite Abschnitt kann leer sein (zwischen den Semikolons wird nichts angezeigt), in diesem Fall gilt der erste Abschnitt für alle Nichtzerowerte, und negative Werte enthalten ein negatives Vorzeichen. Wenn die zu formatierende Zahl ungleich Null ist, aber nach dem Runden nach dem Format im ersten oder zweiten Abschnitt null wird, wird die resultierende Null gemäß dem dritten Abschnitt formatiert.
Die System.Enum Typen System.DateTime unterstützen auch die Verwendung von Formatbezeichnern zum Formatieren von Zeichenfolgendarstellungen von Werten. Die Bedeutung eines bestimmten Formatbezeichners variiert je nach Art von Daten (numerisch, Datum/Uhrzeit, Aufzählung), die formatiert wird. Eine umfassende Liste der Formatbezeichner, die von jedem Typ unterstützt werden, finden Sie System.Enum unter.System.Globalization.DateTimeFormatInfo
Abkürzungen des C.5-Bibliothekstyps
Auf die folgenden Bibliothekstypen wird in dieser Spezifikation verwiesen. Die vollständigen Namen dieser Typen, einschließlich des globalen Namespacequalifizierers, sind unten aufgeführt. In dieser Spezifikation werden diese Typen entweder als vollqualifizierter Name angezeigt; ohne Angabe des globalen Namespacequalifizierers; oder als einfacher unqualifizierter Typname, wobei auch der Namespace ausgelassen wird. Beispielsweise bedeutet der Typ ICollection<T>, wenn er in dieser Spezifikation verwendet wird, immer den Typ 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>
Ende des informativen Texts.
Zusammenarbeit auf GitHub
Die Quelle für diesen Inhalt finden Sie auf GitHub, wo Sie auch Issues und Pull Requests erstellen und überprüfen können. Weitere Informationen finden Sie in unserem Leitfaden für Mitwirkende.
ECMA C# draft specification