Megjegyzés
Az oldalhoz való hozzáféréshez engedély szükséges. Megpróbálhat bejelentkezni vagy módosítani a címtárat.
Az oldalhoz való hozzáféréshez engedély szükséges. Megpróbálhatja módosítani a címtárat.
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. A (C.2.)-ben azonosított típusok és azok tagjai 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. A típusok és azok tagjainak a C.2. §-ban meghatározottakon túl szükséges listájáért lásd a §C.3-at.
Megjegyzés: A parancssori felület kódtár API-jának egy részhalmazának bevezetése nem hoz létre függőséget magáról a parancssori felületről; megfelelő implementációt nem kell a parancssori felületre építeni vagy célként megadni.
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
structalábbi típus rendelkezik areadonlymó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 ArgumentOutOfRangeException : ArgumentException
{
public ArgumentOutOfRangeException(string? paramName);
public ArgumentOutOfRangeException(string? paramName, string? message);
}
public class ArithmeticException : Exception
{
public ArithmeticException();
public ArithmeticException(string? message);
public ArithmeticException(string? message, Exception? innerException);
}
public abstract class Array : IList, ICollection, IEnumerable
{
public int Length { get; }
public int Rank { get; }
public int GetLength(int dimension);
}
public class ArrayTypeMismatchException : Exception
{
public ArrayTypeMismatchException();
public ArrayTypeMismatchException(string? message);
public ArrayTypeMismatchException(string? message,
Exception? innerException);
}
[AttributeUsageAttribute(AttributeTargets.All, Inherited = true,
AllowMultiple = false)]
public abstract class Attribute
{
protected Attribute();
}
public enum AttributeTargets
{
Assembly = 0x1,
Module = 0x2,
Class = 0x4,
Struct = 0x8,
Enum = 0x10,
Constructor = 0x20,
Method = 0x40,
Property = 0x80,
Field = 0x100,
Event = 0x200,
Interface = 0x400,
Parameter = 0x800,
Delegate = 0x1000,
ReturnValue = 0x2000,
GenericParameter = 0x4000,
All = 0x7FFF
}
[AttributeUsageAttribute(AttributeTargets.Class, Inherited = true)]
public sealed class AttributeUsageAttribute : Attribute
{
public AttributeUsageAttribute(AttributeTargets validOn);
public bool AllowMultiple { get; set; }
public bool Inherited { get; set; }
public AttributeTargets ValidOn { get; }
}
public readonly struct Boolean { }
public readonly struct Byte { }
public readonly struct Char { }
public readonly struct Decimal { }
public abstract class Delegate { }
public class DivideByZeroException : ArithmeticException
{
public DivideByZeroException();
public DivideByZeroException(string? message);
public DivideByZeroException(string? message, Exception? innerException);
}
public readonly struct Double { }
public abstract class Enum : ValueType
{
protected Enum();
}
public class Exception
{
public Exception();
public Exception(string? message);
public Exception(string? message, Exception? innerException);
public Exception? InnerException { get; }
public virtual string Message { get; }
}
public static class GC { }
public interface IDisposable
{
void Dispose();
}
public interface IEquatable<T>
{
bool Equals(T? other);
}
public interface IFormattable { }
public sealed class IndexOutOfRangeException : Exception
{
public IndexOutOfRangeException();
public IndexOutOfRangeException(string? message);
public IndexOutOfRangeException(string? message,
Exception? innerException);
}
public readonly struct Int16 { }
public readonly struct Int32 { }
public readonly struct Int64 { }
public readonly struct IntPtr { }
public class InvalidCastException : Exception
{
public InvalidCastException();
public InvalidCastException(string? message);
public InvalidCastException(string? message, Exception? innerException);
}
public class InvalidOperationException : Exception
{
public InvalidOperationException();
public InvalidOperationException(string? message);
public InvalidOperationException(string? message,
Exception? innerException);
}
public class NotSupportedException : Exception
{
public NotSupportedException();
public NotSupportedException(string? message);
public NotSupportedException(string? message,
Exception? innerException);
}
public struct Nullable<T> where T : struct
{
public bool HasValue { get; }
public T Value { get; }
}
public class NullReferenceException : Exception
{
public NullReferenceException();
public NullReferenceException(string? message);
public NullReferenceException(string? message, Exception? innerException);
}
public class Object
{
public Object();
~Object();
public virtual bool Equals(object? obj);
public virtual int GetHashCode();
public Type GetType();
public virtual string? ToString();
}
[AttributeUsageAttribute(AttributeTargets.Class | AttributeTargets.Struct |
AttributeTargets.Enum | AttributeTargets.Interface |
AttributeTargets.Constructor | AttributeTargets.Method |
AttributeTargets.Property | AttributeTargets.Field |
AttributeTargets.Event | AttributeTargets.Delegate, Inherited = false)]
public sealed class ObsoleteAttribute : Attribute
{
public ObsoleteAttribute();
public ObsoleteAttribute(string? message);
public ObsoleteAttribute(string? message, bool error);
public bool IsError { get; }
public string? Message { get; }
}
public class OutOfMemoryException : Exception
{
public OutOfMemoryException();
public OutOfMemoryException(string? message);
public OutOfMemoryException(string? message, Exception? innerException);
}
public class OverflowException : ArithmeticException
{
public OverflowException();
public OverflowException(string? message);
public OverflowException(string? message, Exception? innerException);
}
public readonly struct SByte { }
public readonly struct Single { }
public sealed class StackOverflowException : Exception
{
public StackOverflowException();
public StackOverflowException(string? message);
public StackOverflowException(string? message, Exception? innerException);
}
public sealed class String : IEnumerable<char>, IEnumerable
{
public int Length { get; }
public char this [int index] { get; }
public static string Format(string format, params object?[] args);
System.Collections.IEnumerator IEnumerable.GetEnumerator();
System.Collections.Generic.IEnumerator<char> IEnumerable<char>.GetEnumerator();
}
public class SystemException : Exception
{
public SystemException();
public SystemException(string? message);
public SystemException(string? message, Exception? innerException);
}
public abstract class Type : MemberInfo { }
public sealed class TypeInitializationException : Exception
{
public TypeInitializationException(string fullTypeName,
Exception? innerException);
}
public readonly struct UInt16 { }
public readonly struct UInt32 { }
public readonly struct UInt64 { }
public readonly struct UIntPtr { }
public abstract class ValueType
{
protected ValueType();
}
}
namespace System.Collections
{
public interface ICollection : IEnumerable
{
int Count { get; }
bool IsSynchronized { get; }
object SyncRoot { get; }
void CopyTo(Array array, int index);
}
public interface IEnumerable
{
IEnumerator GetEnumerator();
}
public interface IEnumerator
{
object Current { get; }
bool MoveNext();
void Reset();
}
public interface IList : ICollection, IEnumerable
{
bool IsFixedSize { get; }
bool IsReadOnly { get; }
object? this [int index] { get; set; }
int Add(object? value);
void Clear();
bool Contains(object? value);
int IndexOf(object? value);
void Insert(int index, object? value);
void Remove(object? value);
void RemoveAt(int index);
}
}
namespace System.Collections.Generic
{
public interface ICollection<T> : IEnumerable<T>
{
int Count { get; }
bool IsReadOnly { get; }
void Add(T item);
void Clear();
bool Contains(T item);
void CopyTo(T[] array, int arrayIndex);
bool Remove(T item);
}
public interface IEnumerable<T> : IEnumerable
{
IEnumerator<T> GetEnumerator();
}
public interface IEnumerator<T> : IDisposable, IEnumerator
{
T Current { get; }
}
public interface IList<T> : ICollection<T>
{
T this [int index] { get; set; }
int IndexOf(T item);
void Insert(int index, T item);
void RemoveAt(int index);
}
}
namespace System.Diagnostics
{
[AttributeUsageAttribute(AttributeTargets.Method | AttributeTargets.Class,
AllowMultiple = true)]
public sealed class ConditionalAttribute : Attribute
{
public ConditionalAttribute(string conditionString);
public string ConditionString { get; }
}
}
namespace System.Reflection
{
public abstract class MemberInfo
{
protected MemberInfo();
}
}
namespace System.Runtime.CompilerServices
{
public sealed class IndexerNameAttribute : Attribute
{
public IndexerNameAttribute(string indexerName);
}
public static class Unsafe
{
public static ref T NullRef<T>();
}
}
namespace System.Threading
{
public static class Monitor
{
public static void Enter(object obj);
public static void Exit(object obj);
}
}
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);
}
/// <summary>
/// A read-only value type which represents an abstract
/// index to be used with collections.
/// - The Index can be relative to the start or end of a
/// collection.
/// - An Index can be converted to a zero-based concrete
/// from-start index to be used with a collection
/// of some specified length.
/// - Equality between Index values is provided, however
/// unlike concrete indices they are not ordered.
/// - Array and String element access support indexing
/// with Index values.
/// </summary>
public readonly struct Index : IEquatable<Index>
{
/// <summary>
/// Construct an Index from an integer value and a
/// boolean indicating whether the value is relative
/// to the end (true) or start (false).
/// </summary>
/// <param name="value">
/// The value, must be ≥ 0.
/// </param>
/// <param name="fromEnd">
/// Optional boolean indicating whether the Index is
/// relative to the end (true) or start (false).
/// The default value is false.
/// </param>
/// <exception cref="ArgumentOutOfRangeException">
/// Thrown if value < 0.
/// </exception>
/// <remarks>
/// If the Index is relative to the start then:
/// - the value 0 refers to the first element.
/// If the Index is relative to the end then:
/// - the value 1 refers to the last element; and
/// - the value 0 refers to beyond last element.
/// </remarks>
public Index(int value, bool fromEnd = false);
/// <summary>
/// Implicit conversion from integer to a
/// from-start Index.
/// </summary>
/// <remarks>
/// The predefined operator:
/// <c>Index operator ^(int value);</c>
/// is provided to convert from integer to a
/// from-end Index.
/// </remarks>
public static implicit operator Index(int value);
/// <summary>
/// Return the value.
/// </summary>
public int Value { get; }
/// <summary>
/// Return whether the Index is relative to
/// the end (true) or start (false).
/// </summary>
public bool IsFromEnd { get; }
/// <summary>
/// Return a concrete from-start index for a
/// given collection length.
/// </summary>
/// <param name="length">
/// The length of the collection that the index
/// will be used with.
/// </param>
/// <remarks>
/// This method performs no sanity checking and
/// will never throw an IndexOutOfRangeException.
/// It is expected that the returned index will be
/// used with a collection which will do validation.
/// </remarks>
public int GetOffset(int length);
/// <summary>
/// Indicates whether the current Index value is
/// equal to another Index value.
/// </summary>
/// <param name="other">
/// The value to compare with this Index.
/// </param>
public bool Equals(Index other);
}
/// <summary>
/// A read-only value type which represents a range of
/// abstract indices to be used with collections.
/// - The Range has two Index properties, Start and End.
/// - A Range can be converted to a concrete index from
/// the start and a length value to be used with a
/// collection of some specified length.
/// - Equality between Range values is provided,
/// however they are not ordered.
/// - Array and String element access supports indexing
/// with Range values, returning a sub-array/substring
/// of the indexed value respectively.
/// </summary>
public readonly struct Range : IEquatable<Index>
{
/// <summary>
/// Construct a Range from two Index values.
/// </summary>
/// <param name="start">
/// The inclusive Index value for the start
/// of the range.
/// </param>
/// <param name="end">
/// The exclusive Index value for the end
/// of the range.</param>
/// <remarks>
/// As Index values represent unordered abstract
/// indices no sanity checking can be performed
/// on the resultant Range value,
/// <see cref="GetOffsetAndLength">".
///
/// The predefined operator:
/// <c>Range operator ..(Index start, Index end);</c>
/// also exists to create a Range value.
/// </remarks>
public Range(Index start, Index end);
/// <summary>Return the starting Index.</summary>
public Index Start { get; }
/// <summary>Return the ending Index.</summary>
public Index End { get; }
/// <summary>
/// Return a concrete from-start index and the
/// range length for a given collection length.
/// </summary>
/// <param name="length">
/// The length of the collection that the result
/// will be used with.
/// </param>
/// <exception cref="ArgumentOutOfRangeException">
/// Thrown if the range is not valid wrt length.
/// </exception>
/// <returns>
/// A tuple consisting of an index value and range length
/// </returns>
public (int Offset, int Length) GetOffsetAndLength(int length);
/// <summary>
/// Indicates whether the current Range value is equal
/// to another Range value.
/// </summary>
/// <param name="other">
/// The value to compare with this Range.
/// </param>
public bool Equals(Range other);
}
public readonly ref struct ReadOnlySpan<T>
{
public int Length { get; }
public ref readonly T this[int index] { get; }
}
public readonly ref struct Span<T>
{
public int Length { get; }
public ref T this[int index] { get; }
public static implicit operator ReadOnlySpan<T>(Span<T> span);
}
public struct ValueTuple<T1>
{
public T1 Item1;
public ValueTuple(T1 item1);
}
public struct ValueTuple<T1, T2>
{
public T1 Item1;
public T2 Item2;
public ValueTuple(T1 item1, T2 item2);
}
public struct ValueTuple<T1, T2, T3>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public ValueTuple(T1 item1, T2 item2, T3 item3);
}
public struct ValueTuple<T1, T2, T3, T4>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public T4 Item4;
public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4);
}
public struct ValueTuple<T1, T2, T3, T4, T5>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public T4 Item4;
public T5 Item5;
public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5);
}
public struct ValueTuple<T1, T2, T3, T4, T5, T6>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public T4 Item4;
public T5 Item5;
public T6 Item6;
public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5,
T6 item6);
}
public struct ValueTuple<T1, T2, T3, T4, T5, T6, T7>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public T4 Item4;
public T5 Item5;
public T6 Item6;
public T7 Item7;
public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5,
T6 item6, T7 item7);
}
public struct ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public T4 Item4;
public T5 Item5;
public T6 Item6;
public T7 Item7;
public TRest Rest;
public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5,
T6 item6, T7 item7, TRest rest);
}
public interface IAsyncDisposable
{
public System.Threading.Tasks.ValueTask DisposeAsync();
}
}
namespace System.Collections.Generic
{
public interface IReadOnlyCollection<out T> : IEnumerable<T>
{
int Count { get; }
}
public interface IReadOnlyList<out T> : IReadOnlyCollection<T>
{
T this [int index] { get; }
}
public interface IAsyncEnumerable<out T>
{
IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken token = default);
}
public interface IAsyncEnumerator<out T> : IAsyncDisposable
{
ValueTask<bool> MoveNextAsync();
T Current { get; }
}
}
namespace System.Diagnostics.CodeAnalysis
{
[System.AttributeUsage(System.AttributeTargets.Field |
System.AttributeTargets.Parameter | System.AttributeTargets.Property,
Inherited=false)]
public sealed class AllowNullAttribute : Attribute
{
public AllowNullAttribute() { }
}
[System.AttributeUsage(System.AttributeTargets.Field |
System.AttributeTargets.Parameter | System.AttributeTargets.Property,
Inherited=false)]
public sealed class DisallowNullAttribute : Attribute
{
public DisallowNullAttribute() {}
}
[System.AttributeUsage(System.AttributeTargets.Method, Inherited=false)]
public sealed class DoesNotReturnAttribute : Attribute
{
public DoesNotReturnAttribute() {}
}
[System.AttributeUsage(System.AttributeTargets.Parameter, Inherited=false)]
public sealed class DoesNotReturnIfAttribute : Attribute
{
public DoesNotReturnIfAttribute(bool parameterValue) {}
}
[System.AttributeUsage(System.AttributeTargets.Field |
System.AttributeTargets.Parameter | System.AttributeTargets.Property |
System.AttributeTargets.ReturnValue, Inherited=false)]
public sealed class MaybeNullAttribute : Attribute
{
public MaybeNullAttribute() {}
}
[System.AttributeUsage(System.AttributeTargets.Parameter, Inherited=false)]
public sealed class MaybeNullWhenAttribute : Attribute
{
public MaybeNullWhenAttribute(bool returnValue) {}
}
[System.AttributeUsage(System.AttributeTargets.Field |
System.AttributeTargets.Parameter | System.AttributeTargets.Property |
System.AttributeTargets.ReturnValue, Inherited=false)]
public sealed class NotNullAttribute : Attribute
{
public NotNullAttribute() {}
}
[System.AttributeUsage(System.AttributeTargets.Parameter |
System.AttributeTargets.Property | System.AttributeTargets.ReturnValue,
AllowMultiple=true, Inherited=false)]
public sealed class NotNullIfNotNullAttribute : Attribute
{
public NotNullIfNotNullAttribute(string parameterName) {}
}
[System.AttributeUsage(System.AttributeTargets.Parameter, Inherited=false)]
public sealed class NotNullWhenAttribute : Attribute
{
public NotNullWhenAttribute(bool returnValue) {}
}
}
namespace System.Linq.Expressions
{
public sealed class Expression<TDelegate>
{
public TDelegate Compile();
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct |
AttributeTargets.Interface,
Inherited = false, AllowMultiple = false)]
public sealed class AsyncMethodBuilderAttribute : Attribute
{
public AsyncMethodBuilderAttribute(Type builderType) {}
public Type BuilderType { get; }
}
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
public sealed class CallerFilePathAttribute : Attribute
{
public CallerFilePathAttribute() { }
}
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
public sealed class CallerLineNumberAttribute : Attribute
{
public CallerLineNumberAttribute() { }
}
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
public sealed class CallerMemberNameAttribute : Attribute
{
public CallerMemberNameAttribute() { }
}
[System.AttributeUsage(System.AttributeTargets.Parameter, Inherited=false)]
public sealed class EnumeratorCancellationAttribute : Attribute
{
public EnumeratorCancellationAttribute() {}
}
public static class FormattableStringFactory
{
public static FormattableString Create(string format,
params object?[] arguments);
}
public interface ICriticalNotifyCompletion : INotifyCompletion
{
void UnsafeOnCompleted(Action continuation);
}
public interface INotifyCompletion
{
void OnCompleted(Action continuation);
}
public readonly struct TaskAwaiter : ICriticalNotifyCompletion,
INotifyCompletion
{
public bool IsCompleted { get; }
public void GetResult();
}
public readonly struct TaskAwaiter<TResult> : ICriticalNotifyCompletion,
INotifyCompletion
{
public bool IsCompleted { get; }
public TResult GetResult();
}
public readonly struct ValueTaskAwaiter : ICriticalNotifyCompletion,
INotifyCompletion
{
public bool IsCompleted { get; }
public void GetResult();
}
public readonly struct ValueTaskAwaiter<TResult>
: ICriticalNotifyCompletion, INotifyCompletion
{
public bool IsCompleted { get; }
public TResult GetResult();
}
}
namespace System.Threading
{
public class CancellationTokenSource : IDisposable
{
public CancellationTokenSource();
public System.Threading.CancellationToken Token { get; }
public void Cancel();
public static CancellationTokenSource CreateLinkedTokenSource
(CancellationToken token1,
CancellationToken token2);
}
public readonly struct CancellationToken : IEquatable<CancellationToken>
{
public bool IsCancellationRequested { get; }
}
}
namespace System.Threading.Tasks
{
public class Task
{
public System.Runtime.CompilerServices.TaskAwaiter GetAwaiter();
}
public class Task<TResult> : Task
{
public new System.Runtime.CompilerServices.TaskAwaiter<T> GetAwaiter();
}
public readonly struct ValueTask : System.IEquatable<ValueTask>
{
public System.Runtime.CompilerServices.ValueTaskAwaiter GetAwaiter();
}
public readonly struct ValueTask<TResult>
: System.IEquatable<ValueTask<TResult>>
{
public new System.Runtime.CompilerServices.ValueTaskAwaiter<TResult>
GetAwaiter();
}
}
C.4 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 egySystem.Globalization.NumberFormatInfopéldány. PéldáulSystem.DateTimea használt példányokSystem.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 |
|---|---|
|
Pénznemformátum: Pénzügyi értéket tartalmazó sztringekhez használatos. A
Ha a pontosság-meghatározó nincs megadva, |
|
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 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. |
|
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 Pontosan egy nem nulla tizedesjegy (m) előzi meg a tulajdonság által 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 |
|
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 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 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, |
|
Á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ő:
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:
Minden típushoz:
|
|
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 Legalább egy nem nulla tizedesjegy (d) megelőzi a tulajdonság által A pontosság-meghatározó határozza meg a tizedesjegyek számát (dd... d). Ha a pontosság-meghatározó nincs megadva, |
|
Százalékformátum: Százalékot tartalmazó sztringekhez használatos. A
Ha nincs megadva pontosság, az eredményben szereplő tizedesjegyek számát a függvény határozza meg Az eredmény 100-ra van skálázva (.99-ből 99%). |
|
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. |
|
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.
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. |
|
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. |
|
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.Actionglobal::System.ArgumentExceptionglobal::System.ArgumentOutOfRangeExceptionglobal::System.ArithmeticExceptionglobal::System.Arrayglobal::System.ArrayTypeMisMatchExceptionglobal::System.Attributeglobal::System.AttributeTargetsglobal::System.AttributeUsageAttributeglobal::System.Booleanglobal::System.Byteglobal::System.Charglobal::System.Decimalglobal::System.Delegateglobal::System.DivideByZeroExceptionglobal::System.Doubleglobal::System.Enumglobal::System.Exceptionglobal::System.FormattableStringglobal::System.GCglobal::System.IAsyncDisposableglobal::System.IDisposableglobal::System.IEquatable<T>global::System.IFormattableglobal::System.Indexglobal::System.IndexOutOfRangeExceptionglobal::System.Int16global::System.Int32global::System.Int64global::System.IntPtrglobal::System.InvalidCastExceptionglobal::System.InvalidOperationExceptionglobal::System.NotSupportedExceptionglobal::System.Nullable<T>global::System.NullReferenceExceptionglobal::System.Objectglobal::System.ObsoleteAttributeglobal::System.OperationCanceledExceptionglobal::System.OutOfMemoryExceptionglobal::System.OverflowExceptionglobal::System.Rangeglobal::System.ReadOnlySpanglobal::System.SByteglobal::System.Singleglobal::System.Spanglobal::System.StackOverflowExceptionglobal::System.Stringglobal::System.SystemExceptionglobal::System.Typeglobal::System.TypeInitializationExceptionglobal::System.UInt16global::System.UInt32global::System.UInt64global::System.UIntPtrglobal::System.ValueTuple<T1>global::System.ValueTuple<T1, T2>global::System.ValueTuple<T1, T2, T3>global::System.ValueTuple<T1, T2, T3, T4>global::System.ValueTuple<T1, T2, T3, T4, T5>global::System.ValueTuple<T1, T2, T3, T4, T5, T6>global::System.ValueTuple<T1, T2, T3, T4, T5, T6, T7>global::System.ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest>global::System.ValueTypeglobal::System.Collections.ICollectionglobal::System.Collections.IEnumerableglobal::System.Collections.IEnumeratorglobal::System.Collections.IListglobal::System.Collections.Generic.IAsyncEnumerable<out T>global::System.Collections.Generic.IAsyncEnumerator<out T>global::System.Collections.Generic.ICollection<T>global::System.Collections.Generic.IEnumerable<T>global::System.Collections.Generic.IEnumerator<T>global::System.Collections.Generic.IList<T>global::System.Collections.Generic.IReadonlyCollection<out T>global::System.Collections.Generic.IReadOnlyList<out T>global::System.Diagnostics.ConditionalAttributeglobal::System.Diagnostics.CodeAnalysis.AllowNullAttributeglobal::System.Diagnostics.CodeAnalysis.DisallowNullAttributeglobal::System.Diagnostics.CodeAnalysis.DoesNotReturnAttributeglobal::System.Diagnostics.CodeAnalysis.DoesNotReturnIfAttributeglobal::System.Diagnostics.CodeAnalysis.MaybeNullAttributeglobal::System.Diagnostics.CodeAnalysis.MaybeNullWhenAttributeglobal::System.Diagnostics.CodeAnalysis.NotNullAttributeglobal::System.Diagnostics.CodeAnalysis.NotNullIfNotNullAttributeglobal::System.Diagnostics.CodeAnalysis.NotNullWhenAttributeglobal::System.Linq.Expressions.Expression<TDelegate>global::System.Reflection.MemberInfoglobal::System.Runtime.CompilerServices.AsyncMethodBuilderAttributeglobal::System.Runtime.CompilerServices.CallerFileAttributeglobal::System.Runtime.CompilerServices.CallerLineNumberAttributeglobal::System.Runtime.CompilerServices.CallerMemberNameAttributeglobal::System.Runtime.CompilerServices.FormattableStringFactoryglobal::System.Runtime.CompilerServices.ICriticalNotifyCompletionglobal::System.Runtime.CompilerServices.IndexerNameAttributeglobal::System.Runtime.CompilerServices.INotifyCompletionglobal::System.Runtime.CompilerServices.TaskAwaiterglobal::System.Runtime.CompilerServices.TaskAwaiter<T>global::System.Runtime.CompilerServices.ValueTaskAwaiterglobal::System.Runtime.CompilerServices.ValueTaskAwaiter<TResult>global::System.Runtime.CompilerServices.Unsafeglobal::System.Threading.Monitorglobal::System.Threading.Tasks.Taskglobal::System.Threading.Tasks.Task<TResult>
Az informatív szöveg vége.
Dolgozzon együtt velünk a GitHubon
A tartalom forrása a GitHubon található, ahol létrehozhat és áttekinthet problémákat és lekéréses kérelmeket is. További információért tekintse meg a közreműködői útmutatónkat.
ECMA C# draft specification