Ek C Standart kitaplığı

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. Bu 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ığı.

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ı struct türlerde değiştirici vardır readonly . 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 ArithmeticException : Exception
    {
        public ArithmeticException();
        public ArithmeticException(string message);
        public ArithmeticException(string message, Exception innerException);
    }

    public abstract class Array : IList, ICollection, IEnumerable
    {
        public int Length { get; }
        public int Rank { get; }
        public int GetLength(int dimension);
    }

    public class ArrayTypeMismatchException : Exception
    {
        public ArrayTypeMismatchException();
        public ArrayTypeMismatchException(string message);
        public ArrayTypeMismatchException(string message,
            Exception innerException);
    }

    [AttributeUsageAttribute(AttributeTargets.All, Inherited = true,
        AllowMultiple = false)]
    public abstract class Attribute
    {
        protected Attribute();
    }

    public enum AttributeTargets
    {
        Assembly = 0x1,
        Module = 0x2,
        Class = 0x4,
        Struct = 0x8,
        Enum = 0x10,
        Constructor = 0x20,
        Method = 0x40,
        Property = 0x80,
        Field = 0x100,
        Event = 0x200,
        Interface = 0x400,
        Parameter = 0x800,
        Delegate = 0x1000,
        ReturnValue = 0x2000,
        GenericParameter = 0x4000,
        All = 0x7FFF
    }

    [AttributeUsageAttribute(AttributeTargets.Class, Inherited = true)]
    public sealed class AttributeUsageAttribute : Attribute
    {
        public AttributeUsageAttribute(AttributeTargets validOn);
        public bool AllowMultiple { get; set; }
        public bool Inherited { get; set; }
        public AttributeTargets ValidOn { get; }
    }

    public readonly struct Boolean { }
    public readonly struct Byte { }
    public readonly struct Char { }
    public readonly struct Decimal { }
    public abstract class Delegate { }

    public class DivideByZeroException : ArithmeticException
    {
        public DivideByZeroException();
        public DivideByZeroException(string message);
        public DivideByZeroException(string message, Exception innerException);
    }

    public readonly struct Double { }

    public abstract class Enum : ValueType
    {
        protected Enum();
    }

    public class Exception
    {
        public Exception();
        public Exception(string message);
        public Exception(string message, Exception innerException);
        public sealed Exception InnerException { get; }
        public virtual string Message { get; }
    }

    public class GC { }

    public interface IDisposable
    {
        void Dispose();
    }

    public interface IFormattable { }

    public sealed class IndexOutOfRangeException : Exception
    {
        public IndexOutOfRangeException();
        public IndexOutOfRangeException(string message);
        public IndexOutOfRangeException(string message,
            Exception innerException);
    }

    public readonly struct Int16 { }
    public readonly struct Int32 { }
    public readonly struct Int64 { }
    public readonly struct IntPtr { }

    public class InvalidCastException : Exception
    {
        public InvalidCastException();
        public InvalidCastException(string message);
        public InvalidCastException(string message, Exception innerException);
    }

    public class InvalidOperationException : Exception
    {
        public InvalidOperationException();
        public InvalidOperationException(string message);
        public InvalidOperationException(string message,
            Exception innerException);
    }

    public class NotSupportedException : Exception
    {
        public NotSupportedException();
        public NotSupportedException(string message);
        public NotSupportedException(string message, 
            Exception innerException);    
    }

    public struct Nullable<T>
    {
        public bool HasValue { get; }
        public T Value { get; }
    }

    public class NullReferenceException : Exception
    {
        public NullReferenceException();
        public NullReferenceException(string message);
        public NullReferenceException(string message, Exception innerException);
    }

    public class Object
    {
        public Object();
        ~Object();
        public virtual bool Equals(object obj);
        public virtual int GetHashCode();
        public Type GetType();
        public virtual string ToString();
    }

    [AttributeUsageAttribute(AttributeTargets.Class | AttributeTargets.Struct |
        AttributeTargets.Enum | AttributeTargets.Interface |
        AttributeTargets.Constructor | AttributeTargets.Method |
        AttributeTargets.Property | AttributeTargets.Field |
        AttributeTargets.Event | AttributeTargets.Delegate, Inherited = false)]
    public sealed class ObsoleteAttribute : Attribute
    {
        public ObsoleteAttribute();
        public ObsoleteAttribute(string message);
        public ObsoleteAttribute(string message, bool error);
        public bool IsError { get; }
        public string Message { get; }
    }

    public class OutOfMemoryException : Exception
    {
        public OutOfMemoryException();
        public OutOfMemoryException(string message);
        public OutOfMemoryException(string message, Exception innerException);
    }

    public class OverflowException : ArithmeticException
    {
        public OverflowException();
        public OverflowException(string message);
        public OverflowException(string message, Exception innerException);
    }

    public readonly struct SByte { }
    public readonly struct Single { }

    public sealed class StackOverflowException : Exception
    {
        public StackOverflowException();
        public StackOverflowException(string message);
        public StackOverflowException(string message, Exception innerException);
    }

    public sealed class String : IEnumerable<Char>, IEnumerable
    {
        public int Length { get; }
        public char this [int index] { get; }
        public static string Format(string format, params object[] args);
    }

    public abstract class Type : MemberInfo { }

    public sealed class TypeInitializationException : Exception
    {
        public TypeInitializationException(string fullTypeName,
            Exception innerException);
    }

    public readonly struct UInt16 { }
    public readonly struct UInt32 { }
    public readonly struct UInt64 { }
    public readonly struct UIntPtr { }

    public abstract class ValueType
    {
        protected ValueType();
    }
}

