Megosztás a következőn keresztül:

C. melléklet standard könyvtára

C.1 Általános

A megfelelő C#-megvalósításnak biztosítania kell a meghatározott szemantikával rendelkező típusok minimális készletét. Ezek a típusok és tagjaik betűrendben, névtér és típus szerint vannak felsorolva. Az ilyen típusok és tagjaik formális meghatározásához tekintse meg az ISO/IEC 23271:2012 Common Language Infrastructure (CLI) IV. partíciót; Alaposztálykódtár (BCL), kiterjesztett numerikus kódtár és kiterjesztett tömbtár, amelyeket a jelen specifikáció tartalmaz.

Ez a szöveg informatív.

A standard kódtár a megfelelő C#-implementációhoz szükséges minimális típus- és tagkészlet. Ezért csak azokat a tagokat tartalmazza, amelyekre a C# nyelvi specifikációja kifejezetten szükség van.

A C# megfelelő implementációja várhatóan jelentősen szélesebb tárat biztosít, amely lehetővé teszi a hasznos programok írását. Egy megfelelő implementáció például kibővítheti ezt a kódtárat a következővel:

  • Névterek hozzáadása.
  • Típusok hozzáadása.
  • Tagok hozzáadása nem felületi típusokhoz.
  • Beavatkozó alaposztályok vagy interfészek hozzáadása.
  • A strukturálás és az osztálytípusok további interfészeket implementálnak.
  • Attribútumok hozzáadása (a nem a ConditionalAttributemeglévő típusokhoz és tagokhoz).

Az informatív szöveg vége.

Az ISO/IEC 23271 szabványkódtártípusai

Megjegyzés: Néhány struct alábbi típus rendelkezik a readonly módosítóval. Ez a módosító nem volt elérhető az ISO/IEC 23271 kiadásakor, de a specifikáció megfelelő implementációihoz szükséges. végjegyzet

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 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);
    }
}

Az ISO/IEC 23271-ben nem definiált standard kódtártípusok

A következő típusokat, beleértve a felsorolt tagokat, egy megfelelő szabványos könyvtárban kell meghatározni. (Ezek a típusok az ISO/IEC 23271 jövőbeli kiadásában definiálhatók.) Az ilyen típusok közül soknak több tagja lesz elérhető, mint a felsoroltak.

