Biblioteka standardowa załącznika C
C.1 Ogólne
Zgodna implementacja języka C# zapewnia minimalny zestaw typów o określonych semantyce. Te typy i ich składowe są wymienione tutaj w kolejności alfabetycznej według przestrzeni nazw i typu. Aby uzyskać formalną definicję tych typów i ich elementów członkowskich, zapoznaj się z normą ISO/IEC 23271:2012 Common Language Infrastructure (CLI), Partition IV; Biblioteka klas bazowych (BCL), rozszerzona biblioteka liczbowa i rozszerzona biblioteka tablic, która jest dołączona przez odwołanie do tej specyfikacji.
Ten tekst jest informacyjny.
Biblioteka standardowa ma być minimalnym zestawem typów i elementów członkowskich wymaganych przez zgodną implementację języka C#. W związku z tym zawiera tylko te elementy członkowskie, które są jawnie wymagane przez specyfikację języka C#.
Oczekuje się, że zgodna implementacja języka C# będzie dostarczać znacznie bardziej rozbudowaną bibliotekę, która umożliwia pisanie przydatnych programów. Na przykład zgodna implementacja może rozszerzyć tę bibliotekę przez
- Dodawanie przestrzeni nazw.
- Dodawanie typów.
- Dodawanie elementów członkowskich do typów innych niż interfejsy.
- Dodawanie interweniujących klas bazowych lub interfejsów.
- Posiadanie typów struktur i klas implementuje dodatkowe interfejsy.
- Dodawanie atrybutów (innych niż
ConditionalAttribute) do istniejących typów i elementów członkowskich.
Koniec tekstu informacyjnego.
Standardowe typy bibliotek C.2 zdefiniowane w normie ISO/IEC 23271
Uwaga: niektóre
structtypy poniżej mająreadonlymodyfikator. Ten modyfikator nie był dostępny, gdy wydano normę ISO/IEC 23271, ale jest wymagana do przestrzegania implementacji tej specyfikacji. notatka końcowa
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);
}
}
Standardowe typy bibliotek C.3 niezdefiniowane w normie ISO/IEC 23271
Następujące typy, w tym wymienione elementy członkowskie, są zdefiniowane w zgodnej standardowej bibliotece. (Te typy mogą być zdefiniowane w przyszłej edycji ISO/IEC 23271). Oczekuje się, że wiele z tych typów będzie mieć więcej dostępnych elementów członkowskich niż są wymienione.
Zgodna implementacja może udostępniać Task.GetAwaiter() metody rozszerzenia i Task<TResult>.GetAwaiter() jako metody rozszerzenia.
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();
}
}
Specyfikacje formatu C.4
Znaczenie formatów, które są używane w wyrażeniach ciągów interpolowanych (§12.8.3), są zdefiniowane w normie ISO/IEC 23271:2012. Dla wygody poniższy tekst jest kopiowany z opisu System.IFormattable.
Ten tekst jest informacyjny.
Format to ciąg opisujący wygląd obiektu podczas konwersji na ciąg. Można użyć formatów standardowych lub niestandardowych. Format standardowy przyjmuje formę Axx, gdzie A jest pojedynczym znakiem alfabetycznym nazywanym specyfikatorem formatu, a xx jest liczbą całkowitą z zakresu od zera do 99 włącznie, nazywaną specyfikatorem dokładności. Specyfikator formatu steruje typem formatowania zastosowanego do wartości reprezentowanej jako ciąg. Specyfikator dokładności określa liczbę cyfr znaczących lub miejsc dziesiętnych w ciągu, jeśli ma to zastosowanie.
Uwaga: Aby uzyskać listę specyfikatorów formatu standardowego, zobacz poniższą tabelę. Należy pamiętać, że dany typ danych, taki jak
System.Int32, może nie obsługiwać co najmniej jednego specyfikatora formatu standardowego. notatka końcowa
Uwaga: jeśli format zawiera symbole, które różnią się w zależności od kultury, takie jak currencysymbol zawarte w formatach "C" i "c", obiekt formatowania dostarcza rzeczywiste znaki używane w reprezentacji ciągu. Metoda może zawierać parametr umożliwiający przekazanie
System.IFormatProviderobiektu, który dostarcza obiekt formatowania, lub metoda może użyć domyślnego obiektu formatowania, który zawiera definicje symboli dla bieżącej kultury. Bieżąca kultura domyślnie używa tego samego zestawu symboli używanych w całym systemie. W bibliotece klas bazowych obiekt formatowania dla typów liczbowych dostarczanych przez system jest wystąpieniemSystem.Globalization.NumberFormatInfo. NaSystem.DateTimeprzykład używany jest element aSystem.Globalization.DateTimeFormatInfo. notatka końcowa
W poniższej tabeli opisano standardowe specyfikatory formatu i skojarzone elementy członkowskie obiektów formatowania, które są używane z typami danych liczbowych w bibliotece klas bazowych.
| Specyfikator formatu | opis |
|---|---|
|
Format waluty: używany w przypadku ciągów zawierających wartość pieniężną. Elementy
Jeśli specyfikator dokładności zostanie pominięty, |
|
Format dziesiętny: (Ten format jest prawidłowy tylko wtedy, gdy jest określony z typami danych całkowitych). Służy do ciągów zawierających wartości całkowite. Liczby ujemne są poprzedzone symbolem liczby ujemnej Specyfikator dokładności określa minimalną liczbę cyfr wyświetlanych w ciągu. Jeśli określona precyzja wymaga większej liczby cyfr, niż zawiera wartość, ciąg jest dopełniany zerami. Jeśli specyfikator dokładności określa mniej cyfr niż w wartości, specyfikator dokładności jest ignorowany. |
|
Format naukowy (inżynieryjny): używany w przypadku ciągów w jednej z następujących form: [-]m.ddddddDE+xxx [-]m.ddddddDE-xxx [-]m.dddddde+xxx [-]m.dddddde-xxx Symbol liczby ujemnej ('-') jest wyświetlany tylko wtedy, gdy wartość jest ujemna Dokładnie jedna cyfra niezerowa (m) poprzedza separator dziesiętny ('.'), który jest dostarczany przez Specyfikator dokładności określa liczbę miejsc dziesiętnych (dddddd) w ciągu. Jeśli specyfikator dokładności zostanie pominięty, w ciągu znajduje się sześć miejsc dziesiętnych. Wykładnik (+/-xxx) składa się z symbolu liczby dodatniej lub ujemnej, po którym następuje co najmniej trzy cyfry (xxx). Wykładnik jest pozostawiony zerami, jeśli jest to konieczne. Przypadek specyfikatora formatu ("E" lub "e") określa przypadek używany dla prefiksu wykładnika (E lub e) w ciągu. Wyniki są zaokrąglane do najbliższej wartości możliwej do reprezentowania w razie potrzeby. Symbol liczby dodatniej |
|
Format stałego punktu: używany dla ciągów w następującym formularzu: [-]m.dd... d Co najmniej jedna cyfra dziesiętna (m) poprzedza separator dziesiętny ('.'), który jest dostarczany przez Znak symbolu cyfry ujemnej ('-') poprzedza tylko wtedy, gdy wartość jest ujemna. Ten symbol jest dostarczany przez Specyfikator dokładności określa liczbę miejsc dziesiętnych (dd... d) w ciągu. Jeśli specyfikator dokładności zostanie pominięty, |
|
Format ogólny: ciąg jest formatowany w formacie o stałym punkcie ('F' lub 'f') albo w formacie naukowym ('E' lub 'e'). W przypadku typów całkowitych: Wartości są formatowane przy użyciu formatu stałego punktu, jeśli specyfikator dokładności wykładniczej< , gdzie wykładnik jest wykładnikiem wartości w formacie naukowym. Dla wszystkich innych wartości używany jest format naukowy. Jeśli specyfikator dokładności zostanie pominięty, zostanie użyta domyślna precyzja równa szerokości pola wymaganej do wyświetlenia maksymalnej wartości dla typu danych, co powoduje sformatowanie wartości w formacie stałoprzecinkowym. Domyślne precyzje dla typów całkowitych są następujące:
W przypadku typów pojedynczych, dziesiętnych i podwójnych: Wartości są formatowane przy użyciu formatu stałego punktu, jeśli wykładnik ≥ -4 i specyfikator dokładności wykładniczej< , gdzie wykładnik jest wykładnikiem wartości w formacie naukowym. Dla wszystkich innych wartości używany jest format naukowy. Wyniki są zaokrąglane do najbliższej wartości możliwej do reprezentowania w razie potrzeby. Jeśli specyfikator dokładności zostanie pominięty, zostaną użyte następujące domyślne precyzje:
Dla wszystkich typów:
|
|
Format liczbowy: używany dla ciągów w następującym formularzu: [-]d,ddd,ddd.dd... d Reprezentacja wartości ujemnych jest określana przez Co najmniej jedna cyfra niezerowa (d) poprzedza separator dziesiętny ('.'), który jest dostarczany przez Specyfikator dokładności określa liczbę miejsc dziesiętnych (dd... d). Jeśli specyfikator dokładności zostanie pominięty, |
|
Format procentu: używany dla ciągów zawierających wartość procentową. Elementy
Jeśli nie określono dokładności, liczba miejsc dziesiętnych w wyniku jest określana przez Wynik jest skalowany o 100 (99 staje się 99%). |
|
Format zaokrąglonej podróży: (Ten format jest prawidłowy tylko wtedy, gdy jest określony z System.Double lub System.Single. Służy do zapewnienia, że precyzja reprezentacji ciągu wartości zmiennoprzecinkowej jest taka, że analizowanie ciągu nie powoduje utraty dokładności w porównaniu z oryginalną wartością. Jeśli maksymalna precyzja typu danych (7 dla System.Single, i 15 dla System.Double) spowoduje utratę dokładności, precyzja zostanie zwiększona o dwa miejsca dziesiętne. Jeśli specyfikator dokładności jest dostarczany z tym specyfikatorem formatu, jest ignorowany. Ten format jest w inny sposób identyczny z formatem stałoprzecinkowym. |
|
Format szesnastkowy: (Ten format jest prawidłowy tylko wtedy, gdy jest określony z typami danych całkowitych). Służy do reprezentacji ciągów liczb w bazie 16. Precyzja określa minimalną liczbę cyfr w ciągu. Jeśli precyzja określa więcej cyfr niż liczba zawiera, liczba jest dopełniona zerami po lewej stronie. Przypadek specyfikatora formatu ("X" lub "x") określa, czy wielkie litery lub małe litery są używane w reprezentacji szesnastkowej. |
Jeśli wartość liczbowa jest wartością System.Single lub z wartością System.Double, NaNlub PositiveInfinity, specyfikator formatu jest ignorowany, a jeden z następujących jest zwracany: NegativeInfinity, lub System.Globalization.NumberFormatInfo.NaNSymbolSystem.Globalization.NumberFormatInfo.PositiveInfinitySymbol.System.Globalization.NumberFormatInfo.NegativeInfinitySymbol
Format niestandardowy to dowolny ciąg określony jako format, który nie jest w postaci standardowego ciągu formatu (Axx) opisanego powyżej. W poniższej tabeli opisano znaki używane w konstruowaniu formatów niestandardowych.
| Specyfikator formatu | opis |
|---|---|
0 (zero) |
Symbol zastępczy zero: jeśli sformatowana wartość ma cyfrę w miejscu, w którym w formacie niestandardowym pojawia się cyfra "0", ta cyfra jest kopiowana do ciągu wyjściowego; w przeciwnym razie zero jest przechowywane w tym miejscu w ciągu wyjściowym. Położenie najdalej po lewej stronie "0" przed separatorem dziesiętny i najbardziej po prawej stronie separatora dziesiętnego określają zakres cyfr, które są zawsze obecne w ciągu wyjściowym. Liczba symboli zastępczych Zero i/lub Cyfra po separatorze dziesiętny określa liczbę cyfr wyświetlanych po separatorze dziesiętny. Wartości są zaokrąglane w razie potrzeby. |
# |
Symbol zastępczy cyfry: jeśli sformatowana wartość ma cyfrę w miejscu, w którym w formacie niestandardowym pojawia się znak "#", ta cyfra jest kopiowana do ciągu wyjściowego. W przeciwnym razie nic nie jest przechowywane w tym miejscu w ciągu wyjściowym. Należy pamiętać, że ten specyfikator nigdy nie przechowuje znaku "0", jeśli nie jest cyfrą znaczącą, nawet jeśli "0" jest jedyną cyfrą w ciągu. (Wyświetla znak "0" w ciągu wyjściowym, jeśli jest to cyfra znacząca). Liczba symboli zastępczych Zero i/lub Cyfra po separatorze dziesiętny określa liczbę cyfr wyświetlanych po separatorze dziesiętny. Wartości są zaokrąglane w razie potrzeby. |
. (okres) |
Separator dziesiętny: po lewej stronie "".
znak w ciągu formatu określa lokalizację separatora dziesiętnego w sformatowanej wartości; wszelkie dodatkowe "". znaki są ignorowane. Właściwość System.Globalization.NumberFormatInfo.NumberDecimalSeparator określa symbol używany jako separator dziesiętny. |
, (przecinek) |
Separator grupy i skalowanie liczb: znak "," służy do dwóch celów. Po pierwsze, jeśli format niestandardowy zawiera ten znak między dwoma symbolami zastępczymi Zero lub Cyfra (0 lub #) i z lewej strony separatora dziesiętnego, jeśli taki jest obecny, dane wyjściowe będą miały separatory grup wstawione między każdą grupą cyfr po lewej stronie separatora dziesiętnego. Właściwości Jeśli ciąg formatu zawiera co najmniej jeden znak "", natychmiast po lewej stronie separatora dziesiętnego, liczba zostanie przeskalowana. Współczynnik skalowania jest określany przez liczbę znaków separatora grup natychmiast po lewej stronie separatora dziesiętnego. Jeśli istnieją znaki x, wartość jest podzielona przez 1000X , zanim zostanie sformatowana. Na przykład ciąg formatu "0", podzieli wartość o milion. Należy pamiętać, że obecność znaku "", aby wskazać skalowanie, nie wstawia separatorów grup w ciągu wyjściowym. W związku z tym, aby skalować liczbę o 1 milion i wstawić separatory grup, użyj formatu niestandardowego podobnego do "#,##0,". |
% (procent) |
Symbol zastępczy procentu: obecność znaku "%" w formacie niestandardowym powoduje pomnożenie liczby przez 100 przed sformatowanym znakiem. Symbol procentu jest wstawiany w ciągu wyjściowym w lokalizacji, w której znak "%" pojawia się w ciągu formatu. Właściwość System.Globalization.NumberFormatInfo.PercentSymbol określa symbol procentu. |
|
Format inżynierii: jeśli dowolny z ciągów "E", "E+", "E-", "e", "e+" lub "e-" jest obecny w formacie niestandardowym i następuje natychmiast po co najmniej jednym znaku "0", wartość jest formatowana przy użyciu notacji naukowej. Liczba znaków "0" po prefiksie wykładnika (E lub e) określa minimalną liczbę cyfr w wykładnik. Formaty "E+" i "e+" wskazują, że symbol liczby dodatniej lub ujemnej zawsze poprzedza wykładnik. Formaty "E", "E-", "e" lub "e-" wskazują, że symbol liczby ujemnej poprzedza wykładniki ujemne; żaden symbol nie poprzedza wykładników dodatnich. Symbol liczby dodatniej System.Globalization.NumberFormatInfo.PositiveSign jest dostarczany przez właściwość . Symbol liczby ujemnej System.Globalization.NumberFormatInfo.NegativeSign jest dostarczany przez właściwość . |
\ (ukośnik odwrotny) |
Znak ucieczki: w niektórych językach, takich jak C#, znak ukośnika odwrotnego powoduje, że następny znak w formacie niestandardowym jest interpretowany jako sekwencja ucieczki. Jest on używany z sekwencjami formatowania języka C, takimi jak "\n" (nowy wiersz). W niektórych językach sam znak ucieczki musi być poprzedzony znakiem ucieczki, gdy jest używany jako literał. W przeciwnym razie kompilator interpretuje znak jako sekwencję ucieczki. Ten znak ucieczki nie jest wymagany do obsługi we wszystkich językach programowania. |
|
Ciąg literału: znaki ujęte w pojedynczy lub podwójny cudzysłów są kopiowane do ciągu wyjściowego dosłownie i nie mają wpływu na formatowanie. |
; (średnik) |
Separator sekcji: znak ";" służy do oddzielania sekcji dla liczb dodatnich, ujemnych i zerowych w ciągu formatu. (Ta funkcja została szczegółowo opisana poniżej). |
| Inne | Wszystkie inne znaki: wszystkie inne znaki są przechowywane w ciągu wyjściowym jako literały w pozycji, w której się pojawiają. |
Należy pamiętać, że w przypadku ciągów formatu o stałym punkcie (ciągów nie zawierających "E0", "E+0", "E-0", "e0", "e+0" lub "e-0") liczby są zaokrąglane do tylu miejsc dziesiętnych, ile ma symbole zastępcze Zero lub Cyfra po prawej stronie separatora dziesiętnego. Jeśli format niestandardowy nie zawiera separatora dziesiętnego, liczba jest zaokrąglona do najbliższej liczby całkowitej. Jeśli liczba ma więcej cyfr niż symbole zastępcze Zero lub Cyfra po lewej stronie separatora dziesiętnego, dodatkowe cyfry są kopiowane do ciągu wyjściowego bezpośrednio przed pierwszym symbolem zastępczym Zero lub Digit.
Format niestandardowy może zawierać maksymalnie trzy sekcje oddzielone znakami separatora sekcji, aby określić różne formatowanie dla wartości dodatnich, ujemnych i zerowych. Sekcje są interpretowane w następujący sposób:
Jedna sekcja: Format niestandardowy ma zastosowanie do wszystkich wartości (dodatnie, ujemne i zero). Wartości ujemne obejmują znak ujemny.
Dwie sekcje: Pierwsza sekcja dotyczy wartości dodatnich i zer, a druga sekcja dotyczy wartości ujemnych. Jeśli wartość do sformatowania jest ujemna, ale staje się zero po zaokrągleniu zgodnie z formatem w drugiej sekcji, wynikowe zero jest sformatowane zgodnie z pierwszą sekcją. Wartości ujemne nie zawierają znaku ujemnego, aby umożliwić pełną kontrolę nad reprezentacjami wartości ujemnych. Na przykład negatyw może być reprezentowany w nawiasach przy użyciu formatu niestandardowego podobnego do "###.####; (####.####)’.
Trzy sekcje: Pierwsza sekcja dotyczy wartości dodatnich, druga sekcja dotyczy wartości ujemnych, a trzecia sekcja dotyczy zer. Druga sekcja może być pusta (nic nie pojawia się między średnikami), w tym przypadku pierwsza sekcja dotyczy wszystkich wartości niezerowych, a wartości ujemne zawierają znak ujemny. Jeśli liczba do sformatowania jest niezerowa, ale staje się zero po zaokrągleniu zgodnie z formatem w pierwszej lub drugiej sekcji, wynikowe zero jest sformatowane zgodnie z trzecią sekcją.
Typy System.Enum i System.DateTime obsługują również używanie specyfikatorów formatu do formatowania reprezentacji ciągów wartości. Znaczenie określonego specyfikatora formatu różni się w zależności od rodzaju sformatowanych danych (liczbowych, daty/godziny, wyliczenia). Zobacz System.Enum i System.Globalization.DateTimeFormatInfo , aby uzyskać kompleksową listę specyfikatorów formatu obsługiwanych przez każdy typ.
Skróty typów biblioteki C.5
W tej specyfikacji odwołuje się do następujących typów bibliotek. Poniżej wymieniono pełne nazwy tych typów, w tym globalny kwalifikator przestrzeni nazw. W tej specyfikacji te typy są wyświetlane jako w pełni kwalifikowana nazwa; z pominiętym kwalifikatorem globalnej przestrzeni nazw; lub jako prosta niekwalifikowana nazwa typu, z pominiętą przestrzenią nazw. Na przykład typ ICollection<T>, jeśli jest używany w tej specyfikacji, zawsze oznacza typ 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
Koniec tekstu informacyjnego.
ECMA C# draft specification