namespace System.Collections
{
    public interface ICollection : IEnumerable
    {
        int Count { get; }
        bool IsSynchronized { get; }
        object SyncRoot { get; }
        void CopyTo(Array array, int index);
    }

    public interface IEnumerable
    {
        IEnumerator GetEnumerator();
    }

    public interface IEnumerator
    {
        object Current { get; }
        bool MoveNext();
        void Reset();
    }

    public interface IList : ICollection, IEnumerable
    {
        bool IsFixedSize { get; }
        bool IsReadOnly { get; }
        object this [int index] { get; set; }
        int Add(object value);
        void Clear();
        bool Contains(object value);
        int IndexOf(object value);
        void Insert(int index, object value);
        void Remove(object value);
        void RemoveAt(int index);
    }
}

namespace System.Collections.Generic
{
    public interface ICollection<T> : IEnumerable<T>
    {
        int Count { get; }
        bool IsReadOnly { get; }
        void Add(T item);
        void Clear();
        bool Contains(T item);
        void CopyTo(T[] array, int arrayIndex);
        bool Remove(T item);
    }

    public interface IEnumerable<T> : IEnumerable
    {
        IEnumerator<T> GetEnumerator();
    }

    public interface IEnumerator<T> : IDisposable, IEnumerator
    {
        T Current { get; }
    }

    public interface IList<T> : ICollection<T>
    {
        T this [int index] { get; set; }
        int IndexOf(T item);
        void Insert(int index, T item);
        void RemoveAt(int index);
    }
}

namespace System.Diagnostics
{
    [AttributeUsageAttribute(AttributeTargets.Method | AttributeTargets.Class,
                             AllowMultiple = true)]
    public sealed class ConditionalAttribute : Attribute
    {
        public ConditionalAttribute(string conditionString);
        public string ConditionString { get; }
    }
}

namespace System.Reflection
{
    public abstract class MemberInfo
    {
        protected MemberInfo();
    }
}

namespace System.Runtime.CompilerServices
{
    public sealed class IndexerNameAttribute : Attribute
    {
        public IndexerNameAttribute(String indexerName);
    }

    public static class Unsafe
    {
        public static ref T NullRef<T>();
    }
}

namespace System.Threading
{
    public static class Monitor
    {
        public static void Enter(object obj);
        public static void Exit(object obj);
    }
}

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 class FormattableString : IFormattable { }

    public class OperationCanceledException : Exception
    {
        public OperationCanceledException();
        public OperationCanceledException(string message);
        public OperationCanceledException(string message, Exception innerException);
    }

    public readonly ref struct ReadOnlySpan<T>
    {
        public int Length { get; }
        public ref readonly T this[int index] { get; }
    }

    public readonly ref struct Span<T>
    {
        public int Length { get; }
        public ref T this[int index] { get; }
        public static implicit operator ReadOnlySpan<T>(Span<T> span);
    }

    public struct ValueTuple<T1>
    {
        public T1 Item1;
        public ValueTuple(T1 item1);
    }

    public struct ValueTuple<T1, T2>
    {
        public T1 Item1;
        public T2 Item2;
        public ValueTuple(T1 item1, T2 item2);
    }

    public struct ValueTuple<T1, T2, T3>
    {
        public T1 Item1;
        public T2 Item2;
        public T3 Item3;
        public ValueTuple(T1 item1, T2 item2, T3 item3);
    }

    public struct ValueTuple<T1, T2, T3, T4>
    {
        public T1 Item1;
        public T2 Item2;
        public T3 Item3;
        public T4 Item4;
        public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4);
    }

    public struct ValueTuple<T1, T2, T3, T4, T5>
    {
        public T1 Item1;
        public T2 Item2;
        public T3 Item3;
        public T4 Item4;
        public T5 Item5;
        public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5);
    }

    public struct ValueTuple<T1, T2, T3, T4, T5, T6>
    {
        public T1 Item1;
        public T2 Item2;
        public T3 Item3;
        public T4 Item4;
        public T5 Item5;
        public T6 Item6;
        public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5,
            T6 item6);
    }

    public struct ValueTuple<T1, T2, T3, T4, T5, T6, T7>
    {
        public T1 Item1;
        public T2 Item2;
        public T3 Item3;
        public T4 Item4;
        public T5 Item5;
        public T6 Item6;
        public T7 Item7;
        public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5,
            T6 item6, T7 item7);
    }

    public struct ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest>
    {
        public T1 Item1;
        public T2 Item2;
        public T3 Item3;
        public T4 Item4;
        public T5 Item5;
        public T6 Item6;
        public T7 Item7;
        public TRest Rest;
        public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5,
            T6 item6, T7 item7, TRest rest);
    }
}

