Standardní knihovna přílohy C
C.1 Obecné
Odpovídající implementace jazyka C# poskytuje minimální sadu typů, které mají specifickou sémantiku. Tyto typy a jejich členy jsou uvedeny v abecedním pořadí podle oboru názvů a typu. Formální definici těchto typů a jejich členů najdete v části ISO/IEC 23271:2012 Common Language Infrastructure (CLI), oddíl IV; Knihovna základních tříd (BCL), rozšířená numerická knihovna a rozšířená maticová knihovna, které jsou součástí této specifikace.
Tento text je informativní.
Standardní knihovna je určená jako minimální sada typů a členů vyžadovaných odpovídající implementací jazyka C#. Proto obsahuje pouze ty členy, které explicitně vyžadují specifikace jazyka C#.
Očekává se, že odpovídající implementace jazyka C# bude poskytovat výrazně rozsáhlejší knihovnu, která umožňuje zápis užitečných programů. Například odpovídající implementace může tuto knihovnu rozšířit o
- Přidání oborů názvů
- Přidávání typů
- Přidání členů do typů, které nejsou rozhraním
- Přidání intervening základních tříd nebo rozhraní.
- S strukturou a typy tříd implementují další rozhraní.
- Přidání atributů (kromě
ConditionalAttribute) k existujícím typům a členům
Konec informativního textu
C.2 Standardní typy knihoven definované v ISO/IEC 23271
Poznámka: Některé
structtypy níže majíreadonlymodifikátor. Tento modifikátor nebyl k dispozici při vydání ISO/IEC 23271, ale vyžaduje se pro splnění implementací této specifikace. koncová poznámka
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 Standardní typy knihoven, které nejsou definovány v ISO/IEC 23271
Následující typy, včetně uvedených členů, jsou definovány v odpovídající standardní knihovně. (Tyto typy mohou být definovány v budoucí edici ISO/IEC 23271.) Očekává se, že mnoho z těchto typů bude mít k dispozici více členů, než je uvedeno.
Odpovídající implementace může poskytovat Task.GetAwaiter() a Task<TResult>.GetAwaiter() jako rozšiřující metody.
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();
}
}
Specifikace formátu C.4
Význam formátů, jak se používá v interpolovaných řetězcových výrazech (§12.8.3), jsou definovány v ISO/IEC 23271:2012. Pro usnadnění pohodlí se následující text zkopíruje z popisu System.IFormattable.
Tento text je informativní.
Formát je řetězec, který popisuje vzhled objektu při jeho převodu na řetězec. Lze použít standardní nebo vlastní formáty. Standardní formát má tvar Axx, kde A je jeden abecední znak, který se nazývá specifikátor formátu, a xx je celé číslo mezi nulou a 99 včetně, označované jako specifikátor přesnosti. Specifikátor formátu řídí typ formátování použitého na hodnotu reprezentovanou jako řetězec. Specifikátor přesnosti určuje počet platných číslic nebo desetinných míst v řetězci, pokud je k dispozici.
Poznámka: Seznam standardních specifikátorů formátu najdete v následující tabulce. Všimněte si, že daný datový typ, například
System.Int32, nemusí podporovat jeden nebo více specifikátorů standardního formátu. koncová poznámka
Poznámka: Pokud formát obsahuje symboly, které se liší podle jazykové verze, například měnasymbol zahrnuté ve formátech "C" a "c", objekt formátování poskytuje skutečné znaky použité v řetězcové reprezentaci. Metoda může obsahovat parametr pro předání objektu
System.IFormatProvider, který poskytuje objekt formátování, nebo metoda může použít výchozí objekt formátování, který obsahuje definice symbolů pro aktuální jazykovou verzi. Aktuální jazyková verze obvykle používá stejnou sadu symbolů používaných systémem ve výchozím nastavení. V knihovně základních tříd jeSystem.Globalization.NumberFormatInfoobjekt formátování pro systémové číselné typy instance. NapříkladSystem.DateTimeSystem.Globalization.DateTimeFormatInfose používá. koncová poznámka
Následující tabulka popisuje standardní specifikátory formátu a přidružené členy objektu formátování, které se používají s číselnými datovými typy v knihovně základních tříd.
| Specifikátor formátu | Popis |
|---|---|
|
Formát měny: Používá se pro řetězce obsahující peněžní hodnotu. Symbol
Pokud je specifikátor přesnosti vynechán, |
|
Formát desetinných míst: (Tento formát je platný pouze v případě, že je zadán celočíselnými datovými typy.) Používá se pro řetězce obsahující celočíselné hodnoty. Záporná čísla mají předponu se symbolem záporného čísla určeného Specifikátor přesnosti určuje minimální počet číslic, které se zobrazí v řetězci. Pokud zadaná přesnost vyžaduje více číslic, než obsahuje hodnota, řetězec je vlevo vycpaný nulami. Pokud specifikátor přesnosti určuje méně číslic, než je hodnota, specifikátor přesnosti se ignoruje. |
|
Vědecký (technický) formát: Používá se pro řetězce v jedné z následujících forem: – –m.dddddDE+xxx – –m.ddddddE-xxx – –m.dddddde+xxx – –m.dddddde-xxx Symbol záporného čísla (-) se zobrazí pouze v případě, že je hodnota záporná a je zadána Přesně jedna nenulová desetinná číslice (m) předchází oddělovači desetinných míst ('.'), který je zadán Specifikátor přesnosti určuje počet desetinných míst (dddddd) v řetězci. Pokud je specifikátor přesnosti vynechán, je v řetězci zahrnuto šest desetinných míst. Exponent (+/-xxx) se skládá ze symbolu kladného nebo záporného čísla následovaného minimálně třemi číslicemi (xxx). Exponent je v případě potřeby vlevo vycpaný nulami. Případ specifikátoru formátu (E nebo e) určuje případ použitý pro předponu exponentu (E nebo e) v řetězci. Výsledky se v případě potřeby zaokrouhlí na nejbližší reprezentovatelnou hodnotu. Vlastnost poskytuje symbol kladného |
|
Formát s pevným bodem: Používá se pro řetězce v následujícím formátu: – –m.dd... d Nejméně jedna nenulová desetinná číslice (m) předchází oddělovači desetinných míst ('.'), který je zadán Znaménko symbolu záporného čísla (-) předchází pouze v případě, že je hodnota záporná. Tento symbol je zadán vlastností Specifikátor přesnosti určuje počet desetinných míst (dd... d) v řetězci. Pokud je specifikátor přesnosti vynechán, |
|
Obecný formát: Řetězec je formátován buď ve formátu s pevným bodem (F, f), nebo ve vědeckém formátu (E nebo e). Pro integrální typy: Hodnoty jsou formátovány pomocí formátu s pevným bodem, pokud je specifikátor přesnosti exponentu< , kde exponent je exponent hodnoty ve vědeckém formátu. Pro všechny ostatní hodnoty se používá vědecký formát. Pokud specifikátor přesnosti vynecháte, použije se výchozí přesnost rovna šířce pole požadované k zobrazení maximální hodnoty pro datový typ, což vede k formátování hodnoty ve formátu s pevným bodem. Výchozí přesnosti pro integrální typy jsou následující:
Pro typy Single, Decimal a Double: Hodnoty jsou formátovány pomocí formátu s pevnou čárkou, pokud exponent ≥ -4 a specifikátor přesnosti exponentu, kde < je exponent hodnoty ve vědeckém formátu. Pro všechny ostatní hodnoty se používá vědecký formát. Výsledky se v případě potřeby zaokrouhlí na nejbližší reprezentovatelnou hodnotu. Pokud specifikátor přesnosti vynecháte, použijí se následující výchozí přesnosti:
Pro všechny typy:
|
|
Formát čísla: Používá se pro řetězce v následujícím formátu: – –d,ddd,ddd.dd... d Reprezentace záporných hodnot je určena Nejméně jedna nenulová desetinná číslice (d) předchází oddělovači desetinných míst ('.'), který je zadán Specifikátor přesnosti určuje počet desetinných míst (dd... d). Pokud je specifikátor přesnosti vynechán, |
|
Formát procenta: Používá se pro řetězce obsahující procento. Symbol
Pokud není zadána žádná přesnost, určuje se počet desetinných míst ve výsledku Výsledek se škáluje o 100 (,99 se stane 99 %). |
|
Formát odezvy: (Tento formát je platný pouze v případě, že je zadán parametrem System.Double nebo System.Single.) Používá se k zajištění, aby přesnost řetězcové reprezentace hodnoty s plovoucí desetinnou čárkou byla taková, že analýza řetězce nemá za následek ztrátu přesnosti v porovnání s původní hodnotou. Pokud by maximální přesnost datového typu (7 pro System.Singlea 15 pro System.Double) vedlo ke ztrátě přesnosti, přesnost se zvýší o dvě desetinná místa. Pokud je specifikátor přesnosti dodán s tímto specifikátorem formátu, bude ignorován. Tento formát je jinak shodný s formátem s pevným bodem. |
|
Šestnáctkový formát: (Tento formát je platný pouze v případě, že je zadán celočíselnými datovými typy.) Používá se pro řetězcové reprezentace čísel v základu 16. Přesnost určuje minimální počet číslic v řetězci. Pokud přesnost určuje více číslic, než obsahuje číslo, je číslo vlevo vysunuto nulami. Případ specifikátoru formátu (X nebo x) určuje, zda se v šestnáctkové reprezentaci používají velká nebo malá písmena. |
Je-li číselná hodnota nebo System.SingleSystem.Double s hodnotou NaN, PositiveInfinitynebo NegativeInfinity, specifikátor formátu je ignorován a je vrácena jedna z následujících hodnot: System.Globalization.NumberFormatInfo.NaNSymbol, , System.Globalization.NumberFormatInfo.PositiveInfinitySymbolnebo System.Globalization.NumberFormatInfo.NegativeInfinitySymbol.
Vlastní formát je libovolný řetězec zadaný jako formát, který není ve formě standardního řetězce formátu (Axx) popsaného výše. Následující tabulka popisuje znaky, které se používají při vytváření vlastních formátů.
| Specifikátor formátu | Popis |
|---|---|
0 (nula) |
Zástupný symbol nula: Pokud má formátovaná hodnota číslici na pozici, kde se ve vlastním formátu zobrazí znak 0, zkopíruje se tato číslice do výstupního řetězce. Jinak je nula uložena na této pozici ve výstupním řetězci. Pozice nejvíce vlevo 0 před oddělovačem desetinných míst a oddělovačem desetinných míst vpravo od oddělovače desetinných míst určuje rozsah číslic, které jsou vždy přítomné ve výstupním řetězci. Počet zástupných symbolů nula a/nebo číslic za oddělovačem desetinných míst určuje počet číslic, které se zobrazí za oddělovačem desetinných míst. Hodnoty se podle potřeby zaokrouhlují. |
# |
Zástupný symbol číslice: Pokud má formátovaná hodnota číslici na pozici, kde se ve vlastním formátu objeví znak #, zkopíruje se tato číslice do výstupního řetězce. Jinak se ve výstupním řetězci nic neuloží. Všimněte si, že tento specifikátor nikdy neuchovává znak "0", pokud se nejedná o významnou číslici, i když je 0 jedinou číslicí v řetězci. (Pokud se jedná o významnou číslici, zobrazí se ve výstupním řetězci znak "0".) Počet zástupných symbolů nula a/nebo číslic za oddělovačem desetinných míst určuje počet číslic, které se zobrazí za oddělovačem desetinných míst. Hodnoty se podle potřeby zaokrouhlují. |
. (období) |
Oddělovač desetinných míst: Vlevo nejvíce '.'
znak ve formátovacím řetězci určuje umístění oddělovače desetinných míst ve formátované hodnotě; jakékoli další "." znaky jsou ignorovány. Vlastnost System.Globalization.NumberFormatInfo.NumberDecimalSeparator určuje symbol použitý jako oddělovač desetinných míst. |
, (čárka) |
Oddělovač skupin a měřítko čísel: Znak "," slouží dvěma účelům. Pokud vlastní formát obsahuje tento znak mezi dvěma zástupnými symboly Nula nebo Číslice (0 nebo #) a vlevo od oddělovače desetinných míst, pokud existuje, bude výstup obsahovat oddělovače skupin vložené mezi každou skupinu číslic vlevo od oddělovače desetinných míst.
Pokud formátovací řetězec obsahuje jeden nebo více znaků , okamžitě nalevo od oddělovače desetinných míst, bude číslo škálováno. Koeficient je určen počtem znaků oddělovače skupin bezprostředně vlevo od oddělovače desetinných míst. Pokud jsou znaky x, je hodnota před formátováním vydělena hodnotou 1000X . Například řetězec formátu 0 vydělí hodnotu o jeden milion. Všimněte si, že přítomnost znaku ",", který označuje, že měřítko nevkládává oddělovače skupin do výstupního řetězce. Pokud tedy chcete škálovat číslo o 1 milion a vložit oddělovače skupin, použijte vlastní formát podobný '#,#0,'. |
% (procento) |
Zástupný symbol procenta: Přítomnost znaku %ve vlastním formátu způsobí, že se číslo vynásobí číslem 100 před jeho formátováním. Symbol procenta se vloží do výstupního řetězce do umístění, kde se v řetězci formátu objeví znak %. Vlastnost System.Globalization.NumberFormatInfo.PercentSymbol určuje symbol procenta. |
|
Technický formát: Pokud některý z řetězců "E", "E+", "E-", "e", "e+" nebo "e-" jsou přítomny ve vlastním formátu a za ním následuje alespoň jeden znak "0", pak se hodnota naformátuje pomocí vědeckého zápisu. Počet znaků "0" za předponou exponentu (E nebo e) určuje minimální počet číslic v exponentu. Formáty E+ a e+ označují, že symbol kladného nebo záporného čísla vždy předchází exponentu. Formáty "E", "E-", "e" nebo "e-" označují, že záporný symbol čísla předchází záporným exponentům; před kladnými exponenty není žádný symbol. Vlastnost poskytuje symbol kladného System.Globalization.NumberFormatInfo.PositiveSign čísla. Vlastnost poskytuje symbol záporného System.Globalization.NumberFormatInfo.NegativeSign čísla. |
\ (zpětné lomítko) |
Řídicí znak: V některých jazycích, jako je C#, znak zpětného lomítka způsobí, že další znak ve vlastním formátu bude interpretován jako řídicí sekvence. Používá se se sekvencemi formátování jazyka C, například \n (nový řádek). V některých jazycích musí být řídicí znak samotný před řídicím znakem, pokud se používá jako literál. V opačném případě kompilátor interpretuje znak jako escape sekvenci. Tento řídicí znak není nutné podporovat ve všech programovacích jazycích. |
|
Literální řetězec: Znaky uzavřené v jednoduchých nebo dvojitých uvozovkách se zkopírují do výstupního řetězce doslova a nemají vliv na formátování. |
; (středník) |
Oddělovač oddílů: Znak ;slouží k oddělení oddílů pro kladná, záporná a nulová čísla ve formátovacím řetězci. (Tato funkce je podrobně popsaná níže.) |
| Jiný důvod | Všechny ostatní znaky: Všechny ostatní znaky jsou uloženy ve výstupním řetězci jako literály v pozici, ve které se zobrazují. |
Všimněte si, že pro řetězce formátu s pevným bodem (řetězce neobsahující řetězec E0, E+0, E-0, e0, e+0 nebo e-0) se čísla zaokrouhlí na tolik desetinných míst, kolik je zástupných symbolů nula nebo číslic napravo od oddělovače desetinných míst. Pokud vlastní formát neobsahuje oddělovač desetinných míst, číslo se zaokrouhlí na nejbližší celé číslo. Pokud číslo obsahuje více číslic, než je vlevo od oddělovače desetinných míst, další číslice se zkopírují do výstupního řetězce bezprostředně před prvním zástupným symbolem Nula nebo Číslice.
Vlastní formát může obsahovat až tři oddíly oddělené znaky oddělovače oddílů, aby bylo možné zadat jiné formátování pro kladné, záporné a nulové hodnoty. Oddíly jsou interpretovány takto:
Jedna část: Vlastní formát platí pro všechny hodnoty (kladné, záporné a nulové). Záporné hodnoty zahrnují záporné znaménko.
Dvě části: První oddíl se vztahuje na kladné hodnoty a nuly a druhý oddíl se vztahuje na záporné hodnoty. Pokud je hodnota, která má být formátována, záporná, ale po zaokrouhlování podle formátu v druhém oddílu se výsledná nula naformátuje podle prvního oddílu. Záporné hodnoty nezahrnují záporné znaménko, které umožňuje úplnou kontrolu nad reprezentací záporných hodnot. Záporná záporná závorka může být například reprezentována v závorkách pomocí vlastního formátu podobného '####.##### (####.####)’.
Tři oddíly: První oddíl se vztahuje na kladné hodnoty, druhý oddíl se vztahuje na záporné hodnoty a třetí oddíl se vztahuje na nuly. Druhý oddíl může být prázdný (mezi středníky se nic nezobrazuje), v takovém případě první oddíl platí pro všechny nenulové hodnoty a záporné hodnoty zahrnují záporné znaménko. Pokud je číslo, které má být formátováno, nenulové, ale po zaokrouhlení podle formátu v prvním nebo druhém oddílu se výsledná nula naformátuje podle třetího oddílu.
Typy System.Enum podporují System.DateTime také použití specifikátorů formátu k formátování řetězcových reprezentací hodnot. Význam specifikátoru konkrétního formátu se liší podle typu dat (číselného formátu, data a času, výčtu). Podívejte System.Enum se na System.Globalization.DateTimeFormatInfo úplný seznam specifikátorů formátu podporovaných jednotlivými typy.
Zkratky typů knihoven C.5
Na následující typy knihoven se odkazuje v této specifikaci. Níže jsou uvedeny úplné názvy těchto typů, včetně globálního kvalifikátoru oboru názvů. V rámci této specifikace se tyto typy zobrazují jako plně kvalifikovaný název; s vynechaným globálním oborem názvů; nebo jako jednoduchý nekvalifikovaný název typu s vynechaným oborem názvů. Například typ ICollection<T>, při použití v této specifikaci, vždy znamená 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
Konec informativního textu
ECMA C# draft specification