Not
Bu sayfaya erişim yetkilendirme gerektiriyor. Oturum açmayı veya dizinleri değiştirmeyi deneyebilirsiniz.
Bu sayfaya erişim yetkilendirme gerektiriyor. Dizinleri değiştirmeyi deneyebilirsiniz.
C.1 Genel
Uyumlu bir C# uygulaması, belirli semantiklere sahip en düşük tür kümesini sağlayacaktır. Bu türler ve üyeleri burada ad alanına ve türe göre alfabetik sırada listelenir. (§C.2) içinde tanımlanan türlerin ve üyelerinin resmi tanımı için ISO/IEC 23271:2012 Ortak Dil Altyapısı (CLI), Bölüm IV; Bu belirtime başvuru ile eklenen Temel Sınıf Kitaplığı (BCL), Genişletilmiş SayısalLar Kitaplığı ve Genişletilmiş Dizi Kitaplığı. §C.2'de tanımlananların dışında gerekli türlerin ve üyelerinin listesi için bkz. §C.3.
Not: CLI'nın kitaplık API'sinin bir alt kümesinin benimsenmesi, CLI'nin kendisine bağımlılık oluşturmaz; uyumlu bir uygulamanın CLI üzerinde veya hedefte derlenmesi gerekmez.
Bu metin bilgilendiricidir.
Standart kitaplığın, uyumlu bir C# uygulaması için gereken en düşük tür ve üye kümesi olması amaçlanmıştır. Bu nedenle, yalnızca C# dil belirtiminin açıkça gerektirdiği üyeleri içerir.
Uyumlu bir C# uygulamasının yararlı programların yazılması için önemli ölçüde daha kapsamlı bir kitaplık sağlaması beklenir. Örneğin, uyumlu bir uygulama bu kitaplığı şu şekilde genişletebilir:
- Ad alanları ekleniyor.
- Türler ekleniyor.
- Arabirim olmayan türlere üye ekleme.
- Araya gelen temel sınıflar veya arabirimler ekleme.
- Yapı ve sınıf türlerinin olması ek arabirimler uygular.
- Var olan türlere ve üyelere öznitelikler (
ConditionalAttributedışında) ekleme.
Bilgilendirici metnin sonu.
ISO/IEC 23271'de tanımlanan C.2 Standart Kitaplık Türleri
Not: Aşağıdaki bazı
structtürlerde değiştirici vardırreadonly. ISO/IEC 23271 yayımlandığında bu değiştirici kullanılamıyordu, ancak bu belirtimin uygulanması için gereklidir. son not
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);
}
}
ISO/IEC 23271'de tanımlanmayan C.3 Standart Kitaplık Türleri
Listelenen üyeler de dahil olmak üzere aşağıdaki türler, uygun bir standart kitaplıkta tanımlanmalıdır. (Bu türler ISO/IEC 23271'in gelecekteki bir sürümünde tanımlanabilir.) Bu türlerden birçoğunda listelenenden daha fazla üye olması beklenir.
Uyumlu bir uygulama uzantı yöntemleri olarak ve Task.GetAwaiter() sağlayabilirTask<TResult>.GetAwaiter().
namespace System
{
public interface IAsyncDisposable
{
ValueTask DisposeAsync();
}
public class FormattableString : IFormattable { }
public class OperationCanceledException : Exception
{
public OperationCanceledException();
public OperationCanceledException(string? message);
public OperationCanceledException(string? message, Exception? innerException);
}
/// <summary>
/// A read-only value type which represents an abstract
/// index to be used with collections.
/// - The Index can be relative to the start or end of a
/// collection.
/// - An Index can be converted to a zero-based concrete
/// from-start index to be used with a collection
/// of some specified length.
/// - Equality between Index values is provided, however
/// unlike concrete indices they are not ordered.
/// - Array and String element access support indexing
/// with Index values.
/// </summary>
public readonly struct Index : IEquatable<Index>
{
/// <summary>
/// Construct an Index from an integer value and a
/// boolean indicating whether the value is relative
/// to the end (true) or start (false).
/// </summary>
/// <param name="value">
/// The value, must be ≥ 0.
/// </param>
/// <param name="fromEnd">
/// Optional boolean indicating whether the Index is
/// relative to the end (true) or start (false).
/// The default value is false.
/// </param>
/// <exception cref="ArgumentOutOfRangeException">
/// Thrown if value < 0.
/// </exception>
/// <remarks>
/// If the Index is relative to the start then:
/// - the value 0 refers to the first element.
/// If the Index is relative to the end then:
/// - the value 1 refers to the last element; and
/// - the value 0 refers to beyond last element.
/// </remarks>
public Index(int value, bool fromEnd = false);
/// <summary>
/// Implicit conversion from integer to a
/// from-start Index.
/// </summary>
/// <remarks>
/// The predefined operator:
/// <c>Index operator ^(int value);</c>
/// is provided to convert from integer to a
/// from-end Index.
/// </remarks>
public static implicit operator Index(int value);
/// <summary>
/// Return the value.
/// </summary>
public int Value { get; }
/// <summary>
/// Return whether the Index is relative to
/// the end (true) or start (false).
/// </summary>
public bool IsFromEnd { get; }
/// <summary>
/// Return a concrete from-start index for a
/// given collection length.
/// </summary>
/// <param name="length">
/// The length of the collection that the index
/// will be used with.
/// </param>
/// <remarks>
/// This method performs no sanity checking and
/// will never throw an IndexOutOfRangeException.
/// It is expected that the returned index will be
/// used with a collection which will do validation.
/// </remarks>
public int GetOffset(int length);
/// <summary>
/// Indicates whether the current Index value is
/// equal to another Index value.
/// </summary>
/// <param name="other">
/// The value to compare with this Index.
/// </param>
public bool Equals(Index other);
}
/// <summary>
/// A read-only value type which represents a range of
/// abstract indices to be used with collections.
/// - The Range has two Index properties, Start and End.
/// - A Range can be converted to a concrete index from
/// the start and a length value to be used with a
/// collection of some specified length.
/// - Equality between Range values is provided,
/// however they are not ordered.
/// - Array and String element access supports indexing
/// with Range values, returning a sub-array/substring
/// of the indexed value respectively.
/// </summary>
public readonly struct Range : IEquatable<Index>
{
/// <summary>
/// Construct a Range from two Index values.
/// </summary>
/// <param name="start">
/// The inclusive Index value for the start
/// of the range.
/// </param>
/// <param name="end">
/// The exclusive Index value for the end
/// of the range.</param>
/// <remarks>
/// As Index values represent unordered abstract
/// indices no sanity checking can be performed
/// on the resultant Range value,
/// <see cref="GetOffsetAndLength">".
///
/// The predefined operator:
/// <c>Range operator ..(Index start, Index end);</c>
/// also exists to create a Range value.
/// </remarks>
public Range(Index start, Index end);
/// <summary>Return the starting Index.</summary>
public Index Start { get; }
/// <summary>Return the ending Index.</summary>
public Index End { get; }
/// <summary>
/// Return a concrete from-start index and the
/// range length for a given collection length.
/// </summary>
/// <param name="length">
/// The length of the collection that the result
/// will be used with.
/// </param>
/// <exception cref="ArgumentOutOfRangeException">
/// Thrown if the range is not valid wrt length.
/// </exception>
/// <returns>
/// A tuple consisting of an index value and range length
/// </returns>
public (int Offset, int Length) GetOffsetAndLength(int length);
/// <summary>
/// Indicates whether the current Range value is equal
/// to another Range value.
/// </summary>
/// <param name="other">
/// The value to compare with this Range.
/// </param>
public bool Equals(Range other);
}
public readonly ref struct ReadOnlySpan<T>
{
public int Length { get; }
public ref readonly T this[int index] { get; }
}
public readonly ref struct Span<T>
{
public int Length { get; }
public ref T this[int index] { get; }
public static implicit operator ReadOnlySpan<T>(Span<T> span);
}
public struct ValueTuple<T1>
{
public T1 Item1;
public ValueTuple(T1 item1);
}
public struct ValueTuple<T1, T2>
{
public T1 Item1;
public T2 Item2;
public ValueTuple(T1 item1, T2 item2);
}
public struct ValueTuple<T1, T2, T3>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public ValueTuple(T1 item1, T2 item2, T3 item3);
}
public struct ValueTuple<T1, T2, T3, T4>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public T4 Item4;
public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4);
}
public struct ValueTuple<T1, T2, T3, T4, T5>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public T4 Item4;
public T5 Item5;
public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5);
}
public struct ValueTuple<T1, T2, T3, T4, T5, T6>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public T4 Item4;
public T5 Item5;
public T6 Item6;
public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5,
T6 item6);
}
public struct ValueTuple<T1, T2, T3, T4, T5, T6, T7>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public T4 Item4;
public T5 Item5;
public T6 Item6;
public T7 Item7;
public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5,
T6 item6, T7 item7);
}
public struct ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public T4 Item4;
public T5 Item5;
public T6 Item6;
public T7 Item7;
public TRest Rest;
public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5,
T6 item6, T7 item7, TRest rest);
}
public interface IAsyncDisposable
{
public System.Threading.Tasks.ValueTask DisposeAsync();
}
}
namespace System.Collections.Generic
{
public interface IReadOnlyCollection<out T> : IEnumerable<T>
{
int Count { get; }
}
public interface IReadOnlyList<out T> : IReadOnlyCollection<T>
{
T this [int index] { get; }
}
public interface IAsyncEnumerable<out T>
{
IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken token = default);
}
public interface IAsyncEnumerator<out T> : IAsyncDisposable
{
ValueTask<bool> MoveNextAsync();
T Current { get; }
}
}
namespace System.Diagnostics.CodeAnalysis
{
[System.AttributeUsage(System.AttributeTargets.Field |
System.AttributeTargets.Parameter | System.AttributeTargets.Property,
Inherited=false)]
public sealed class AllowNullAttribute : Attribute
{
public AllowNullAttribute() { }
}
[System.AttributeUsage(System.AttributeTargets.Field |
System.AttributeTargets.Parameter | System.AttributeTargets.Property,
Inherited=false)]
public sealed class DisallowNullAttribute : Attribute
{
public DisallowNullAttribute() {}
}
[System.AttributeUsage(System.AttributeTargets.Method, Inherited=false)]
public sealed class DoesNotReturnAttribute : Attribute
{
public DoesNotReturnAttribute() {}
}
[System.AttributeUsage(System.AttributeTargets.Parameter, Inherited=false)]
public sealed class DoesNotReturnIfAttribute : Attribute
{
public DoesNotReturnIfAttribute(bool parameterValue) {}
}
[System.AttributeUsage(System.AttributeTargets.Field |
System.AttributeTargets.Parameter | System.AttributeTargets.Property |
System.AttributeTargets.ReturnValue, Inherited=false)]
public sealed class MaybeNullAttribute : Attribute
{
public MaybeNullAttribute() {}
}
[System.AttributeUsage(System.AttributeTargets.Parameter, Inherited=false)]
public sealed class MaybeNullWhenAttribute : Attribute
{
public MaybeNullWhenAttribute(bool returnValue) {}
}
[System.AttributeUsage(System.AttributeTargets.Field |
System.AttributeTargets.Parameter | System.AttributeTargets.Property |
System.AttributeTargets.ReturnValue, Inherited=false)]
public sealed class NotNullAttribute : Attribute
{
public NotNullAttribute() {}
}
[System.AttributeUsage(System.AttributeTargets.Parameter |
System.AttributeTargets.Property | System.AttributeTargets.ReturnValue,
AllowMultiple=true, Inherited=false)]
public sealed class NotNullIfNotNullAttribute : Attribute
{
public NotNullIfNotNullAttribute(string parameterName) {}
}
[System.AttributeUsage(System.AttributeTargets.Parameter, Inherited=false)]
public sealed class NotNullWhenAttribute : Attribute
{
public NotNullWhenAttribute(bool returnValue) {}
}
}
namespace System.Linq.Expressions
{
public sealed class Expression<TDelegate>
{
public TDelegate Compile();
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct |
AttributeTargets.Interface,
Inherited = false, AllowMultiple = false)]
public sealed class AsyncMethodBuilderAttribute : Attribute
{
public AsyncMethodBuilderAttribute(Type builderType) {}
public Type BuilderType { get; }
}
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
public sealed class CallerFilePathAttribute : Attribute
{
public CallerFilePathAttribute() { }
}
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
public sealed class CallerLineNumberAttribute : Attribute
{
public CallerLineNumberAttribute() { }
}
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
public sealed class CallerMemberNameAttribute : Attribute
{
public CallerMemberNameAttribute() { }
}
[System.AttributeUsage(System.AttributeTargets.Parameter, Inherited=false)]
public sealed class EnumeratorCancellationAttribute : Attribute
{
public EnumeratorCancellationAttribute() {}
}
public static class FormattableStringFactory
{
public static FormattableString Create(string format,
params object?[] arguments);
}
public interface ICriticalNotifyCompletion : INotifyCompletion
{
void UnsafeOnCompleted(Action continuation);
}
public interface INotifyCompletion
{
void OnCompleted(Action continuation);
}
public readonly struct TaskAwaiter : ICriticalNotifyCompletion,
INotifyCompletion
{
public bool IsCompleted { get; }
public void GetResult();
}
public readonly struct TaskAwaiter<TResult> : ICriticalNotifyCompletion,
INotifyCompletion
{
public bool IsCompleted { get; }
public TResult GetResult();
}
public readonly struct ValueTaskAwaiter : ICriticalNotifyCompletion,
INotifyCompletion
{
public bool IsCompleted { get; }
public void GetResult();
}
public readonly struct ValueTaskAwaiter<TResult>
: ICriticalNotifyCompletion, INotifyCompletion
{
public bool IsCompleted { get; }
public TResult GetResult();
}
}
namespace System.Threading
{
public class CancellationTokenSource : IDisposable
{
public CancellationTokenSource();
public System.Threading.CancellationToken Token { get; }
public void Cancel();
public static CancellationTokenSource CreateLinkedTokenSource
(CancellationToken token1,
CancellationToken token2);
}
public readonly struct CancellationToken : IEquatable<CancellationToken>
{
public bool IsCancellationRequested { get; }
}
}
namespace System.Threading.Tasks
{
public class Task
{
public System.Runtime.CompilerServices.TaskAwaiter GetAwaiter();
}
public class Task<TResult> : Task
{
public new System.Runtime.CompilerServices.TaskAwaiter<T> GetAwaiter();
}
public readonly struct ValueTask : System.IEquatable<ValueTask>
{
public System.Runtime.CompilerServices.ValueTaskAwaiter GetAwaiter();
}
public readonly struct ValueTask<TResult>
: System.IEquatable<ValueTask<TResult>>
{
public new System.Runtime.CompilerServices.ValueTaskAwaiter<TResult>
GetAwaiter();
}
}
C.4 Biçim Belirtimleri
İlişkili dize ifadelerinde (§12.8.3) kullanılan biçimlerin anlamı ISO/IEC 23271:2012'de tanımlanır. Kolaylık olması için, aşağıdaki metin açıklamasından System.IFormattablekopyalanır.
Bu metin bilgilendiricidir.
Biçim, bir dizeye dönüştürüldüğünde nesnenin görünümünü açıklayan bir dizedir. Standart veya özel biçimler kullanılabilir. Standart biçim Axx biçimini alır; burada A, biçim tanımlayıcısı olarak adlandırılan tek bir alfabetik karakterdir ve xx, duyarlık belirtici olarak adlandırılan sıfır ile 99 (dahil) arasında bir tamsayıdır. Biçim tanımlayıcısı, dize olarak temsil edilen değere uygulanan biçimlendirme türünü denetler. Duyarlık belirtici , varsa dizedeki önemli basamak veya ondalık basamak sayısını denetler.
Not: Standart biçim tanımlayıcılarının listesi için aşağıdaki tabloya bakın. gibi
System.Int32belirli bir veri türünün standart biçim tanımlayıcılarından birini veya daha fazlasını desteklemeyebileceğini unutmayın. son not
Not: Bir biçim, 'C' ve 'c' biçimleri tarafından eklenen para birimimbol gibi kültüre göre değişen simgeler içerdiğinde, biçimlendirme nesnesi dize gösteriminde kullanılan gerçek karakterleri sağlar. Bir yöntem, biçimlendirme nesnesi sağlayan bir
System.IFormatProvidernesneyi geçirmek için bir parametre içerebilir veya yöntem, geçerli kültür için sembol tanımlarını içeren varsayılan biçimlendirme nesnesini kullanabilir. Geçerli kültür genellikle varsayılan olarak sistem genelinde kullanılan aynı simge kümesini kullanır. Temel Sınıf Kitaplığı'nda, sistem tarafından sağlanan sayısal türlerin biçimlendirme nesnesi birSystem.Globalization.NumberFormatInfoörnektir. ÖrneğinSystem.DateTime, birSystem.Globalization.DateTimeFormatInfokullanılır. son not
Aşağıdaki tabloda, Temel Sınıf Kitaplığı'ndaki sayısal veri türleriyle kullanılan standart biçim tanımlayıcıları ve ilişkili biçimlendirme nesnesi üyeleri açıklanmaktadır.
| Biçim Tanımlayıcısı | Açıklama |
|---|---|
|
Para Birimi Biçimi: Parasal değer içeren dizeler için kullanılır. Bir öğesinin
Duyarlık belirtici atlanırsa, |
|
Ondalık Biçim: (Bu biçim yalnızca tam sayı veri türleriyle belirtildiğinde geçerlidir.) Tamsayı değerleri içeren dizeler için kullanılır. Negatif sayılar, özelliği tarafından belirtilen negatif sayı simgesiyle ön eke Duyarlık belirtici, dizede görüntülenen en az basamak sayısını belirler. Belirtilen duyarlık değerin içerdiğinden daha fazla basamak gerektiriyorsa, dize sıfırlarla sola doldurulur. Duyarlık belirtici değerin içindekinden daha az basamak belirtiyorsa, duyarlık tanımlayıcısı yoksayılır. |
|
Bilimsel (Mühendislik) Biçimi: Aşağıdaki formlardan birinde dizeler için kullanılır: [-]m.ddddddE+xxx [-]m.ddddddE-xxx [-]m.dddddde+xxx [-]m.dddddde-xxx Negatif sayı simgesi ('-') yalnızca değer negatifse ve özelliği tarafından Tam olarak sıfır olmayan bir ondalık basamak (m), özelliği tarafından Duyarlık belirtici, dizedeki ondalık basamak sayısını (dddddd) belirler. Duyarlık belirtici atlanırsa, dizeye altı ondalık basamak eklenir. Üs (+/-xxx), pozitif veya negatif bir sayı simgesinden ve ardından en az üç basamaktan (xxx) oluşur. Üs, gerekirse sıfırlarla sol tuş takımına alınır. Biçim belirticisinin ('E' veya 'e') durumu, dizedeki üs ön eki (E veya e) için kullanılan büyük/küçük harf durumunu belirler. Sonuçlar gerektiğinde en yakın temsil edilebilir değere yuvarlanir. Pozitif sayı simgesi özelliği tarafından |
|
Sabit Nokta Biçimi: Aşağıdaki biçimdeki dizeler için kullanılır: [-]m.dd... d Sıfır olmayan en az bir ondalık basamak (m), özelliği tarafından Negatif sayı simgesi işareti ('-') yalnızca değer negatifse m'nin önüne geçilir. Bu simge özelliği tarafından Duyarlık belirtici ondalık basamak sayısını belirler (dd... d) dizesinde. Duyarlık belirtici atlanırsa, |
|
Genel Biçim: Dize sabit nokta biçiminde ('F' veya 'f') ya da bilimsel biçimde ('E' veya 'e') biçimlendirilir. Tam sayı türleri için: Üs duyarlık tanımlayıcısı ise < değerler sabit nokta biçimi kullanılarak biçimlendirilir; burada üs, değerin bilimsel biçimdeki üssüdür. Diğer tüm değerler için bilimsel biçim kullanılır. Duyarlık belirtici atlanırsa, veri türü için en yüksek değeri görüntülemek için gereken alan genişliğine eşit bir varsayılan duyarlık kullanılır ve bu da değerin sabit nokta biçiminde biçimlendirildiğine neden olur. İntegral türleri için varsayılan duyarlıklar aşağıdaki gibidir:
Tek, Ondalık ve Çift türleri için: Üsteldeğerler sabit nokta biçimi kullanılarak biçimlendirilir; burada üs, değerin bilimsel biçimdeki üssüdür. Diğer tüm değerler için bilimsel biçim kullanılır. Sonuçlar gerektiğinde en yakın temsil edilebilir değere yuvarlanir. Duyarlık belirtici atlanırsa, aşağıdaki varsayılan duyarlıklar kullanılır:
Tüm türler için:
|
|
Sayı Biçimi: Aşağıdaki biçimdeki dizeler için kullanılır: [-]d,ddd,ddd.dd... d Negatif değerlerin gösterimi özelliği tarafından Sıfır olmayan en az bir ondalık basamak (d), özelliği tarafından Duyarlık belirtici ondalık basamak sayısını belirler (dd... d). Duyarlık belirtici atlanırsa, |
|
Yüzde Biçimi: Yüzde içeren dizeler için kullanılır. Bir öğesinin
Duyarlık belirtilmezse, sonuçtaki ondalık basamak sayısı tarafından Sonuç 100 ile ölçeklendirilir (.99% 99 olur). |
|
Gidiş dönüş Biçimi: (Bu biçim yalnızca veya System.Doubleile System.Single belirtildiğinde geçerlidir.) Kayan nokta değerinin dize gösteriminin duyarlığı, dizenin ayrıştırılmasının özgün değerle karşılaştırıldığında duyarlık kaybına neden olmamasını sağlamak için kullanılır. Veri türünün en yüksek duyarlığı (için System.Single7 ve için System.Double15) duyarlık kaybına neden olursa, duyarlık iki ondalık basamak artırılır. Bu biçim tanımlayıcısı ile bir duyarlık belirtici sağlanırsa, yoksayılır. Bu biçim aksi takdirde sabit nokta biçimiyle aynıdır. |
|
Onaltılık Biçim: (Bu biçim yalnızca tam sayı veri türleriyle belirtildiğinde geçerlidir.) Temel 16'daki sayıların dize gösterimleri için kullanılır. Duyarlık, dizedeki en az basamak sayısını belirler. Duyarlık sayı içerdiğinden daha fazla basamak belirtiyorsa, sayı sıfırlarla sola doldurulur. Biçim belirticisinin ('X' veya 'x') durumu, büyük veya küçük harflerin onaltılık gösterimde kullanılıp kullanılmayacağını belirler. |
Sayısal değer veya System.SingleSystem.DoubleNaNdeğeri , PositiveInfinityveya NegativeInfinityise, biçim tanımlayıcısı yoksayılır ve aşağıdakilerden biri döndürülür: System.Globalization.NumberFormatInfo.NaNSymbol, System.Globalization.NumberFormatInfo.PositiveInfinitySymbolveya .System.Globalization.NumberFormatInfo.NegativeInfinitySymbol
Özel biçim, yukarıda açıklanan standart biçim dizesi (Axx) biçiminde olmayan bir biçim olarak belirtilen herhangi bir dizedir. Aşağıdaki tabloda, özel biçimler oluştururken kullanılan karakterler açıklanmaktadır.
| Biçim Tanımlayıcısı | Açıklama |
|---|---|
0 (sıfır) |
Sıfır yer tutucusu: Biçimlendirilen değerin özel biçimde '0' göründüğü konumda bir basamak varsa, bu basamak çıkış dizesine kopyalanır; aksi takdirde çıkış dizesinde bu konumda sıfır depolanır. Ondalık ayırıcıdan önce en soldaki '0' ve ondalık ayırıcıdan sonraki en sağdaki '0' konumu, çıkış dizesinde her zaman var olan basamak aralığını belirler. Ondalık ayırıcıdan sonraki Sıfır ve/veya Basamak yer tutucularının sayısı, ondalık ayırıcıdan sonra görünen basamak sayısını belirler. Değerler gerektiği gibi yuvarlanmış. |
# |
Basamak yer tutucusu: Biçimlendirilen değerin özel biçimde bir '#' göründüğü konumda bir basamak varsa, bu basamak çıkış dizesine kopyalanır; aksi takdirde, çıkış dizesinde bu konumda hiçbir şey depolanmaz. Dizedeki tek basamak '0' olsa bile, bu tanımlayıcının hiçbir zaman '0' karakterini önemli bir basamak değilse depolamadığını unutmayın. (Önemli bir basamaksa çıkış dizesinde '0' karakterini görüntüler.) Ondalık ayırıcıdan sonraki Sıfır ve/veya Basamak yer tutucularının sayısı, ondalık ayırıcıdan sonra görünen basamak sayısını belirler. Değerler gerektiği gibi yuvarlanmış. |
. (nokta) |
Ondalık ayırıcı: En soldaki '.'
biçim dizesindeki karakter, biçimlendirilmiş değerdeki ondalık ayırıcının konumunu belirler; herhangi bir ek '.' karakterler yoksayılır. özelliği ondalık System.Globalization.NumberFormatInfo.NumberDecimalSeparator ayırıcı olarak kullanılan simgeyi belirler. |
, (virgül) |
Grup ayırıcısı ve sayı ölçeklendirme: ',' karakteri iki amaca hizmet eder. İlk olarak, özel biçim iki Sıfır veya Basamak yer tutucusu (0 veya #) arasında ve varsa ondalık ayırıcının solunda bu karakteri içeriyorsa, çıkışta ondalık ayırıcının solundaki her basamak grubunun arasına grup ayırıcıları eklenir.
Biçim dizesi ondalık ayırıcısının hemen solunda bir veya daha fazla ',' karakteri içeriyorsa, sayı ölçeklendirilir. Ölçek faktörü, ondalık ayırıcının hemen solundaki grup ayırıcı karakter sayısına göre belirlenir. X karakter varsa, değer biçimlendirilmeden önce 1000X'e bölünür. Örneğin, '0,' biçim dizesi bir değeri bir milyona böler. Ölçeklendirmeyi göstermek için ',' karakterinin varlığının çıkış dizesine grup ayırıcıları eklemediğini unutmayın. Bu nedenle, bir sayıyı 1 milyona ölçeklendirmek ve grup ayırıcıları eklemek için '#,##0,' gibi özel bir biçim kullanın. |
% (yüzde) |
Yüzde yer tutucusu: '%' karakterinin özel biçimde bulunması, bir sayının biçimlendirilmeden önce 100 ile çarpılmasına neden olur. Yüzde simgesi, '%' öğesinin biçim dizesinde göründüğü konumdaki çıkış dizesine eklenir.
System.Globalization.NumberFormatInfo.PercentSymbol özelliği yüzde simgesini belirler. |
|
Mühendislik biçimi: 'E', 'E+', 'E-', 'e', 'e+' veya 'e-' dizelerinden herhangi biri özel bir biçimde mevcutsa ve hemen ardından en az bir '0' karakteri gelirse, değer bilimsel gösterim kullanılarak biçimlendirilir. Üs ön ekini (E veya e) izleyen '0' karakter sayısı, üs içindeki en az basamak sayısını belirler. 'E+' ve 'e+' biçimleri, pozitif veya negatif bir sayı simgesinin her zaman üssün önüne geldiğini gösterir. 'E', 'E-', 'e' veya 'e-' biçimleri, negatif bir sayı simgesinin negatif üslerden önce geldiğini gösterir; hiçbir simge pozitif üslerden önce değildir. Pozitif sayı simgesi özelliği tarafından System.Globalization.NumberFormatInfo.PositiveSign sağlanır. Negatif sayı simgesi özelliği tarafından System.Globalization.NumberFormatInfo.NegativeSign sağlanır. |
\ (ters eğik çizgi) |
Kaçış karakteri: C# gibi bazı dillerde ters eğik çizgi karakteri, özel biçimdeki bir sonraki karakterin kaçış dizisi olarak yorumlanmasına neden olur. '\n' (yeni satır) gibi C dil biçimlendirme dizileriyle kullanılır. Bazı dillerde, kaçış karakterinin kendisinden önce sabit değer olarak kullanıldığında bir kaçış karakteri olması gerekir. Aksi takdirde, derleyici karakteri kaçış dizisi olarak yorumlar. Bu kaçış karakterinin tüm programlama dillerinde desteklenmesi gerekmez. |
|
Değişmez dize: Tek veya çift tırnak içine alınmış karakterler çıktı dizesine tam anlamıyla kopyalanır ve biçimlendirmeyi etkilemez. |
; (noktalı virgül) |
Bölüm ayırıcı: ';' karakteri, biçim dizesindeki pozitif, negatif ve sıfır sayılarının bölümlerini ayırmak için kullanılır. (Bu özellik aşağıda ayrıntılı olarak açıklanmıştır.) |
| Diğer | Diğer tüm karakterler: Diğer tüm karakterler çıkış dizesinde göründükleri konumda değişmez değer olarak depolanır. |
Sabit nokta biçim dizeleri için ('E0', 'E+0', 'E-0', 'e0', 'e+0' veya 'e-0' içermeyen dizeler), sayıların ondalık ayırıcının sağındaki Sıfır veya Basamak yer tutucuları kadar ondalık basamağı olacak şekilde yuvarlandığını unutmayın. Özel biçim ondalık ayırıcı içermiyorsa, sayı en yakın tamsayıya yuvarlanmış olur. Sayının ondalık ayırıcısının solunda Sıfır veya Basamak yer tutucularından daha fazla basamak varsa, ek basamaklar ilk Sıfır veya Basamak yer tutucusunun hemen öncesinde çıkış dizesine kopyalanır.
Özel biçim, pozitif, negatif ve sıfır değerleri için farklı biçimlendirme belirtmek üzere bölüm ayırıcı karakterleriyle ayrılmış en fazla üç bölüm içerebilir. Bölümler aşağıdaki gibi yorumlanır:
Bir bölüm: Özel biçim tüm değerlere (pozitif, negatif ve sıfır) uygulanır. Negatif değerler negatif bir işaret içerir.
İki bölüm: İlk bölüm pozitif değerler ve sıfırlar için, ikinci bölüm ise negatif değerler için geçerlidir. Biçimlendirilecek değer negatifse, ancak ikinci bölümdeki biçime göre yuvarladıktan sonra sıfıra dönüşürse, sonuçta elde edilen sıfır ilk bölüme göre biçimlendirilir. Negatif değerler, negatif değerlerin gösterimleri üzerinde tam denetime izin vermek için negatif bir işaret içermez. Örneğin negatif, '#.# gibi özel bir biçim kullanılarak parantez içinde gösterilebilir; (####.####)’.
Üç bölüm: İlk bölüm pozitif değerler için, ikinci bölüm negatif değerler için ve üçüncü bölüm sıfırlar için geçerlidir. İkinci bölüm boş olabilir (noktalı virgüller arasında hiçbir şey görünmez), bu durumda ilk bölüm sıfır olmayan tüm değerler için geçerlidir ve negatif değerler negatif bir işaret içerir. Biçimlendirilecek sayı sıfır değilse, ancak birinci veya ikinci bölümdeki biçime göre yuvarladıktan sonra sıfıra dönüşürse, sonuçta elde edilen sıfır üçüncü bölüme göre biçimlendirilir.
ve System.Enum türleri, değerlerin System.DateTime dize gösterimlerini biçimlendirmek için biçim tanımlayıcılarının kullanılmasını da destekler. Belirli bir biçim tanımlayıcısının anlamı, biçimlendirilmekte olan veri türüne (sayısal, tarih/saat, numaralandırma) göre değişir.
System.Enum Her tür tarafından desteklenen biçim tanımlayıcılarının kapsamlı bir listesi için ve konusuna bakınSystem.Globalization.DateTimeFormatInfo.
C.5 Kitaplık Türü Kısaltmaları
Bu belirtimde aşağıdaki kitaplık türlerine başvurulmaktadır. Genel ad alanı niteleyicisi de dahil olmak üzere bu türlerin tam adları aşağıda listelenmiştir. Bu belirtim boyunca, bu türler tam ad olarak görünür; genel ad alanı niteleyicisi atlanmış; veya ad alanı da atlanmış basit bir nitelenmemiş tür adı olarak. Örneğin, türü ICollection<T>, bu belirtim içinde kullanıldığında her zaman türü global::System.Collections.Generic.ICollection<T>anlamına gelir.
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>
Bilgilendirici metnin sonu.
GitHub'da bizimle işbirliği yapın
Bu içeriğin kaynağı GitHub'da bulunabilir; burada ayrıca sorunları ve çekme isteklerini oluşturup gözden geçirebilirsiniz. Daha fazla bilgi için katkıda bulunan kılavuzumuzu inceleyin.
ECMA C# draft specification