A megfelelő implementációk kiegészítő módszereket biztosíthatnak Task.GetAwaiter() és Task<TResult>.GetAwaiter() alkalmazhatnak.

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);
    }

    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.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.Collections.Generic
{
    public interface IAsyncEnumerable<out T>
    {
        IAsyncEnumerator<T> GetAsyncEnumerator();
    }

    public interface IAsyncEnumerator<out T> : IAsyncDisposable
    {
        ValueTask<bool> MoveNextAsync();
        T Current { 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() { }
    }

    [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.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();
    }

    public readonly struct CancellationToken : IEquatable<System.Threading.CancellationToken>
    {
        public static CancellationToken None { get; }
        public bool IsCancellationRequested { get; }
        public bool CanBeCanceled { get; }
        public WaitHandle WaitHandle { get; }
        public CancellationToken(bool canceled);
        public CancellationTokenRegistration Register(Action callback);
        public CancellationTokenRegistration Register(Action callback, bool useSynchronizationContext);
        public CancellationTokenRegistration Register(Action<object?> callback, object? state);
        public CancellationTokenRegistration Register(Action<object?, CancellationToken> callback, object? state);
        public CancellationTokenRegistration Register(Action<object?> callback, object? state, bool useSynchronizationContext);
        public CancellationTokenRegistration UnsafeRegister(Action<object?> callback, object? state);
        public CancellationTokenRegistration UnsafeRegister(Action<object?, CancellationToken> callback, object? state);
        public bool Equals(CancellationToken other);
        public override bool Equals([NotNullWhen(true)] object? other);
        public override int GetHashCode();
        public static bool operator ==(CancellationToken left, CancellationToken right);
        public static bool operator !=(CancellationToken left, CancellationToken right);
        public void ThrowIfCancellationRequested();
    }  
}

C.4 Formátumspecifikációk

Az interpolált sztringkifejezésekben (§12.8.3) használt formátumok jelentését az ISO/IEC 23271:2012 szabvány határozza meg. A kényelem érdekében a program a következő szöveget másolja ki a leírásból System.IFormattable.

Ez a szöveg informatív.

A formátumok olyan sztringek, amelyek egy objektum megjelenését írják le, amikor sztringgé alakítják. Szabványos vagy egyéni formátumok is használhatók. A standard formátum az Axx formátum, ahol az A egy betűrendes karakter, a formátumkijelölő, az xx pedig egy nulla és 99 közötti egész szám, amelyet pontosság-meghatározónak neveznek. A formátumkijelölő szabályozza a sztringként ábrázolt értékre alkalmazott formázás típusát. A pontosság-meghatározó a sztringben lévő jelentős számjegyek vagy tizedesjegyek számát vezérli, ha van ilyen.

Megjegyzés: A szabványos formátumkijelölők listájáért tekintse meg az alábbi táblázatot. Vegye figyelembe, hogy előfordulhat, hogy egy adott adattípus, például System.Int32egy vagy több szabványos formátumkijelölő nem támogatott. végjegyzet

Megjegyzés: Ha egy formátum kultúránként eltérő szimbólumokat tartalmaz, például a "C" és a "c" formátum által tartalmazott pénznemszimbólumot, a formázási objektum a sztring-ábrázolásban használt tényleges karaktereket adja meg. A metódus tartalmazhat egy paramétert egy formázási objektumot biztosító objektum átadásához System.IFormatProvider , vagy a metódus az alapértelmezett formázási objektumot használhatja, amely az aktuális kultúra szimbólumdefinícióit tartalmazza. A jelenlegi kultúra általában ugyanazt a szimbólumkészletet használja, amelyet alapértelmezés szerint rendszerszintűen használnak. Az alaposztálytárban a rendszer által megadott numerikus típusok formázási objektuma egy System.Globalization.NumberFormatInfo példány. Például System.DateTime a használt példányok System.Globalization.DateTimeFormatInfo . végjegyzet

Az alábbi táblázat az alaposztálytár numerikus adattípusaival használt szabványos formátumkijelölőket és társított formázási objektumtagokat ismerteti.

Format Specifier Leírás

C

c

Pénznemformátum: Pénzügyi értéket tartalmazó sztringekhez használatos. A System.Globalization.NumberFormatInfo.CurrencySymbolszámjegycsoportok System.Globalization.NumberFormatInfo.CurrencyGroupSizesSystem.Globalization.NumberFormatInfo.CurrencyGroupSeparatorSystem.Globalization.NumberFormatInfo.CurrencyDecimalSeparator pénznemszimbólumátSystem.Globalization.NumberFormatInfo, méretét és elválasztójelét, illetve tizedesjelet ad meg.

System.Globalization.NumberFormatInfo.CurrencyNegativePattern és System.Globalization.NumberFormatInfo.CurrencyPositivePattern határozza meg a negatív és pozitív értékek ábrázolására használt szimbólumokat. A negatív érték előtagja lehet például mínuszjellel, vagy zárójelben is.

Ha a pontosság-meghatározó nincs megadva, System.Globalization.NumberFormatInfo.CurrencyDecimalDigits a sztring tizedesjegyeinek számát határozza meg. Az eredmények szükség esetén a legközelebbi ábrázolható értékre vannak kerekítve.

D

d

Decimális formátum: (Ez a formátum csak akkor érvényes, ha az integrál adattípusokkal van megadva.) Egész számértékeket tartalmazó sztringekhez használatos. A negatív számok előtagja a tulajdonság által System.Globalization.NumberFormatInfo.NegativeSign megadott negatív számszimbólum.

A pontosság-meghatározó határozza meg a sztringben megjelenő számjegyek minimális számát. Ha a megadott pontossághoz több számjegyre van szükség, mint amennyit az érték tartalmaz, a sztring bal oldali kitöltése nullákkal történik. Ha a pontosság-meghatározó kevesebb számjegyet ad meg, mint amennyi az értékben van, a pontosság-meghatározó figyelmen kívül lesz hagyva.

E

e

Tudományos (mérnöki) formátum: Sztringekhez használatos az alábbi űrlapok egyikében:

          [-]m.dddddddDE+xxx

          [-]m.ddddddE-xxx

          [-]m.ddddddd e+xxx

          [-]m.dddddde-xxx

A negatív szám szimbólum ('-') csak akkor jelenik meg, ha az érték negatív, és a System.Globalization.NumberFormatInfo.NegativeSign tulajdonság adja meg.

Pontosan egy nem nulla tizedesjegy (m) előzi meg a tulajdonság által System.Globalization.NumberFormatInfo.NumberDecimalSeparator megadott tizedeselválasztót ('.').

A pontosság-meghatározó határozza meg a karakterlánc tizedesjegyeinek (dddddd) számát. Ha a pontosság-meghatározó nincs megadva, a sztring hat tizedesjegyet tartalmaz.

A kitevő (+/-xxx) egy pozitív vagy negatív számszimbólumból áll, amelyet legalább három számjegy (xxx) követ. A kitevőt szükség esetén nullákkal kell kipárnázni. A formátumjelölő ('E' vagy 'e' ) esete határozza meg a sztringben a kitevő előtaghoz (E vagy e) használt esetet. Az eredmények szükség esetén a legközelebbi ábrázolható értékre vannak kerekítve. A pozitív szám szimbólumot a System.Globalization.NumberFormatInfo.PositiveSign tulajdonság adja meg.

F

f

Rögzített pontformátum: A következő formában használt sztringekhez használható:

          [-]m.dd... d

Legalább egy nem nulla tizedesjegy (m) megelőzi a tulajdonság által System.Globalization.NumberFormatInfo.NumberDecimalSeparator megadott tizedeselválasztót ('.').

A negatív számszimbólumjel ('-') csak akkor előzi meg az m értéket, ha az érték negatív. Ezt a szimbólumot a System.Globalization.NumberFormatInfo.NegativeSign tulajdonság adja meg.

A pontosság-meghatározó határozza meg a tizedesjegyek számát (dd... d) a sztringben. Ha a pontosság-meghatározó nincs megadva, System.Globalization.NumberFormatInfo.NumberDecimalDigits a sztring tizedesjegyeinek számát határozza meg. Az eredmények szükség esetén a legközelebbi ábrázolható értékre vannak kerekítve.

G

g

Általános formátum: A sztring rögzített pontformátumban ("F" vagy "f") vagy tudományos formátumban ("E" vagy "e") van formázva.

Integráltípusok esetén:

Az értékek rögzítettpontos formátummal vannak formázva, ha a kitevő< pontossági meghatározó, ahol a kitevő a tudományos formátumú érték kitevője . Minden más értékhez tudományos formátumot használunk.

Ha a pontosság-kijelölő nincs megadva, akkor a program az adattípus maximális értékének megjelenítéséhez szükséges mezőszélességnek megfelelő alapértelmezett pontosságot használja, ami azt eredményezi, hogy az érték rögzítettpontos formátumban van formázva. Az integráltípusok alapértelmezett pontossága a következő:

           System.Int16, System.UInt16 : 5

           System.Int32, System.UInt32 : 10

           System.Int64, System.UInt64 : 19

Egy-, tizedes- és kettős típusok esetén:

Az értékek rögzítettpontos formátummal vannak formázva, ha a kitevő ≥ -4 és a kitevő< pontossági kijelölő, ahol a kitevő az érték kitevője tudományos formátumban. Minden más értékhez tudományos formátumot használunk. Az eredmények szükség esetén a legközelebbi ábrázolható értékre vannak kerekítve.

Ha a pontosság-meghatározó nincs megadva, a rendszer a következő alapértelmezett pontosságokat használja:

           System.Single : 7

           System.Double : 15

           System.Decimal : 29

Minden típushoz:

  • Az eredményben megjelenő számjegyek száma (a kitevőt nem beleértve) nem lépi túl a pontosság-meghatározó értékét; az értékek szükség szerint kerekítve lesznek.
  • Ha lehetséges, a tizedesvesszőt és a záró nullákat a rendszer eltávolítja.
  • A formátumjelölő (G vagy g) esete határozza meg, hogy az "E" vagy az "e" előtag a tudományos formátumkijelölőt jelöli-e.

N

n

Számformátum: A következő űrlap sztringjeihez használatos:

          [-]d,ddd,ddd.dd... d

A negatív értékek ábrázolását a System.Globalization.NumberFormatInfo.NumberNegativePattern tulajdonság határozza meg. Ha a minta negatív számszimbólumot ('-') tartalmaz, akkor ezt a szimbólumot a System.Globalization.NumberFormatInfo.NegativeSign tulajdonság adja meg.

Legalább egy nem nulla tizedesjegy (d) megelőzi a tulajdonság által System.Globalization.NumberFormatInfo.NumberDecimalSeparator megadott tizedeselválasztót ('.'). A tizedesvessző és az érték legjelentősebb számjegye közötti számjegyek a tulajdonság által System.Globalization.NumberFormatInfo.NumberGroupSizes megadott csoportméret alapján vannak csoportosítva. A csoportelválasztót (''') az egyes számjegycsoportok közé szúrja be, és a System.Globalization.NumberFormatInfo.NumberGroupSeparator tulajdonság adja meg.

A pontosság-meghatározó határozza meg a tizedesjegyek számát (dd... d). Ha a pontosság-meghatározó nincs megadva, System.Globalization.NumberFormatInfo.NumberDecimalDigits a sztring tizedesjegyeinek számát határozza meg. Az eredmények szükség esetén a legközelebbi ábrázolható értékre vannak kerekítve.

P

p

Százalékformátum: Százalékot tartalmazó sztringekhez használatos. A System.Globalization.NumberFormatInfo.PercentSymbol, System.Globalization.NumberFormatInfo.PercentGroupSizes, System.Globalization.NumberFormatInfo.PercentGroupSeparatorés System.Globalization.NumberFormatInfo.PercentDecimalSeparator a tagok a számjegycsoportok százalékos szimbólumát System.Globalization.NumberFormatInfo , méretét és elválasztójelét, illetve a tizedeselválasztót adja meg.

System.Globalization.NumberFormatInfo.PercentNegativePattern és System.Globalization.NumberFormatInfo.PercentPositivePattern határozza meg a negatív és pozitív értékek ábrázolására használt szimbólumokat. A negatív érték előtagja lehet például mínuszjellel, vagy zárójelben is.

Ha nincs megadva pontosság, az eredményben szereplő tizedesjegyek számát a függvény határozza meg System.Globalization.NumberFormatInfo.PercentDecimalDigits. Az eredmények szükség esetén a legközelebbi ábrázolható értékre vannak kerekítve.

Az eredmény 100-ra van skálázva (.99-ből 99%).

R

r

 Körút formátuma: (Ez a formátum csak akkor érvényes, ha meg van adva vagy System.DoubleSystem.Single.) Annak biztosítására szolgál, hogy a lebegőpontos értékek sztringreprezentációjának pontossága olyan legyen, hogy a sztring elemzése ne eredményezzen pontosságvesztést az eredeti értékhez képest. Ha az adattípus (7 System.Singleés 15 System.Double) maximális pontossága a pontosság csökkenését eredményezné, a pontosság két tizedesjegygel nő. Ha egy pontosság-meghatározót ad meg ezzel a formátumkijelölővel, a rendszer figyelmen kívül hagyja. Ez a formátum egyébként megegyezik a rögzített pont formátumával.

X

x

 Hexadecimális formátum: (Ez a formátum csak akkor érvényes, ha az integrál adattípusokkal van megadva.) Számokat ábrázoló sztringek a 16-os alapban. A pontosság határozza meg a sztringben lévő számjegyek minimális számát. Ha a pontosság több számjegyet ad meg, mint amennyit a szám tartalmaz, a szám bal oldali kitöltése nullákkal történik. A formátumjelölő ("X" vagy "x") esete határozza meg, hogy nagybetűket vagy kisbetűket használnak-e a hexadecimális ábrázolásban.

Ha a numerikus érték egy vagy egy , vagy, akkor a formátumjelölő figyelmen kívül lesz hagyva, és a következő értékek egyikét adja vissza: System.Single, System.Doublevagy NaN.PositiveInfinityNegativeInfinitySystem.Globalization.NumberFormatInfo.NaNSymbolSystem.Globalization.NumberFormatInfo.PositiveInfinitySymbolSystem.Globalization.NumberFormatInfo.NegativeInfinitySymbol

Az egyéni formátum minden olyan sztring, amely formátumként van megadva, és nem a fent leírt standard formátumú sztring (Axx) formájában van megadva. Az alábbi táblázat az egyéni formátumok készítéséhez használt karaktereket ismerteti.

Format Specifier Leírás
0 (nulla)

Nulla helyőrző: Ha a formázott értéknek van egy számjegye abban a pozícióban, ahol a "0" egyéni formátumban jelenik meg, akkor a program ezt a számjegyet a kimeneti sztringbe másolja, ellenkező esetben a kimeneti sztringben egy nulla van tárolva ebben a pozícióban. A bal szélső "0" pozíciója a tizedeselválasztó előtt, a jobb szélső "0" pedig a tizedeselválasztó után határozza meg a kimeneti sztringben mindig jelen lévő számjegyek tartományát.

A tizedesjelet követő nulla és/vagy számjegy helyőrzők száma határozza meg a tizedeselválasztó után megjelenő számjegyek számát. Az értékek szükség szerint kerekítve lesznek.
#

Számjegy helyőrzője: Ha a formázott értéknek van egy számjegye abban a pozícióban, ahol az egyéni formátumban egy "#" jelenik meg, akkor a program ezt a számjegyet a kimeneti sztringbe másolja; ellenkező esetben a kimeneti sztringben semmi sem található ebben a pozícióban. Vegye figyelembe, hogy ez a kijelölő soha nem tárolja a "0" karaktert, ha nem jelentős számjegy, még akkor sem, ha a sztringben a "0" az egyetlen számjegy. (A kimeneti sztringben a "0" karakter jelenik meg, ha jelentős számjegy.)

A tizedesjelet követő nulla és/vagy számjegy helyőrzők száma határozza meg a tizedeselválasztó után megjelenő számjegyek számát. Az értékek szükség szerint kerekítve lesznek.
. (időszak) Decimális elválasztó: A bal legtöbb "." a formátumsztring karaktere határozza meg a decimális elválasztó helyét a formázott értékben; bármilyen további "." karakterek figyelmen kívül hagyása. A System.Globalization.NumberFormatInfo.NumberDecimalSeparator tulajdonság határozza meg a tizedesjelként használt szimbólumot.
, (vessző)

Csoportelválasztó és számskálázás: A "," karakter két célt szolgál. Először is, ha az egyéni formátum két Nulla vagy Számjegy helyőrző (0 vagy #) és a tizedeselválasztótól balra található karakter között tartalmazza ezt a karaktert, akkor a kimenetben a tizedeselválasztótól balra lévő számjegycsoportok között csoportelválasztók lesznek beszúrva. System.Globalization.NumberFormatInfo.NumberGroupSeparator A System.Globalization.NumberFormatInfo.NumberGroupSizes tulajdonságok határozzák meg a csoportelválasztóként használt szimbólumot, illetve az egyes csoportok számjegyeinek számát.

Ha a formátumsztring egy vagy több "," karaktert tartalmaz közvetlenül a tizedeselválasztótól balra, akkor a szám skálázva lesz. A skálázási tényezőt a tizedesjel elválasztójelétől közvetlenül balra lévő csoportelválasztó karakterek száma határozza meg. Ha vannak x karakterek, akkor az érték 1000X-tal lesz osztva a formázás előtt. A "0" formátumsztring például egymillióval osztja el az értéket. Vegye figyelembe, hogy a skálázást jelző "," karakter jelenléte nem szúr be csoportelválasztókat a kimeneti sztringbe. Így egy szám 1 millióval való skálázásához és csoportelválasztók beszúrásához használjon a "#,##0," formátumhoz hasonló egyéni formátumot.
% (százalék) Százalékos helyőrző: A(z) "%" karakter jelenléte egyéni formátumban azt eredményezi, hogy a szám megszorozva lesz 100-mal a formázás előtt. A százalék szimbólum be lesz szúrva a kimeneti sztringbe azon a helyen, ahol a (%) megjelenik a formátumsztringben. A System.Globalization.NumberFormatInfo.PercentSymbol tulajdonság határozza meg a százalékszimbólumot.

E0

E+0

E-0

e0

e+0

e-0

 Mérnöki formátum: Ha az "E", "E+", "E-", "e", "e+" vagy "e-" sztringek bármelyike egyéni formátumban van jelen, és legalább egy "0" karakter követi, akkor az érték tudományos jelöléssel van formázva. A kitevő előtagot (E vagy e) követő "0" karakterszám határozza meg a kitevőben lévő számjegyek minimális számát. Az "E+" és az "e+" formátum azt jelzi, hogy a pozitív vagy negatív számszimbólum mindig megelőzi a kitevőt. Az "E", "E-", "e" vagy "e-" formátum azt jelzi, hogy a negatív számszimbólum megelőzi a negatív kitevőket; egyetlen szimbólum sem előzi meg a pozitív kitevőket. A pozitív szám szimbólumot a System.Globalization.NumberFormatInfo.PositiveSign tulajdonság adja meg. A negatív számszimbólumot a System.Globalization.NumberFormatInfo.NegativeSign tulajdonság adja meg.
\ (fordított perjel) Escape karakter: Egyes nyelvekben(például C#) a fordított perjel karakter az egyéni formátumban lévő következő karaktert feloldósorozatként értelmezi. C nyelvformázási szekvenciákhoz, például "\n" (newline) használják. Bizonyos nyelvekben magát a feloldó karaktert elő kell előznie egy feloldó karakternek, ha konstansként használják. Ellenkező esetben a fordító feloldósorozatként értelmezi a karaktert. Ezt a feloldó karaktert nem kell minden programozási nyelven támogatni.

'ABC'

"ABC"

 Literális sztring: Az egy- vagy dupla idézőjelek közé zárt karaktereket a program szó szerint átmásolja a kimeneti sztringbe, és nem befolyásolja a formázást.
; (pontosvessző) Szakaszelválasztó: A ";" karakter a pozitív, negatív és nulla számokat tartalmazó szakaszok elválasztására szolgál a formátumsztringben. (Ezt a funkciót az alábbiakban részletesen ismertetjük.)
Egyéb Minden más karakter: A kimeneti sztringben minden más karaktert a rendszer literálként tárol abban a pozícióban, amelyben azok megjelennek.

Vegye figyelembe, hogy rögzítettpontos formátumú sztringek (az "E0", "E+0", "E-0", "e0", "e+0" vagy "e-0" sztringeket nem tartalmazó sztringek) esetében a számok annyi tizedesjegyre vannak kerekítve, mint a tizedeselválasztótól jobbra található Nulla vagy Számjegy helyőrzők. Ha az egyéni formátum nem tartalmaz decimális elválasztójelet, a szám a legközelebbi egész számra lesz kerekítve. Ha a számnak több számjegye van, mint a tizedeselválasztótól balra található Nulla vagy Számjegy helyőrzők, a további számjegyeket a program közvetlenül az első Nulla vagy Számjegy helyőrző előtt másolja a kimeneti sztringbe.

Az egyéni formátum legfeljebb három szakaszt tartalmazhat szakaszelválasztó karakterekkel elválasztva, így különböző formázást adhat meg a pozitív, negatív és nulla értékekhez. A szakaszok értelmezése a következő:

  • Egy szakasz: Az egyéni formátum minden értékre vonatkozik (pozitív, negatív és nulla). A negatív értékek negatív előjelet tartalmaznak.

  • Két szakasz: Az első szakasz pozitív értékekre és nullákra, a második pedig a negatív értékekre vonatkozik. Ha a formázandó érték negatív, de a második szakasz formátuma szerinti kerekítés után nullává válik, akkor az eredményül kapott nulla az első szakasz szerint lesz formázva. A negatív értékek nem tartalmaznak negatív előjelet, így teljes mértékben szabályozható a negatív értékek ábrázolása. A negatívok például zárójelben is megjeleníthetők a "####.#; formátumhoz hasonló egyéni formátummal; (####.####)’.

  • Három szakasz: Az első szakasz a pozitív értékekre, a második a negatív értékekre, a harmadik pedig a nullákra vonatkozik. A második szakasz lehet üres (a pontosvesszők között semmi sem jelenik meg), ebben az esetben az első szakasz az összes nemzero értékre vonatkozik, a negatív értékek pedig negatív előjelet tartalmaznak. Ha a formázandó szám nem nulla, de az első vagy a második szakasz formátuma szerinti kerekítés után nullává válik, akkor az eredményül kapott nulla a harmadik szakasz szerint lesz formázva.

A System.Enum típusok formátumkijelölőkkel System.DateTime is támogatják az értékek sztringreprezentációinak formázását. Egy adott formátumjelölő jelentése a formázandó adatok típusától (numerikus, dátum/idő, enumerálás) függően változik. Tekintse meg és System.Enum tekintse meg System.Globalization.DateTimeFormatInfo az egyes típusok által támogatott formátumjelölők átfogó listáját.

C.5 kódtártípus rövidítései

Ebben a specifikációban az alábbi kódtártípusokra hivatkozunk. Az alábbiakban felsoroljuk az ilyen típusok teljes nevét, beleértve a globális névtér-minősítőt is. Ebben a specifikációban ezek a típusok teljes névként jelennek meg; a globális névtér-minősítő ki van hagyva; vagy egy egyszerű, nem minősített típusnévként, a névtér kihagyása mellett. Például a típus ICollection<T>, ha ebben a specifikációban használatos, mindig a típust global::System.Collections.Generic.ICollection<T>jelenti.

  • global::System.Action
  • global::System.ArgumentException
  • global::System.ArithmeticException
  • global::System.Array
  • global::System.ArrayTypeMisMatchException
  • global::System.Attribute
  • global::System.AttributeTargets
  • global::System.AttributeUsageAttribute
  • global::System.Boolean
  • global::System.Byte
  • global::System.Char
  • global::System.Decimal
  • global::System.Delegate
  • global::System.DivideByZeroException
  • global::System.Double
  • global::System.Enum
  • global::System.Exception
  • global::System.FormattableString
  • global::System.GC
  • global::System.IAsyncDisposable
  • global::System.IDisposable
  • global::System.IFormattable
  • global::System.IndexOutOfRangeException
  • global::System.Int16
  • global::System.Int32
  • global::System.Int64
  • global::System.IntPtr
  • global::System.InvalidCastException
  • global::System.InvalidOperationException
  • global::System.NotSupportedException
  • global::System.Nullable<T>
  • global::System.NullReferenceException
  • global::System.Object
  • global::System.ObsoleteAttribute
  • global::System.OperationCanceledException
  • global::System.OutOfMemoryException
  • global::System.OverflowException
  • global::System.ReadOnlySpan
  • global::System.SByte
  • global::System.Single
  • global::System.Span
  • global::System.StackOverflowException
  • global::System.String
  • global::System.SystemException
  • global::System.Type
  • global::System.TypeInitializationException
  • global::System.UInt16
  • global::System.UInt32
  • global::System.UInt64
  • global::System.UIntPtr
  • global::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.ValueType
  • global::System.Collections.ICollection
  • global::System.Collections.IEnumerable
  • global::System.Collections.IEnumerator
  • global::System.Collections.IList
  • global::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.ConditionalAttribute
  • global::System.Diagnostics.CodeAnalysis.AllowNullAttribute
  • global::System.Diagnostics.CodeAnalysis.DisallowNullAttribute
  • global::System.Diagnostics.CodeAnalysis.DoesNotReturnAttribute
  • global::System.Diagnostics.CodeAnalysis.DoesNotReturnIfAttribute
  • global::System.Diagnostics.CodeAnalysis.MaybeNullAttribute
  • global::System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute
  • global::System.Diagnostics.CodeAnalysis.NotNullAttribute
  • global::System.Diagnostics.CodeAnalysis.NotNullIfNotNullAttribute
  • global::System.Diagnostics.CodeAnalysis.NotNullWhenAttribute
  • global::System.Linq.Expressions.Expression<TDelegate>
  • global::System.Reflection.MemberInfo
  • global::System.Runtime.CompilerServices.AsyncMethodBuilderAttribute
  • global::System.Runtime.CompilerServices.CallerFileAttribute
  • global::System.Runtime.CompilerServices.CallerLineNumberAttribute
  • global::System.Runtime.CompilerServices.CallerMemberNameAttribute
  • global::System.Runtime.CompilerServices.FormattableStringFactory
  • global::System.Runtime.CompilerServices.ICriticalNotifyCompletion
  • global::System.Runtime.CompilerServices.IndexerNameAttribute
  • global::System.Runtime.CompilerServices.INotifyCompletion
  • global::System.Runtime.CompilerServices.TaskAwaiter
  • global::System.Runtime.CompilerServices.TaskAwaiter<T>
  • global::System.Runtime.CompilerServices.ValueTaskAwaiter
  • global::System.Runtime.CompilerServices.ValueTaskAwaiter<TResult>
  • global::System.Runtime.CompilerServices.Unsafe
  • global::System.Threading.Monitor
  • global::System.Threading.Tasks.Task
  • global::System.Threading.Tasks.Task<TResult>

Az informatív szöveg vége.