Catatan
Akses ke halaman ini memerlukan otorisasi. Anda dapat mencoba masuk atau mengubah direktori.
Akses ke halaman ini memerlukan otorisasi. Anda dapat mencoba mengubah direktori.
C.1 Umum
Implementasi C# yang sesuai harus menyediakan sekumpulan jenis minimum yang memiliki semantik tertentu. Jenis dan anggotanya tercantum di sini, dalam urutan alfabet menurut namespace layanan dan jenis. Untuk definisi formal jenis dan anggotanya yang diidentifikasi dalam (§C.2), lihat ISO/IEC 23271:2012 Common Language Infrastructure (CLI), Partisi IV; Pustaka Kelas Dasar (BCL), Pustaka Numerik Yang Diperluas, dan Pustaka Array yang Diperluas, yang disertakan oleh referensi dalam spesifikasi ini. Untuk daftar jenis dan anggota mereka yang diperlukan di luar yang diidentifikasi dalam §C.2, lihat §C.3.
Catatan: Adopsi subset API pustaka CLI tidak membuat dependensi pada CLI itu sendiri; implementasi yang sesuai tidak perlu dibangun di atas, atau target, CLI.
Teks ini informatif.
Pustaka standar dimaksudkan untuk menjadi set minimum jenis dan anggota yang diperlukan oleh implementasi C# yang sesuai. Dengan demikian, ini hanya berisi anggota yang secara eksplisit diperlukan oleh spesifikasi bahasa C#.
Diharapkan bahwa implementasi C# yang sesuai akan menyediakan pustaka yang jauh lebih luas yang memungkinkan program yang berguna ditulis. Misalnya, implementasi yang sesuai mungkin memperluas pustaka ini dengan
- Menambahkan namespace layanan.
- Menambahkan jenis.
- Menambahkan anggota ke jenis non-antarmuka.
- Menambahkan kelas atau antarmuka dasar yang mengintervensi.
- Memiliki jenis struct dan class mengimplementasikan antarmuka tambahan.
- Menambahkan atribut (selain
ConditionalAttribute) ke jenis dan anggota yang ada.
Akhir teks informatif.
Jenis Pustaka Standar C.2 yang ditentukan dalam ISO/IEC 23271
Catatan: Beberapa
structjenis di bawah ini memiliki pengubahreadonly. Pengubah ini tidak tersedia ketika ISO/IEC 23271 dirilis, tetapi diperlukan untuk menyesuaikan implementasi spesifikasi ini. catatan akhir
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);
}
}
Jenis Pustaka Standar C.3 tidak ditentukan dalam ISO/IEC 23271
Jenis berikut, termasuk anggota yang tercantum, harus didefinisikan dalam pustaka standar yang sesuai. (Jenis ini mungkin ditentukan dalam edisi ISO/IEC 23271 di masa mendatang.) Diharapkan bahwa banyak dari jenis ini akan memiliki lebih banyak anggota yang tersedia daripada yang tercantum.
Implementasi yang sesuai dapat menyediakan Task.GetAwaiter() dan Task<TResult>.GetAwaiter() sebagai metode ekstensi.
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();
}
}
Spesifikasi Format C.4
Arti format, seperti yang digunakan dalam ekspresi string terinterpolasi (§12.8.3), didefinisikan dalam ISO/IEC 23271:2012. Untuk kenyamanan, teks berikut disalin dari deskripsi System.IFormattable.
Teks ini informatif.
Format adalah string yang menjelaskan tampilan objek saat dikonversi menjadi string. Format standar atau kustom dapat digunakan. Format standar mengambil bentuk Axx, di mana A adalah karakter alfabet tunggal yang disebut penentu format, dan xx adalah bilangan bulat antara nol dan 99 inklusif, yang disebut penentu presisi. Penentu format mengontrol jenis pemformatan yang diterapkan ke nilai yang direpresentasikan sebagai string. Penentu presisi mengontrol jumlah digit signifikan atau tempat desimal dalam string, jika berlaku.
Catatan: Untuk daftar penentu format standar, lihat tabel di bawah ini. Perhatikan bahwa jenis data tertentu, seperti
System.Int32, mungkin tidak mendukung satu atau beberapa penentu format standar. catatan akhir
Catatan: Saat format menyertakan simbol yang bervariasi menurut budaya, seperti currencysymbol yang disertakan oleh format 'C' dan 'c', objek pemformatan menyediakan karakter aktual yang digunakan dalam representasi string. Metode mungkin menyertakan parameter untuk meneruskan
System.IFormatProviderobjek yang menyediakan objek pemformatan, atau metode mungkin menggunakan objek pemformatan default, yang berisi definisi simbol untuk budaya saat ini. Budaya saat ini biasanya menggunakan sekumpulan simbol yang sama yang digunakan di seluruh sistem secara default. Di Pustaka Kelas Dasar, objek pemformatan untuk jenis numerik yang disediakan sistem adalahSystem.Globalization.NumberFormatInfoinstans. MisalnyaSystem.DateTime, digunakanSystem.Globalization.DateTimeFormatInfo. catatan akhir
Tabel berikut ini menjelaskan penentu format standar dan anggota objek pemformatan terkait yang digunakan dengan jenis data numerik di Pustaka Kelas Dasar.
| Penentu Format | Deskripsi |
|---|---|
|
Format Mata Uang: Digunakan untuk string yang berisi nilai moneter. ,
Jika penentu presisi dihilangkan, |
|
Format Desimal: (Format ini hanya valid jika ditentukan dengan jenis data integral.) Digunakan untuk string yang berisi nilai bilangan bulat. Angka negatif diawali dengan simbol angka negatif yang ditentukan oleh Penentu presisi menentukan jumlah minimum digit yang muncul dalam string. Jika presisi yang ditentukan memerlukan lebih banyak digit daripada nilai yang dikandung, string diisi kiri dengan nol. Jika penentu presisi menentukan lebih sedikit digit daripada nilainya, penentu presisi diabaikan. |
|
Format Ilmiah (Teknik): Digunakan untuk string dalam salah satu bentuk berikut: [-]m.dddddddE+xxx [-]m.dddddddE-xxx [-]m.dddddde+xxx [-]m.ddddddde-xxx Simbol angka negatif ('-') hanya muncul jika nilainya negatif, dan disediakan oleh Tepat satu digit desimal bukan nol (m) mendahului pemisah desimal ('.'), yang disediakan oleh Penentu presisi menentukan jumlah tempat desimal (dddddd) dalam string. Jika penentu presisi dihilangkan, enam tempat desimal disertakan dalam string. Eksponen (+/-xxx) terdiri dari simbol angka positif atau negatif diikuti dengan minimal tiga digit (xxx). Eksponen diisi kiri dengan nol, jika perlu. Kasus penentu format ('E' atau 'e') menentukan kasus yang digunakan untuk awalan eksponen (E atau e) dalam string. Hasil dibulatkan ke nilai terdekat yang dapat diwakili jika diperlukan. Simbol angka positif disediakan oleh |
|
Format Titik Tetap: Digunakan untuk string dalam formulir berikut: [-]m.dd... d Setidaknya satu digit desimal bukan nol (m) mendahului pemisah desimal ('.'), yang disediakan oleh Tanda simbol angka negatif ('-') mendahului m hanya jika nilainya negatif. Simbol ini disediakan oleh Penentu presisi menentukan jumlah tempat desimal (dd... d) dalam string. Jika penentu presisi dihilangkan, |
|
Format Umum: String diformat dalam format titik tetap ('F' atau 'f') atau format ilmiah ('E' atau 'e'). Untuk jenis integral: Nilai diformat menggunakan format titik tetap jika , di mana < adalah eksponen nilai dalam format ilmiah. Untuk semua nilai lainnya, format ilmiah digunakan. Jika penentu presisi dihilangkan, presisi default sama dengan lebar bidang yang diperlukan untuk menampilkan nilai maksimum untuk jenis data digunakan, yang menghasilkan nilai yang diformat dalam format titik tetap. Presisi default untuk jenis integral adalah sebagai berikut:
Untuk jenis Tunggal, Desimal, dan Ganda: Nilai diformat menggunakan format titik tetap jika eksponen ≥ -4 dan penentu presisi eksponen< , di mana eksponen adalah eksponen nilai dalam format ilmiah. Untuk semua nilai lainnya, format ilmiah digunakan. Hasil dibulatkan ke nilai terdekat yang dapat diwakili jika diperlukan. Jika penentu presisi dihilangkan, presisi default berikut digunakan:
Untuk semua jenis:
|
|
Format Angka: Digunakan untuk string dalam formulir berikut: [-]d,ddd,ddd.dd... d Representasi nilai negatif ditentukan oleh Setidaknya satu digit desimal bukan nol (d) mendahului pemisah desimal ('.'), yang disediakan oleh Penentu presisi menentukan jumlah tempat desimal (dd... d). Jika penentu presisi dihilangkan, |
|
Format Persen: Digunakan untuk string yang berisi persentase. ,
Jika tidak ada presisi yang ditentukan, jumlah tempat desimal dalam hasil ditentukan oleh Hasilnya diskalakan sebesar 100 (,99 menjadi 99%). |
|
Format Pulang Pergi: (Format ini hanya valid jika ditentukan dengan System.Double atau System.Single.) Digunakan untuk memastikan bahwa presisi representasi string dari nilai floating-point sih sehingga mengurai string tidak mengakibatkan hilangnya presisi jika dibandingkan dengan nilai asli. Jika presisi maksimum jenis data (7 untuk System.Single, dan 15 untuk System.Double) akan mengakibatkan hilangnya presisi, presisi ditingkatkan oleh dua tempat desimal. Jika penentu presisi disediakan dengan penentu format ini, penentu akan diabaikan. Format ini jika tidak identik dengan format titik tetap. |
|
Format Heksadesimal: (Format ini hanya valid jika ditentukan dengan jenis data integral.) Digunakan untuk representasi string angka di Base 16. Presisi menentukan jumlah minimum digit dalam string. Jika presisi menentukan lebih banyak digit daripada angka yang dikandung, angka tersebut diisi kiri dengan nol. Kasus penentu format ('X' atau 'x') menentukan apakah huruf besar atau huruf kecil digunakan dalam representasi heksadesimal. |
Jika nilai numerik adalah System.Single atau dengan nilai System.Double, , NaNatau PositiveInfinity, penentu format diabaikan, dan salah satu hal berikut dikembalikan: NegativeInfinity, , System.Globalization.NumberFormatInfo.NaNSymbolatau System.Globalization.NumberFormatInfo.PositiveInfinitySymbolSystem.Globalization.NumberFormatInfo.NegativeInfinitySymbol .
Format kustom adalah string apa pun yang ditentukan sebagai format yang tidak dalam bentuk string format standar (Axx) yang dijelaskan di atas. Tabel berikut ini menjelaskan karakter yang digunakan dalam membuat format kustom.
| Penentu Format | Deskripsi |
|---|---|
0 (nol) |
Tempat penampung nol: Jika nilai yang diformat memiliki digit di posisi di mana '0' muncul dalam format kustom, maka digit tersebut disalin ke string output; jika tidak, nol disimpan dalam posisi tersebut dalam string output. Posisi '0' paling kiri sebelum pemisah desimal dan '0' paling kanan setelah pemisah desimal menentukan rentang digit yang selalu ada dalam string output. Jumlah tempat penampung Nol dan/atau Digit setelah pemisah desimal menentukan jumlah digit yang muncul setelah pemisah desimal. Nilai dibulatkan seperlunya. |
# |
Tempat penampung digit: Jika nilai yang diformat memiliki digit di posisi di mana '#' muncul dalam format kustom, maka digit tersebut disalin ke string output; jika tidak, tidak ada yang disimpan dalam posisi tersebut dalam string output. Perhatikan bahwa penentu ini tidak pernah menyimpan karakter '0' jika bukan digit yang signifikan, bahkan jika '0' adalah satu-satunya digit dalam string. (Ini menampilkan karakter '0' dalam string output jika merupakan digit yang signifikan.) Jumlah tempat penampung Nol dan/atau Digit setelah pemisah desimal menentukan jumlah digit yang muncul setelah pemisah desimal. Nilai dibulatkan seperlunya. |
. (titik) |
Pemisah desimal: Paling kiri '.'
karakter dalam string format menentukan lokasi pemisah desimal dalam nilai yang diformat; tambahan '.' karakter diabaikan. Properti System.Globalization.NumberFormatInfo.NumberDecimalSeparator menentukan simbol yang digunakan sebagai pemisah desimal. |
, (koma) |
Pemisah grup dan penskalakan angka: Karakter ',' melayani dua tujuan. Pertama, jika format kustom berisi karakter ini antara dua tempat penampung Nol atau Digit (0 atau #) dan di sebelah kiri pemisah desimal jika ada, maka output akan memiliki pemisah grup yang dimasukkan di antara setiap grup digit di sebelah kiri pemisah desimal. Properti Jika string format berisi satu atau beberapa karakter ',' segera di sebelah kiri pemisah desimal, maka angka akan diskalakan. Faktor skala ditentukan oleh jumlah karakter pemisah grup segera di sebelah kiri pemisah desimal. Jika ada karakter x, maka nilai dibagi dengan 1000X sebelum diformat. Misalnya, string format '0,,' akan membagi nilai sebesar satu juta. Perhatikan bahwa keberadaan karakter ',' untuk menunjukkan penskalaan tidak menyisipkan pemisah grup dalam string output. Dengan demikian, untuk menskalakan angka sebesar 1 juta dan menyisipkan pemisah grup, gunakan format kustom yang mirip dengan '#,##0,,'. |
% (persen) |
Tempat penampung persentase: Keberadaan karakter '%' dalam format kustom menyebabkan angka dikalikan dengan 100 sebelum diformat. Simbol persen disisipkan dalam string output di lokasi tempat '%' muncul dalam string format. Properti System.Globalization.NumberFormatInfo.PercentSymbol menentukan simbol persen. |
|
Format teknik: Jika salah satu string 'E', 'E+', 'E-', 'e', 'e+', atau 'e-' ada dalam format kustom dan diikuti segera oleh setidaknya satu karakter '0', maka nilai diformat menggunakan notasi ilmiah. Jumlah karakter '0' setelah awalan eksponen (E atau e) menentukan jumlah minimum digit dalam eksponen. Format 'E+' dan 'e+' menunjukkan bahwa simbol angka positif atau negatif selalu mendahului eksponen. Format 'E', 'E-', 'e', atau 'e-' menunjukkan bahwa simbol angka negatif mendahului eksponen negatif; tidak ada simbol yang mendahului eksponen positif. Simbol angka positif disediakan oleh System.Globalization.NumberFormatInfo.PositiveSign properti . Simbol angka negatif disediakan oleh System.Globalization.NumberFormatInfo.NegativeSign properti . |
\ (garis miring terbelakang) |
Karakter escape: Dalam beberapa bahasa, seperti C#, karakter garis miring terbalik menyebabkan karakter berikutnya dalam format kustom ditafsirkan sebagai urutan escape. Ini digunakan dengan urutan pemformatan bahasa C, seperti '\n' (baris baru). Dalam beberapa bahasa, karakter escape itu sendiri harus didahului oleh karakter escape ketika digunakan sebagai literal. Jika tidak, kompilator menafsirkan karakter sebagai urutan escape. Karakter escape ini tidak diperlukan untuk didukung dalam semua bahasa pemrograman. |
|
String literal: Karakter yang diapit dalam tanda kutip tunggal atau ganda disalin ke string output secara harfiah, dan tidak memengaruhi pemformatan. |
; (Titik koma) |
Pemisah bagian: Karakter ';' digunakan untuk memisahkan bagian untuk angka positif, negatif, dan nol dalam string format. (Fitur ini dijelaskan secara rinci di bawah ini.) |
| Lainnya | Semua karakter lainnya: Semua karakter lain disimpan dalam string output sebagai literal dalam posisi di mana karakter tersebut muncul. |
Perhatikan bahwa untuk string format titik tetap (string yang tidak berisi 'E0', 'E+0', 'E-0', 'e0', 'e+0', atau 'e-0'), angka dibulatkan ke tempat desimal sebanyak ada tempat penampung Nol atau Digit di sebelah kanan pemisah desimal. Jika format kustom tidak berisi pemisah desimal, angka dibulatkan ke bilangan bulat terdekat. Jika angka memiliki lebih banyak digit daripada tempat penampung Nol atau Digit di sebelah kiri pemisah desimal, digit tambahan disalin ke string output segera sebelum tempat penampung Nol atau Digit pertama.
Format kustom dapat berisi hingga tiga bagian yang dipisahkan oleh karakter pemisah bagian, untuk menentukan pemformatan yang berbeda untuk nilai positif, negatif, dan nol. Bagian ditafsirkan sebagai berikut:
Satu bagian: Format kustom berlaku untuk semua nilai (positif, negatif, dan nol). Nilai negatif menyertakan tanda negatif.
Dua bagian: Bagian pertama berlaku untuk nilai positif dan nol, dan bagian kedua berlaku untuk nilai negatif. Jika nilai yang akan diformat negatif, tetapi menjadi nol setelah pembulatan sesuai dengan format di bagian kedua, maka nol yang dihasilkan diformat sesuai dengan bagian pertama. Nilai negatif tidak menyertakan tanda negatif untuk memungkinkan kontrol penuh atas representasi nilai negatif. Misalnya, negatif dapat diwakili dalam tanda kurung menggunakan format kustom yang mirip dengan '####.#####; (####.####)’.
Tiga bagian: Bagian pertama berlaku untuk nilai positif, bagian kedua berlaku untuk nilai negatif, dan bagian ketiga berlaku untuk nol. Bagian kedua dapat kosong (tidak ada yang muncul di antara titik koma), dalam hal ini bagian pertama berlaku untuk semua nilai nonzero, dan nilai negatif menyertakan tanda negatif. Jika angka yang akan diformat bukan nol, tetapi menjadi nol setelah pembulatan sesuai dengan format di bagian pertama atau kedua, maka nol yang dihasilkan diformat sesuai dengan bagian ketiga.
Jenis System.Enum dan System.DateTime juga mendukung penggunaan penentu format untuk memformat representasi string nilai. Arti penentu format tertentu bervariasi sesuai dengan jenis data (numerik, tanggal/waktu, enumerasi) yang diformat. Lihat System.Enum dan System.Globalization.DateTimeFormatInfo untuk daftar komprehensif penentu format yang didukung oleh setiap jenis.
Singkatan Jenis Pustaka C.5
Jenis pustaka berikut dirujuk dalam spesifikasi ini. Nama lengkap jenis tersebut, termasuk kualifikasi namespace global tercantum di bawah ini. Sepanjang spesifikasi ini, jenis ini muncul sebagai nama yang sepenuhnya memenuhi syarat; dengan kualifikasi namespace global dihilangkan; atau sebagai nama jenis sederhana yang tidak memenuhi syarat, dengan namespace dihilangkan juga. Misalnya, jenis ICollection<T>, ketika digunakan dalam spesifikasi ini, selalu berarti jenis global::System.Collections.Generic.ICollection<T>.
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>
Akhir teks informatif.
Berkolaborasi dengan kami di GitHub
Sumber untuk konten ini dapat ditemukan di GitHub, yang juga dapat Anda gunakan untuk membuat dan meninjau masalah dan menarik permintaan. Untuk informasi selengkapnya, lihat panduan kontributor kami.
ECMA C# draft specification