namespace System.Collections.Generic
{
    public interface IReadOnlyCollection<out T> : IEnumerable<T>
    {
        int Count { get; }
    }

    public interface IReadOnlyList<out T> : IReadOnlyCollection<T>
    {
        T this [int index] { get; }
    }
}

namespace System.Linq.Expressions
{
    public sealed class Expression<TDelegate>
    {
        public TDelegate Compile();
    }
}

namespace System.Runtime.CompilerServices
{
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | 
        AttributeTargets.Interface, 
        Inherited = false, AllowMultiple = false)]
    public sealed class AsyncMethodBuilderAttribute : Attribute
    {
        public AsyncMethodBuilderAttribute(Type builderType) {}
 
        public Type BuilderType { get; }
    }

    [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
    public sealed class CallerFilePathAttribute : Attribute
    {
        public CallerFilePathAttribute() { }
    }

    [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
    public sealed class CallerLineNumberAttribute : Attribute
    {
        public CallerLineNumberAttribute() { }
    }

    [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
    public sealed class CallerMemberNameAttribute : Attribute
    {
        public CallerMemberNameAttribute() { }
    }

    public static class FormattableStringFactory
    {
        public static FormattableString Create(string format,
            params object[] arguments);
    }

    public interface ICriticalNotifyCompletion : INotifyCompletion
    {
        void UnsafeOnCompleted(Action continuation);
    }

    public interface INotifyCompletion
    {
        void OnCompleted(Action continuation);
    }

    public readonly struct TaskAwaiter : ICriticalNotifyCompletion,
        INotifyCompletion
    {
        public bool IsCompleted { get; }
        public void GetResult();
    }

    public readonly struct TaskAwaiter<TResult> : ICriticalNotifyCompletion,
        INotifyCompletion
    {
        public bool IsCompleted { get; }
        public TResult GetResult();
    }

    public readonly struct ValueTaskAwaiter : ICriticalNotifyCompletion,
        INotifyCompletion
    {
        public bool IsCompleted { get; }
        public void GetResult();
    }

    public readonly struct ValueTaskAwaiter<TResult>
        : ICriticalNotifyCompletion, INotifyCompletion
    {
        public bool IsCompleted { get; }
        public TResult GetResult();
    }

    [System.AttributeUsage(System.AttributeTargets.Field |
      System.AttributeTargets.Parameter | System.AttributeTargets.Property,
      Inherited=false)]
    public sealed class AllowNullAttribute : Attribute
    {
        public AllowNullAttribute() { }
    }

    [System.AttributeUsage(System.AttributeTargets.Field |
      System.AttributeTargets.Parameter | System.AttributeTargets.Property,
      Inherited=false)]
    public sealed class DisallowNullAttribute : Attribute
    {
        public DisallowNullAttribute() {}
    }

    [System.AttributeUsage(System.AttributeTargets.Method, Inherited=false)]
    public sealed class DoesNotReturnAttribute : Attribute
    {
        public DoesNotReturnAttribute() {}
    }

    [System.AttributeUsage(System.AttributeTargets.Parameter, Inherited=false)]
    public sealed class DoesNotReturnIfAttribute : Attribute
    {
        public DoesNotReturnIfAttribute(bool parameterValue) {}
    }

    [System.AttributeUsage(System.AttributeTargets.Field | 
      System.AttributeTargets.Parameter | System.AttributeTargets.Property | 
      System.AttributeTargets.ReturnValue, Inherited=false)]
    public sealed class MaybeNullAttribute : Attribute
    {
        public MaybeNullAttribute() {}
    }

    [System.AttributeUsage(System.AttributeTargets.Parameter, Inherited=false)]
    public sealed class MaybeNullWhenAttribute : Attribute
    {
        public MaybeNullWhenAttribute(bool returnValue) {}
    }

    [System.AttributeUsage(System.AttributeTargets.Field |
      System.AttributeTargets.Parameter | System.AttributeTargets.Property | 
      System.AttributeTargets.ReturnValue, Inherited=false)]
    public sealed class NotNullAttribute : Attribute
    {
        public NotNullAttribute() {}
    }

    [System.AttributeUsage(System.AttributeTargets.Parameter | 
      System.AttributeTargets.Property | System.AttributeTargets.ReturnValue, 
      AllowMultiple=true, Inherited=false)]
    public sealed class NotNullIfNotNullAttribute : Attribute
    {
        public NotNullIfNotNullAttribute(string parameterName) {}
    }

    [System.AttributeUsage(System.AttributeTargets.Parameter, Inherited=false)]
    public sealed class NotNullWhenAttribute : Attribute
    {
        public NotNullWhenAttribute(bool returnValue) {}
    }
}

namespace System.Threading.Tasks
{
    public class Task
    {
        public System.Runtime.CompilerServices.TaskAwaiter GetAwaiter();
    }

    public class Task<TResult> : Task
    {
        public new System.Runtime.CompilerServices.TaskAwaiter<T> GetAwaiter();
    }

    public readonly struct ValueTask : System.IEquatable<ValueTask>
    {
        public System.Runtime.CompilerServices.ValueTaskAwaiter GetAwaiter();
    }

    public readonly struct ValueTask<TResult>
        : System.IEquatable<ValueTask<TResult>>
    {
        public new System.Runtime.CompilerServices.ValueTaskAwaiter<TResult>
            GetAwaiter();
    }
}

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.IFormatProvider nesneyi 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 bir System.Globalization.NumberFormatInfo örnektir. Örneğin System.DateTime , bir System.Globalization.DateTimeFormatInfo kullanı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.

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.

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.Action
• global::System.ArgumentException
• global::System.ArithmeticException
• global::System.Array
• global::System.ArrayTypeMisMatchException
• global::System.Attribute
• global::System.AttributeTargets
• global::System.AttributeUsageAttribute
• global::System.Boolean
• global::System.Byte
• global::System.Char
• global::System.Collections.Generic.ICollection<T>
• global::System.Collections.Generic.IEnumerable<T>
• global::System.Collections.Generic.IEnumerator<T>
• global::System.Collections.Generic.IList<T>
• global::System.Collections.Generic.IReadonlyCollection<out T>
• global::System.Collections.Generic.IReadOnlyList<out T>
• global::System.Collections.ICollection
• global::System.Collections.IEnumerable
• global::System.Collections.IList
• global::System.Collections.IEnumerator
• global::System.Decimal
• global::System.Delegate
• global::System.Diagnostics.ConditionalAttribute
• global::System.DivideByZeroException
• global::System.Double
• global::System.Enum
• global::System.Exception
• global::System.GC
• global::System.ICollection
• global::System.IDisposable
• global::System.IEnumerable
• global::System.IEnumerable<out T>
• global::System.IList
• global::System.IndexOutOfRangeException
• global::System.Int16
• global::System.Int32
• global::System.Int64
• global::System.IntPtr
• global::System.InvalidCastException
• global::System.InvalidOperationException
• global::System.Linq.Expressions.Expression<TDelegate>
• global::System.MemberInfo
• global::System.NotSupportedException
• global::System.Nullable<T>
• global::System.NullReferenceException
• global::System.Object
• global::System.ObsoleteAttribute
• global::System.OutOfMemoryException
• global::System.OverflowException
• global::System.Runtime.CompilerServices.CallerFileAttribute
• global::System.Runtime.CompilerServices.CallerLineNumberAttribute
• global::System.Runtime.CompilerServices.CallerMemberNameAttribute
• global::System.Runtime.CompilerServices.ICriticalNotifyCompletion
• global::System.Runtime.CompilerServices.IndexerNameAttribute
• global::System.Runtime.CompilerServices.INotifyCompletion
• global::System.Runtime.CompilerServices.TaskAwaiter
• global::System.Runtime.CompilerServices.TaskAwaiter<T>
• global::System.SByte
• global::System.Single
• global::System.StackOverflowException
• global::System.String
• global::System.SystemException
• global::System.Threading.Monitor
• global::System.Threading.Tasks.Task
• global::System.Threading.Tasks.Task<TResult>
• global::System.Type
• global::System.TypeInitializationException
• global::System.UInt16
• global::System.UInt32
• global::System.UInt64
• global::System.UIntPtr
• global::System.ValueType

Bilgilendirici metnin sonu.