Early Preview

This is currently very much a preview. Please feel free to try things out, but don't be upset if anything is not yet working. Feedback is welcome over on our GitHub Dicussions page.

System.Runtime

System Library

Author Microsoft
Version 10.0.1
Tags

Public Types

Microsoft.​Win32.​SafeHandles

class CriticalHandleMinusOneIsInvalid
Provides a base class for Win32 critical handle implementations in which the value of -1 indicates an invalid handle.
class CriticalHandleZeroOrMinusOneIsInvalid
Provides a base class for Win32 critical handle implementations in which the value of either 0 or -1 indicates an invalid handle.
class SafeFileHandle
Represents a wrapper class for a file handle.
class SafeHandleMinusOneIsInvalid
Provides a base class for Win32 safe handle implementations in which the value of -1 indicates an invalid handle.
class SafeHandleZeroOrMinusOneIsInvalid
Provides a base class for Win32 safe handle implementations in which the value of either 0 or -1 indicates an invalid handle.
class SafeWaitHandle
Represents a wrapper class for a wait handle.

System

class AccessViolationException
The exception that is thrown when there is an attempt to read or write protected memory.
class Action
Encapsulates a method that has no parameters and does not return a value.
class Action`1
Encapsulates a method that has a single parameter and does not return a value.
class Action`10
Encapsulates a method that has 10 parameters and does not return a value.
class Action`11
Encapsulates a method that has 11 parameters and does not return a value.
class Action`12
Encapsulates a method that has 12 parameters and does not return a value.
class Action`13
Encapsulates a method that has 13 parameters and does not return a value.
class Action`14
Encapsulates a method that has 14 parameters and does not return a value.
class Action`15
Encapsulates a method that has 15 parameters and does not return a value.
class Action`16
Encapsulates a method that has 16 parameters and does not return a value.
class Action`2
Encapsulates a method that has two parameters and does not return a value.
class Action`3
Encapsulates a method that has three parameters and does not return a value.
class Action`4
Encapsulates a method that has four parameters and does not return a value.
class Action`5
Encapsulates a method that has five parameters and does not return a value.
class Action`6
Encapsulates a method that has six parameters and does not return a value.
class Action`7
Encapsulates a method that has seven parameters and does not return a value.
class Action`8
Encapsulates a method that has eight parameters and does not return a value.
class Action`9
Encapsulates a method that has nine parameters and does not return a value.
class Activator
Contains methods to create types of objects locally or remotely, or obtain references to existing remote objects. This class cannot be inherited.
class AggregateException
Represents one or more errors that occur during application execution.
class AppContext
Provides members for setting and retrieving data about an application's context.
class AppDomain
Represents an application domain, which is an isolated environment where applications execute. This class cannot be inherited.
class AppDomainSetup
Represents assembly binding information that can be added to an instance of <see cref="T:System.AppDomain" /> .
class AppDomainUnloadedException
The exception that is thrown when an attempt is made to access an unloaded application domain.
class ApplicationException
Serves as the base class for application-defined exceptions.
class ApplicationId
Contains information used to uniquely identify a manifest-based application. This class cannot be inherited.
struct ArgIterator
Represents a variable-length argument list; that is, the parameters of a function that takes a variable number of arguments.
class ArgumentException
The exception that is thrown when one of the arguments provided to a method is not valid.
class ArgumentNullException
The exception that is thrown when a null reference ( <see langword="Nothing" /> in Visual Basic) is passed to a method that does not accept it as a valid argument.
class ArgumentOutOfRangeException
The exception that is thrown when the value of an argument is outside the allowable range of values as defined by the invoked method.
class ArithmeticException
The exception that is thrown for errors in an arithmetic, casting, or conversion operation.
class Array
Provides methods for creating, manipulating, searching, and sorting arrays, thereby serving as the base class for all arrays in the common language runtime.
struct ArraySegment`1
Delimits a section of a one-dimensional array.
class ArrayTypeMismatchException
The exception that is thrown when an attempt is made to store an element of the wrong type within an array.
class AssemblyLoadEventArgs
Provides data for the <see cref="E:System.AppDomain.AssemblyLoad" /> event.
class AssemblyLoadEventHandler
Represents the method that handles the <see cref="E:System.AppDomain.AssemblyLoad" /> event of an <see cref="T:System.AppDomain" /> .
class AsyncCallback
References a method to be called when a corresponding asynchronous operation completes.
class Attribute
Represents the base class for custom attributes.
enum AttributeTargets
Specifies the application elements on which it is valid to apply an attribute.
class AttributeUsageAttribute
Specifies the usage of another attribute class. This class cannot be inherited.
class BadImageFormatException
The exception that is thrown when the file image of a dynamic link library (DLL) or an executable program is invalid.
enum Base64FormattingOptions
Specifies whether relevant <see cref="Overload:System.Convert.ToBase64CharArray" /> and <see cref="Overload:System.Convert.ToBase64String" /> methods insert line breaks in their output.
class BitConverter
Converts base data types to an array of bytes, and an array of bytes to base data types.
struct Boolean
Represents a Boolean ( <see langword="true" /> or <see langword="false" /> ) value.
class Buffer
Manipulates arrays of primitive types.
struct Byte
Represents an 8-bit unsigned integer.
class CannotUnloadAppDomainException
The exception that is thrown when an attempt to unload an application domain fails.
struct Char
Represents a character as a UTF-16 code unit.
class CharEnumerator
Supports iterating over a <see cref="T:System.String" /> object and reading its individual characters. This class cannot be inherited.
class CLSCompliantAttribute
Indicates whether a program element is compliant with the Common Language Specification (CLS). This class cannot be inherited.
class Comparison`1
Represents the method that compares two objects of the same type.
class ContextBoundObject
Defines the base class for all context-bound classes.
class ContextMarshalException
The exception that is thrown when an attempt to marshal an object across a context boundary fails.
class ContextStaticAttribute
Indicates that the value of a static field is unique for a particular context.
class Convert
Converts a base data type to another base data type.
class Converter`2
Represents a method that converts an object from one type to another type.
struct DateOnly
Represents dates with values ranging from January 1, 0001 Anno Domini (Common Era) through December 31, 9999 A.D. (C.E.) in the Gregorian calendar.
struct DateTime
Represents an instant in time, typically expressed as a date and time of day.
enum DateTimeKind
Specifies whether a <see cref="T:System.DateTime" /> object represents a local time, a Coordinated Universal Time (UTC), or is not specified as either local time or UTC.
struct DateTimeOffset
Represents a point in time, typically expressed as a date and time of day, relative to Coordinated Universal Time (UTC).
enum DayOfWeek
Specifies the day of the week.
class DBNull
Represents a nonexistent value. This class cannot be inherited.
struct Decimal
Represents a decimal floating-point number.
class Delegate
Represents a delegate, which is a data structure that refers to a static method or to a class instance and an instance method of that class.
class DivideByZeroException
The exception that is thrown when there is an attempt to divide an integral or <see cref="T:System.Decimal" /> value by zero.
struct Double
Represents a double-precision floating-point number.
class DuplicateWaitObjectException
The exception that is thrown when an object appears more than once in an array of synchronization objects.
class EntryPointNotFoundException
The exception that is thrown when an attempt to load a class fails due to the absence of an entry method.
class Enum
Provides the base class for enumerations.
class Environment
Provides information about, and means to manipulate, the current environment and platform. This class cannot be inherited.
enum EnvironmentVariableTarget
Specifies the location where an environment variable is stored or retrieved in a set or get operation.
class EventArgs
Represents the base class for classes that contain event data, and provides a value to use for events that do not include event data.
class EventHandler
Represents the method that will handle an event that has no event data.
class EventHandler`1
Represents the method that will handle an event when the event provides data.
class EventHandler`2
Represents the method that will handle an event when the event provides data.
class Exception
Represents errors that occur during application execution.
class ExecutionEngineException
The exception that is thrown when there is an internal error in the execution engine of the common language runtime. This class cannot be inherited.
class FieldAccessException
The exception that is thrown when there is an invalid attempt to access a private or protected field inside a class.
class FileStyleUriParser
A customizable parser based on the File scheme.
class FlagsAttribute
Indicates that an enumeration can be treated as a bit field; that is, a set of flags.
class FormatException
The exception that is thrown when the format of an argument is invalid, or when a composite format string is not well formed.
class FormattableString
Represents a composite format string, along with the arguments to be formatted.
class FtpStyleUriParser
A customizable parser based on the File Transfer Protocol (FTP) scheme.
class Func`1
Encapsulates a method that has no parameters and returns a value of the type specified by the <typeparamref name="TResult" /> parameter.
class Func`10
Encapsulates a method that has nine parameters and returns a value of the type specified by the <typeparamref name="TResult" /> parameter.
class Func`11
Encapsulates a method that has 10 parameters and returns a value of the type specified by the <typeparamref name="TResult" /> parameter.
class Func`12
Encapsulates a method that has 11 parameters and returns a value of the type specified by the <typeparamref name="TResult" /> parameter.
class Func`13
Encapsulates a method that has 12 parameters and returns a value of the type specified by the <typeparamref name="TResult" /> parameter.
class Func`14
Encapsulates a method that has 13 parameters and returns a value of the type specified by the <typeparamref name="TResult" /> parameter.
class Func`15
Encapsulates a method that has 14 parameters and returns a value of the type specified by the <typeparamref name="TResult" /> parameter.
class Func`16
Encapsulates a method that has 15 parameters and returns a value of the type specified by the <typeparamref name="TResult" /> parameter.
class Func`17
Encapsulates a method that has 16 parameters and returns a value of the type specified by the <typeparamref name="TResult" /> parameter.
class Func`2
Encapsulates a method that has one parameter and returns a value of the type specified by the <typeparamref name="TResult" /> parameter.
class Func`3
Encapsulates a method that has two parameters and returns a value of the type specified by the <typeparamref name="TResult" /> parameter.
class Func`4
Encapsulates a method that has three parameters and returns a value of the type specified by the <typeparamref name="TResult" /> parameter.
class Func`5
Encapsulates a method that has four parameters and returns a value of the type specified by the <typeparamref name="TResult" /> parameter.
class Func`6
Encapsulates a method that has five parameters and returns a value of the type specified by the <typeparamref name="TResult" /> parameter.
class Func`7
Encapsulates a method that has six parameters and returns a value of the type specified by the <typeparamref name="TResult" /> parameter.
class Func`8
Encapsulates a method that has seven parameters and returns a value of the type specified by the <typeparamref name="TResult" /> parameter.
class Func`9
Encapsulates a method that has eight parameters and returns a value of the type specified by the <typeparamref name="TResult" /> parameter.
class GC
Controls the system garbage collector, a service that automatically reclaims unused memory.
enum GCCollectionMode
Specifies the behavior for a forced garbage collection.
struct GCGenerationInfo
Represents the size and the fragmenation of a generation on entry and on exit of the GC reported in <see cref="T:System.GCMemoryInfo" /> .
enum GCKind
Specifies the kind of a garbage collection.
struct GCMemoryInfo
Provides a set of APIs that can be used to retrieve garbage collection information.
enum GCNotificationStatus
Provides information about the current registration for notification of the next full garbage collection.
class GenericUriParser
A customizable parser for a hierarchical URI.
enum GenericUriParserOptions
Specifies options for a <see cref="T:System.UriParser" /> .
class GopherStyleUriParser
A customizable parser based on the Gopher scheme.
struct Guid
Represents a globally unique identifier (GUID).
struct Half
Represents a half-precision floating-point number.
struct HashCode
Combines the hash code for multiple values into a single hash code.
class HttpStyleUriParser
A customizable parser based on the HTTP scheme.
struct IAsyncDisposable
Provides a mechanism for releasing unmanaged resources asynchronously.
struct IAsyncResult
Represents the status of an asynchronous operation.
struct ICloneable
Supports cloning, which creates a new instance of a class with the same value as an existing instance.
struct IComparable
Defines a generalized type-specific comparison method that a value type or class implements to order or sort its instances.
struct IComparable`1
Defines a generalized comparison method that a value type or class implements to create a type-specific comparison method for ordering or sorting its instances.
struct IConvertible
Defines methods that convert the value of the implementing reference or value type to a common language runtime type that has an equivalent value.
struct ICustomFormatter
Defines a method that supports custom formatting of the value of an object.
struct IDisposable
Provides a mechanism for releasing unmanaged resources.
struct IEquatable`1
Defines a generalized method that a value type or class implements to create a type-specific method for determining equality of instances.
struct IFormatProvider
Provides a mechanism for retrieving an object to control formatting.
struct IFormattable
Provides functionality to format the value of an object into a string representation.
struct Index
Represents a type that can be used to index a collection either from the beginning or the end.
class IndexOutOfRangeException
The exception that is thrown when an attempt is made to access an element of an array or collection with an index that is outside its bounds.
class InsufficientExecutionStackException
The exception that is thrown when there is insufficient execution stack available to allow most methods to execute.
class InsufficientMemoryException
The exception that is thrown when a check for sufficient available memory fails. This class cannot be inherited.
struct Int128
Represents a 128-bit signed integer.
struct Int16
Represents a 16-bit signed integer.
struct Int32
Represents a 32-bit signed integer.
struct Int64
Represents a 64-bit signed integer.
struct IntPtr
Represents a signed integer where the bit-width is the same as a pointer.
class InvalidCastException
The exception that is thrown for invalid casting or explicit conversion.
class InvalidOperationException
The exception that is thrown when a method call is invalid for the object's current state.
class InvalidProgramException
The exception that is thrown when a program contains invalid Microsoft intermediate language (MSIL) or metadata. Generally this indicates a bug in the compiler that generated the program. This exception is also thrown when internal runtime implementation limits have been exceeded by the program.
class InvalidTimeZoneException
The exception that is thrown when time zone information is invalid.
struct IObservable`1
Defines a provider for push-based notification.
struct IObserver`1
Provides a mechanism for receiving push-based notifications.
struct IParsable`1
Defines a mechanism for parsing a string to a value.
struct IProgress`1
Defines a provider for progress updates.
struct ISpanFormattable
Provides functionality to format the string representation of an object into a span.
struct ISpanParsable`1
Defines a mechanism for parsing a span of characters to a value.
struct IUtf8SpanFormattable
Provides functionality to format the string representation of an object into a span as UTF-8.
struct IUtf8SpanParsable`1
Defines a mechanism for parsing a span of UTF-8 characters to a value.
class Lazy`1
Provides support for lazy initialization.
class Lazy`2
Provides a lazy indirect reference to an object and its associated metadata for use by the Managed Extensibility Framework.
class LdapStyleUriParser
A customizable parser based on the Lightweight Directory Access Protocol (LDAP) scheme.
enum LoaderOptimization
An enumeration used with the <see cref="T:System.LoaderOptimizationAttribute" /> class to specify loader optimizations for an executable.
class LoaderOptimizationAttribute
Used to set the default loader optimization policy for the main method of an executable application.
class MarshalByRefObject
Enables access to objects across application domain boundaries in applications that support remoting.
class Math
Provides constants and static methods for trigonometric, logarithmic, and other common mathematical functions.
class MathF
Provides constants and static methods for trigonometric, logarithmic, and other common mathematical functions.
class MemberAccessException
The exception that is thrown when an attempt to access a class member fails.
struct Memory`1
Represents a contiguous region of memory.
class MethodAccessException
The exception that is thrown when there is an invalid attempt to access a method, such as accessing a private method from partially trusted code.
enum MidpointRounding
Specifies the strategy that mathematical rounding methods should use to round a number.
class MissingFieldException
The exception that is thrown when there is an attempt to dynamically access a field that does not exist. If a field in a class library has been removed or renamed, recompile any assemblies that reference that library.
class MissingMemberException
The exception that is thrown when there is an attempt to dynamically access a class member that does not exist or that is not declared as public. If a member in a class library has been removed or renamed, recompile any assemblies that reference that library.
class MissingMethodException
The exception that is thrown when there is an attempt to dynamically access a method that does not exist.
struct ModuleHandle
Represents a runtime handle for a module.
class MTAThreadAttribute
Indicates that the COM threading model for an application is multithreaded apartment (MTA).
class MulticastDelegate
Represents a multicast delegate; that is, a delegate that can have more than one element in its invocation list.
class MulticastNotSupportedException
The exception that is thrown when there is an attempt to combine two delegates based on the <see cref="T:System.Delegate" /> type instead of the <see cref="T:System.MulticastDelegate" /> type. This class cannot be inherited.
class NetPipeStyleUriParser
A parser based on the NetPipe scheme for the "Indigo" system.
class NetTcpStyleUriParser
A parser based on the NetTcp scheme for the "Indigo" system.
class NewsStyleUriParser
A customizable parser based on the news scheme using the Network News Transfer Protocol (NNTP).
class NonSerializedAttribute
Indicates that a field of a serializable class should not be serialized. This class cannot be inherited.
class NotFiniteNumberException
The exception that is thrown when a floating-point value is positive infinity, negative infinity, or Not-a-Number (NaN).
class NotImplementedException
The exception that is thrown when a requested method or operation is not implemented.
class NotSupportedException
The exception that is thrown when an invoked method is not supported, or when there is an attempt to read, seek, or write to a stream that does not support the invoked functionality.
class Nullable
Supports a value type that can be assigned <see langword="null" /> . This class cannot be inherited.
struct Nullable`1
Represents a value type that can be assigned <see langword="null" /> .
class NullReferenceException
The exception that is thrown when there is an attempt to dereference a null object reference.
class Object
Supports all classes in the .NET class hierarchy and provides low-level services to derived classes. This is the ultimate base class of all .NET classes; it is the root of the type hierarchy.
class ObjectDisposedException
The exception that is thrown when an operation is performed on a disposed object.
class ObsoleteAttribute
Marks program elements that are no longer in use.
class OperatingSystem
Represents information about an operating system, such as the version and platform identifier. This class cannot be inherited.
class OperationCanceledException
The exception that is thrown in a thread upon cancellation of an operation that the thread was executing.
class OutOfMemoryException
The exception that is thrown when there is not enough memory to continue the execution of a program.
class OverflowException
The exception that is thrown when an arithmetic, casting, or conversion operation in a checked context results in an overflow.
class ParamArrayAttribute
Indicates that a method will allow a variable number of arguments in its invocation. This class cannot be inherited.
enum PlatformID
Identifies the operating system, or platform, supported by an assembly.
class PlatformNotSupportedException
The exception that is thrown when a feature does not run on a particular platform.
class Predicate`1
Represents the method that defines a set of criteria and determines whether the specified object meets those criteria.
class Progress`1
Provides an <see cref="T:System.IProgress`1" /> that invokes callbacks for each reported progress value.
class Random
Represents a pseudo-random number generator, which is an algorithm that produces a sequence of numbers that meet certain statistical requirements for randomness.
struct Range
Represents a range that has start and end indexes.
class RankException
The exception that is thrown when an array with the wrong number of dimensions is passed to a method.
struct ReadOnlyMemory`1
Represents a contiguous region of memory, similar to <see cref="T:System.ReadOnlySpan`1" /> . Unlike <see cref="T:System.ReadOnlySpan`1" /> , it is not a byref-like type.
struct ReadOnlySpan`1
Provides a type-safe and memory-safe read-only representation of a contiguous region of arbitrary memory.
class ResolveEventArgs
Provides data for loader resolution events, such as the <see cref="E:System.AppDomain.TypeResolve" /> , <see cref="E:System.AppDomain.ResourceResolve" /> , <see cref="E:System.AppDomain.ReflectionOnlyAssemblyResolve" /> , and <see cref="E:System.AppDomain.AssemblyResolve" /> events.
class ResolveEventHandler
Represents a method that handles the <see cref="E:System.AppDomain.TypeResolve" /> , <see cref="E:System.AppDomain.ResourceResolve" /> , or <see cref="E:System.AppDomain.AssemblyResolve" /> event of an <see cref="T:System.AppDomain" /> .
struct RuntimeArgumentHandle
References a variable-length argument list.
struct RuntimeFieldHandle
Represents a field using an internal metadata token.
struct RuntimeMethodHandle
<see cref="T:System.RuntimeMethodHandle" /> is a handle to the internal metadata representation of a method.
struct RuntimeTypeHandle
Represents a type using an internal metadata token.
struct SByte
Represents an 8-bit signed integer.
class SerializableAttribute
Indicates that a class can be serialized using binary or XML serialization. This class cannot be inherited.
struct Single
Represents a single-precision floating-point number.
struct Span`1
Provides a type-safe and memory-safe representation of a contiguous region of arbitrary memory.
class StackOverflowException
The exception that is thrown when the execution stack exceeds the stack size. This class cannot be inherited.
class STAThreadAttribute
Indicates that the COM threading model for an application is single-threaded apartment (STA).
class String
Represents text as a sequence of UTF-16 code units.
class StringComparer
Represents a string comparison operation that uses specific case and culture-based or ordinal comparison rules.
enum StringComparison
Specifies the culture, case, and sort rules to be used by certain overloads of the <see cref="M:System.String.Compare(System.String,System.String)" /> and <see cref="M:System.String.Equals(System.Object)" /> methods.
class StringNormalizationExtensions
Provides extension methods to work with string normalization.
enum StringSplitOptions
Specifies options for applicable <see cref="Overload:System.String.Split" /> method overloads, such as whether to omit empty substrings from the returned array or trim whitespace from substrings.
class SystemException
Serves as the base class for system exceptions namespace.
class ThreadStaticAttribute
Indicates that the value of a static field is unique for each thread.
struct TimeOnly
Represents a time of day, as would be read from a clock, within the range 00:00:00 to 23:59:59.9999999.
class TimeoutException
The exception that is thrown when the time allotted for a process or operation has expired.
class TimeProvider
Provides an abstraction for time.
struct TimeSpan
Represents a time interval.
class TimeZone
Represents a time zone.
class TimeZoneInfo
Represents any time zone in the world.
class TimeZoneNotFoundException
The exception that is thrown when a time zone cannot be found.
class Tuple
Provides static methods for creating tuple objects.
class Tuple`1
Represents a 1-tuple, or singleton.
class Tuple`2
Represents a 2-tuple, or pair.
class Tuple`3
Represents a 3-tuple, or triple.
class Tuple`4
Represents a 4-tuple, or quadruple.
class Tuple`5
Represents a 5-tuple, or quintuple.
class Tuple`6
Represents a 6-tuple, or sextuple.
class Tuple`7
Represents a 7-tuple, or septuple.
class Tuple`8
Represents an n-tuple, where n is 8 or greater.
class TupleExtensions
Provides extension methods for tuples to interoperate with language support for tuples in C#.
class Type
Represents type declarations: class types, interface types, array types, value types, enumeration types, type parameters, generic type definitions, and open or closed constructed generic types.
class TypeAccessException
The exception that is thrown when a method attempts to use a type that it does not have access to.
enum TypeCode
Specifies the type of an object.
struct TypedReference
Describes objects that contain both a managed pointer to a location and a runtime representation of the type that may be stored at that location.
class TypeInitializationException
The exception that is thrown as a wrapper around the exception thrown by the class initializer. This class cannot be inherited.
class TypeLoadException
The exception that is thrown when type-loading failures occur.
class TypeUnloadedException
The exception that is thrown when there is an attempt to access an unloaded class.
struct UInt128
Represents a 128-bit unsigned integer.
struct UInt16
Represents a 16-bit unsigned integer.
struct UInt32
Represents a 32-bit unsigned integer.
struct UInt64
Represents a 64-bit unsigned integer.
struct UIntPtr
Represents an unsigned integer where the bit-width is the same as a pointer.
class UnauthorizedAccessException
The exception that is thrown when the operating system denies access because of an I/O error or a specific type of security error.
class UnhandledExceptionEventArgs
Provides data for the event that is raised when there is an exception that is not handled in any application domain.
class UnhandledExceptionEventHandler
Represents the method that will handle the event raised by an exception that is not handled by the application domain.
class Uri
Provides an object representation of a uniform resource identifier (URI) and easy access to the parts of the URI.
class UriBuilder
Provides a custom constructor for uniform resource identifiers (URIs) and modifies URIs for the <see cref="T:System.Uri" /> class.
enum UriComponents
Specifies the parts of a <see cref="T:System.Uri" /> .
struct UriCreationOptions
Provides options that control how a <see cref="T:System.Uri" /> is created and behaves.
enum UriFormat
Controls how URI information is escaped.
class UriFormatException
The exception that is thrown when an invalid Uniform Resource Identifier (URI) is detected.
enum UriHostNameType
Defines host name types for the <see cref="M:System.Uri.CheckHostName(System.String)" /> method.
enum UriKind
Defines the different kinds of URIs.
class UriParser
Parses a new URI scheme. This is an abstract class.
enum UriPartial
Defines the parts of a URI for the <see cref="M:System.Uri.GetLeftPart(System.UriPartial)" /> method.
struct ValueTuple
Provides static methods for creating value tuples.
struct ValueTuple`1
Represents a value tuple with a single component.
struct ValueTuple`2
Represents a value tuple with 2 components.
struct ValueTuple`3
Represents a value tuple with 3 components.
struct ValueTuple`4
Represents a value tuple with 4 components.
struct ValueTuple`5
Represents a value tuple with 5 components.
struct ValueTuple`6
Represents a value tuple with 6 components.
struct ValueTuple`7
Represents a value tuple with 7 components.
struct ValueTuple`8
Represents an n-value tuple, where n is 8 or greater.
class ValueType
Provides the base class for value types.
class Version
Represents the version number of an assembly, operating system, or the common language runtime. This class cannot be inherited.
struct Void
Specifies a return value type for a method that does not return a value.
class WeakReference
Represents a weak reference, which references an object while still allowing that object to be reclaimed by garbage collection.
class WeakReference`1
Represents a typed weak reference, which references an object while still allowing that object to be reclaimed by garbage collection.

System.​Buffers

class ArrayPool`1
Provides a resource pool that enables reusing instances of type T[].
struct IMemoryOwner`1
Identifies the owner of a block of memory who is responsible for disposing of the underlying memory appropriately.
struct IPinnable
Provides a mechanism for pinning and unpinning objects to prevent the garbage collector from moving them.
struct MemoryHandle
Provides a memory handle for a block of memory.
class MemoryManager`1
An abstract base class that is used to replace the implementation of <see cref="T:System.Memory`1" /> .
enum OperationStatus
Defines the values that can be returned from span-based operations that support processing of input contained in multiple discontiguous buffers.
class ReadOnlySpanAction`2
Encapsulates a method that receives a read-only span of objects of type <typeparamref name="T" /> and a state object of type <typeparamref name="TArg" /> .
class SearchValues
Provides a set of initialization methods for instances of the <see cref="T:System.Buffers.SearchValues`1" /> class.
class SearchValues`1
Provides an immutable, read-only set of values optimized for efficient searching. Instances are created by <see cref="M:System.Buffers.SearchValues.Create(System.ReadOnlySpan{System.Byte})" /> or <see cref="M:System.Buffers.SearchValues.Create(System.ReadOnlySpan{System.Char})" /> .
class SpanAction`2
Encapsulates a method that receives a span of objects of type <typeparamref name="T" /> and a state object of type <typeparamref name="TArg" /> .

System.​Buffers.​Text

class Base64
Converts between binary data and UTF-8 encoded text that is represented in base 64.
class Base64Url
Converts between binary data and URL-safe ASCII encoded text that's represented in Base64Url characters.

System.​CodeDom.​Compiler

class GeneratedCodeAttribute
Identifies code generated by a tool. This class cannot be inherited.
class IndentedTextWriter
Provides a text writer that can indent new lines by a tab string token.

System.​Collections

class ArrayList
Implements the <see cref="T:System.Collections.IList" /> interface using an array whose size is dynamically increased as required.
class Comparer
Compares two objects for equivalence, where string comparisons are case-sensitive.
struct DictionaryEntry
Defines a dictionary key/value pair that can be set or retrieved.
class Hashtable
Represents a collection of key/value pairs that are organized based on the hash code of the key.
struct ICollection
Defines size, enumerators, and synchronization methods for all nongeneric collections.
struct IComparer
Exposes a method that compares two objects.
struct IDictionary
Represents a nongeneric collection of key/value pairs.
struct IDictionaryEnumerator
Enumerates the elements of a nongeneric dictionary.
struct IEnumerable
Exposes an enumerator, which supports a simple iteration over a non-generic collection.
struct IEnumerator
Supports a simple iteration over a non-generic collection.
struct IEqualityComparer
Defines methods to support the comparison of objects for equality.
struct IHashCodeProvider
Supplies a hash code for an object, using a custom hash function.
struct IList
Represents a non-generic collection of objects that can be individually accessed by index.
struct IStructuralComparable
Supports the structural comparison of collection objects.
struct IStructuralEquatable
Defines methods to support the comparison of objects for structural equality.

System.​Collections.​Generic

struct IAlternateEqualityComparer`2
Implemented by an <see cref="T:System.Collections.Generic.IEqualityComparer`1" /> to support comparing a <typeparamref name="TAlternate" /> instance with a <typeparamref name="T" /> instance.
struct IAsyncEnumerable`1
Exposes an enumerator that provides asynchronous iteration over values of a specified type.
struct IAsyncEnumerator`1
Supports a simple asynchronous iteration over a generic collection.
struct ICollection`1
Defines methods to manipulate generic collections.
struct IComparer`1
Defines a method that a type implements to compare two objects.
struct IDictionary`2
Represents a generic collection of key/value pairs.
struct IEnumerable`1
Exposes the enumerator, which supports a simple iteration over a collection of a specified type.
struct IEnumerator`1
Supports a simple iteration over a generic collection.
struct IEqualityComparer`1
Defines methods to support the comparison of objects for equality.
struct IList`1
Represents a collection of objects that can be individually accessed by index.
struct IReadOnlyCollection`1
Represents a strongly-typed, read-only collection of elements.
struct IReadOnlyDictionary`2
Represents a generic read-only collection of key/value pairs.
struct IReadOnlyList`1
Represents a read-only collection of elements that can be accessed by index.
struct IReadOnlySet`1
Provides a readonly abstraction of a set.
struct ISet`1
Provides the base interface for the abstraction of sets.
class KeyNotFoundException
The exception that is thrown when the key specified for accessing an element in a collection does not match any key in the collection.
class KeyValuePair
Creates instances of the <see cref="T:System.Collections.Generic.KeyValuePair`2" /> struct.
struct KeyValuePair`2
Defines a key/value pair that can be set or retrieved.

System.​Collections.​ObjectModel

class Collection`1
Provides the base class for a generic collection.
class ReadOnlyCollection
Provides static methods for read-only collections.
class ReadOnlyCollection`1
Provides the base class for a generic read-only collection.
class ReadOnlyDictionary`2
Represents a read-only, generic collection of key/value pairs.
class ReadOnlySet`1
Represents a read-only, generic set of values.

System.​ComponentModel

class DefaultValueAttribute
Specifies the default value for a property.
class EditorBrowsableAttribute
Specifies that a class or member is viewable in an editor. This class cannot be inherited.
enum EditorBrowsableState
Specifies the browsable state of a property or method from within an editor.

System.​Configuration.​Assemblies

enum AssemblyHashAlgorithm
Specifies all the hash algorithms used for hashing files and for generating the strong name.
enum AssemblyVersionCompatibility
Defines the different types of assembly version compatibility.

System.​Diagnostics

class ConditionalAttribute
Indicates to compilers that a method call or attribute should be ignored unless a specified conditional compilation symbol is defined.
class Debug
Provides a set of methods and properties that help debug your code.
class DebuggableAttribute
Modifies code generation for runtime just-in-time (JIT) debugging. This class cannot be inherited.
class Debugger
Enables communication with a debugger. This class cannot be inherited.
class DebuggerBrowsableAttribute
Determines if and how a member is displayed in the debugger variable windows. This class cannot be inherited.
enum DebuggerBrowsableState
Provides display instructions for the debugger.
class DebuggerDisableUserUnhandledExceptionsAttribute
If a .NET Debugger is attached that supports the <see cref="M:System.Diagnostics.Debugger.BreakForUserUnhandledException(System.Exception)" /> API, the debugger won't break on user-unhandled exceptions when the exception is caught by a method with this attribute, unless <see cref="M:System.Diagnostics.Debugger.BreakForUserUnhandledException(System.Exception)" /> is called.
class DebuggerDisplayAttribute
Determines how a class or field is displayed in the debugger variable windows.
class DebuggerHiddenAttribute
Specifies the <see cref="T:System.Diagnostics.DebuggerHiddenAttribute" /> . This class cannot be inherited.
class DebuggerNonUserCodeAttribute
Identifies a type or member that is not part of the user code for an application.
class DebuggerStepperBoundaryAttribute
Indicates the code following the attribute is to be executed in run, not step, mode.
class DebuggerStepThroughAttribute
Instructs the debugger to step through the code instead of stepping into the code. This class cannot be inherited.
class DebuggerTypeProxyAttribute
Specifies the display proxy for a type.
class DebuggerVisualizerAttribute
Specifies that the type has a visualizer. This class cannot be inherited.
class StackTraceHiddenAttribute
Types and Methods attributed with StackTraceHidden will be omitted from the stack trace text shown in StackTrace.ToString() and Exception.StackTrace
class Stopwatch
Provides a set of methods and properties that you can use to accurately measure elapsed time.
class UnreachableException
The exception that is thrown when the program executes an instruction that was thought to be unreachable.

System.​Diagnostics.​CodeAnalysis

class AllowNullAttribute
Specifies that <see langword="null" /> is allowed as an input even if the corresponding type disallows it.
class ConstantExpectedAttribute
Indicates that the specified method parameter expects a constant.
class DisallowNullAttribute
Specifies that <see langword="null" /> is disallowed as an input even if the corresponding type allows it.
class DoesNotReturnAttribute
Specifies that a method will never return under any circumstance.
class DoesNotReturnIfAttribute
Specifies that the method will not return if the associated <see cref="T:System.Boolean" /> parameter is passed the specified value.
class DynamicallyAccessedMembersAttribute
Indicates that certain members on a specified <see cref="T:System.Type" /> are accessed dynamically, for example, through <see cref="N:System.Reflection" /> .
enum DynamicallyAccessedMemberTypes
Specifies the types of members that are dynamically accessed. This enumeration has a <see cref="T:System.FlagsAttribute" /> attribute that allows a bitwise combination of its member values.
class DynamicDependencyAttribute
States a dependency that one member has on another.
class ExcludeFromCodeCoverageAttribute
Specifies that the attributed code should be excluded from code coverage information.
class ExperimentalAttribute
Indicates that an API is experimental and it may change in the future.
class FeatureGuardAttribute
<para> Indicates that the specified public static Boolean read-only property guards access to the specified feature.</para>
class FeatureSwitchDefinitionAttribute
<para> Indicates that the specified public static Boolean read-only property corresponds to the feature switch specified by name.</para>
class MaybeNullAttribute
Specifies that an output may be <see langword="null" /> even if the corresponding type disallows it.
class MaybeNullWhenAttribute
Specifies that when a method returns <see cref="P:System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute.ReturnValue" /> , the parameter may be <see langword="null" /> even if the corresponding type disallows it.
class MemberNotNullAttribute
Specifies that the method or property will ensure that the listed field and property members have values that aren't <see langword="null" /> .
class MemberNotNullWhenAttribute
Specifies that the method or property will ensure that the listed field and property members have non-null values when returning with the specified return value condition.
class NotNullAttribute
Specifies that an output is not <see langword="null" /> even if the corresponding type allows it. Specifies that an input argument was not <see langword="null" /> when the call returns.
class NotNullIfNotNullAttribute
Specifies that the output will be non-null if the named parameter is non-null.
class NotNullWhenAttribute
Specifies that when a method returns <see cref="P:System.Diagnostics.CodeAnalysis.NotNullWhenAttribute.ReturnValue" /> , the parameter will not be <see langword="null" /> even if the corresponding type allows it.
class RequiresAssemblyFilesAttribute
Indicates that the specified member requires assembly files to be on disk.
class RequiresDynamicCodeAttribute
Indicates that the specified method requires the ability to generate new code at runtime, for example through <see cref="N:System.Reflection" /> .
class RequiresUnreferencedCodeAttribute
Indicates that the specified method requires dynamic access to code that is not referenced statically, for example, through <see cref="N:System.Reflection" /> .
class SetsRequiredMembersAttribute
Specifies that this constructor sets all required members for the current type, and callers do not need to set any required members themselves.
class StringSyntaxAttribute
Specifies the syntax used in a string.
class SuppressMessageAttribute
Suppresses reporting of a specific code analysis rule violation, allowing multiple suppressions on a single code artifact. Does not apply to compiler diagnostics.
class UnconditionalSuppressMessageAttribute
Suppresses reporting of a specific rule violation, allowing multiple suppressions on a single code artifact.
class UnscopedRefAttribute
Used to indicate a byref escapes and is not scoped.

System.​Globalization

class Calendar
Represents time in divisions, such as weeks, months, and years.
enum CalendarAlgorithmType
Specifies whether a calendar is solar-based, lunar-based, or lunisolar-based.
enum CalendarWeekRule
Defines different rules for determining the first week of the year.
class CharUnicodeInfo
Retrieves information about a Unicode character. This class cannot be inherited.
class ChineseLunisolarCalendar
Represents time in divisions, such as months, days, and years. Years are calculated using the Chinese calendar, while days and months are calculated using the lunisolar calendar.
class CompareInfo
Implements a set of methods for culture-sensitive string comparisons.
enum CompareOptions
Defines the string comparison options to use with <see cref="T:System.Globalization.CompareInfo" /> .
class CultureInfo
Provides information about a specific culture (called a locale for unmanaged code development). The information includes the names for the culture, the writing system, the calendar used, the sort order of strings, and formatting for dates and numbers.
class CultureNotFoundException
The exception that is thrown when a method attempts to construct a culture that is not available.
enum CultureTypes
Defines the types of culture lists that can be retrieved using the <see cref="M:System.Globalization.CultureInfo.GetCultures(System.Globalization.CultureTypes)" /> method.
class DateTimeFormatInfo
Provides culture-specific information about the format of date and time values.
enum DateTimeStyles
Defines the formatting options that customize string parsing for some date and time parsing methods.
class DaylightTime
Defines the period of daylight saving time.
enum DigitShapes
Specifies the culture-specific display of digits.
class EastAsianLunisolarCalendar
Represents a calendar that divides time into months, days, years, and eras, and has dates that are based on cycles of the sun and the moon.
class GlobalizationExtensions
Provides globalization-related extension methods.
class GregorianCalendar
Represents the Gregorian calendar.
enum GregorianCalendarTypes
Defines the different language versions of the Gregorian calendar.
class HebrewCalendar
Represents the Hebrew calendar.
class HijriCalendar
Represents the Hijri calendar.
class IdnMapping
Supports the use of non-ASCII characters for Internet domain names. This class cannot be inherited.
class ISOWeek
Provides static members to support the ISO week date that is part of the ISO 8601 date and time standard issued by the International Organization for Standardization (ISO).
class JapaneseCalendar
Represents the Japanese calendar.
class JapaneseLunisolarCalendar
Represents time in divisions, such as months, days, and years. Years are calculated as for the Japanese calendar, while days and months are calculated using the lunisolar calendar.
class JulianCalendar
Represents the Julian calendar.
class KoreanCalendar
Represents the Korean calendar.
class KoreanLunisolarCalendar
Represents time in divisions, such as months, days, and years. Years are calculated using the Gregorian calendar, while days and months are calculated using the lunisolar calendar.
class NumberFormatInfo
Provides culture-specific information for formatting and parsing numeric values.
enum NumberStyles
Determines the styles permitted in numeric string arguments that are passed to the <see langword="Parse" /> and <see langword="TryParse" /> methods of the integral and floating-point numeric types.
class PersianCalendar
Represents the Persian calendar.
class RegionInfo
Contains information about the country/region.
class SortKey
Represents the result of mapping a string to its sort key.
class SortVersion
Provides information about the version of Unicode used to compare and order strings.
class StringInfo
Provides functionality to split a string into text elements and to iterate through those text elements.
class TaiwanCalendar
the Taiwan calendar.
class TaiwanLunisolarCalendar
Represents the Taiwan lunisolar calendar. As for the Taiwan calendar, years are calculated using the Gregorian calendar, while days and months are calculated using the lunisolar calendar.
class TextElementEnumerator
Enumerates the text elements of a string.
class TextInfo
Defines text properties and behaviors, such as casing, that are specific to a writing system.
class ThaiBuddhistCalendar
Represents the Thai Buddhist calendar.
enum TimeSpanStyles
Defines the formatting options that customize string parsing for the <see cref="Overload:System.TimeSpan.ParseExact" /> and <see cref="Overload:System.TimeSpan.TryParseExact" /> methods.
class UmAlQuraCalendar
Represents the Saudi Hijri (Um Al Qura) calendar.
enum UnicodeCategory
Defines the Unicode category of a character.

System.​IO

class BinaryReader
Reads primitive data types as binary values in a specific encoding.
class BinaryWriter
Writes primitive types in binary to a stream and supports writing strings in a specific encoding.
class BufferedStream
Adds a buffering layer to read and write operations on another stream. This class cannot be inherited.
class Directory
Exposes static methods for creating, moving, and enumerating through directories and subdirectories. This class cannot be inherited.
class DirectoryInfo
Exposes instance methods for creating, moving, and enumerating through directories and subdirectories. This class cannot be inherited.
class DirectoryNotFoundException
The exception that is thrown when part of a file or directory cannot be found.
class EndOfStreamException
The exception that is thrown when reading is attempted past the end of a stream.
class EnumerationOptions
Provides file and directory enumeration options.
class File
Provides static methods for the creation, copying, deletion, moving, and opening of a single file, and aids in the creation of <see cref="T:System.IO.FileStream" /> objects.
enum FileAccess
Defines constants for read, write, or read/write access to a file.
enum FileAttributes
Provides attributes for files and directories.
class FileInfo
Provides properties and instance methods for the creation, copying, deletion, moving, and opening of files, and aids in the creation of <see cref="T:System.IO.FileStream" /> objects. This class cannot be inherited.
class FileLoadException
The exception that is thrown when a managed assembly is found but cannot be loaded.
enum FileMode
Specifies how the operating system should open a file.
class FileNotFoundException
The exception that is thrown when an attempt to access a file that does not exist on disk fails.
enum FileOptions
Represents advanced options for creating a <see cref="T:System.IO.FileStream" /> object.
enum FileShare
Contains constants for controlling the kind of access other operations can have to the same file.
class FileStream
Provides a <see cref="T:System.IO.Stream" /> for a file, supporting both synchronous and asynchronous read and write operations.
class FileStreamOptions
Defines a variety of configuration options for <see cref="T:System.IO.FileStream" /> .
class FileSystemInfo
Provides the base class for both <see cref="T:System.IO.FileInfo" /> and <see cref="T:System.IO.DirectoryInfo" /> objects.
enum HandleInheritability
Specifies whether the underlying handle is inheritable by child processes.
class InvalidDataException
The exception that is thrown when a data stream is in an invalid format.
class IOException
The exception that is thrown when an I/O error occurs.
enum MatchCasing
Specifies the type of character casing to match.
enum MatchType
Specifies the type of wildcard matching to use.
class MemoryStream
Creates a stream whose backing store is memory.
class Path
Performs operations on <see cref="T:System.String" /> instances that contain file or directory path information. These operations are performed in a cross-platform manner.
class PathTooLongException
The exception that's thrown when a path or fully qualified file name is longer than the system-defined maximum length.
class RandomAccess
Provides offset-based APIs for reading and writing files in a thread-safe manner.
enum SearchOption
Specifies whether to search the current directory, or the current directory and all subdirectories.
enum SeekOrigin
Specifies the position in a stream to use for seeking.
class Stream
Provides a generic view of a sequence of bytes. This is an abstract class.
class StreamReader
Implements a <see cref="T:System.IO.TextReader" /> that reads characters from a byte stream in a particular encoding.
class StreamWriter
Implements a <see cref="T:System.IO.TextWriter" /> for writing characters to a stream in a particular encoding.
class StringReader
Implements a <see cref="T:System.IO.TextReader" /> that reads from a string.
class StringWriter
Implements a <see cref="T:System.IO.TextWriter" /> for writing information to a string. The information is stored in an underlying <see cref="T:System.Text.StringBuilder" /> .
class TextReader
Represents a reader that can read a sequential series of characters.
class TextWriter
Represents a writer that can write a sequential series of characters. This class is abstract.
enum UnixFileMode
<para>Represents the Unix filesystem permissions.</para> <para>This enumeration supports a bitwise combination of its member values.</para>
class UnmanagedMemoryStream
Provides access to unmanaged blocks of memory from managed code.

System.​IO.​Enumeration

struct FileSystemEntry
Provides a lower level view of <see cref="T:System.IO.FileSystemInfo" /> to help process and filter find results.
class FileSystemEnumerable`1
Allows utilizing custom filter predicates and transform delegates for enumeration purposes.
class FileSystemEnumerator`1
Enumerates the file system elements of the provided type that are being searched and filtered by a <see cref="T:System.IO.Enumeration.FileSystemEnumerable`1" /> .
class FileSystemName
Provides methods for matching file system names.

System.​Net

class WebUtility
Provides methods for encoding and decoding URLs when processing Web requests.

System.​Numerics

class BitOperations
Provides utility methods for intrinsic bit-twiddling operations. The methods use hardware intrinsics when available on the underlying platform; otherwise, they use optimized software fallbacks.
struct IAdditionOperators`3
Defines a mechanism for computing the sum of two values.
struct IAdditiveIdentity`2
Defines a mechanism for getting the additive identity of a given type.
struct IBinaryFloatingPointIeee754`1
Defines an IEEE 754 floating-point type that is represented in a base-2 format.
struct IBinaryInteger`1
Defines an integer type that is represented in a base-2 format.
struct IBinaryNumber`1
Defines a number that is represented in a base-2 format.
struct IBitwiseOperators`3
Defines a mechanism for performing bitwise operations over two values.
struct IComparisonOperators`3
Defines a mechanism for comparing two values to determine relative order.
struct IDecrementOperators`1
Defines a mechanism for decrementing a given value.
struct IDivisionOperators`3
Defines a mechanism for computing the quotient of two values.
struct IEqualityOperators`3
Defines a mechanism for comparing two values to determine equality.
struct IExponentialFunctions`1
Defines support for exponential functions.
struct IFloatingPoint`1
Defines a floating-point type.
struct IFloatingPointConstants`1
Defines support for floating-point constants.
struct IFloatingPointIeee754`1
Defines an IEEE 754 floating-point type.
struct IHyperbolicFunctions`1
Defines support for hyperbolic functions.
struct IIncrementOperators`1
Defines a mechanism for incrementing a given value.
struct ILogarithmicFunctions`1
Defines support for logarithmic functions.
struct IMinMaxValue`1
Defines a mechanism for getting the minimum and maximum value of a type.
struct IModulusOperators`3
Defines a mechanism for computing the modulus or remainder of two values.
struct IMultiplicativeIdentity`2
Defines a mechanism for getting the multiplicative identity of a given type.
struct IMultiplyOperators`3
Defines a mechanism for computing the product of two values.
struct INumber`1
Defines a number type.
struct INumberBase`1
Defines the base of other number types.
struct IPowerFunctions`1
Defines support for power functions.
struct IRootFunctions`1
Defines support for root functions.
struct IShiftOperators`3
Defines a mechanism for shifting a value by another value.
struct ISignedNumber`1
Defines a number type that can represent both positive and negative values.
struct ISubtractionOperators`3
Defines a mechanism for computing the difference of two values.
struct ITrigonometricFunctions`1
Defines support for trigonometric functions.
struct IUnaryNegationOperators`2
Defines a mechanism for computing the unary negation of a value.
struct IUnaryPlusOperators`2
Defines a mechanism for computing the unary plus of a value.
struct IUnsignedNumber`1
Defines a number type that can only represent positive values.
struct TotalOrderIeee754Comparer`1
Represents a comparison operation that compares floating-point numbers with IEEE 754 totalOrder semantic.

System.​Reflection

class AmbiguousMatchException
The exception that is thrown when binding to a member results in more than one member matching the binding criteria. This class cannot be inherited.
class Assembly
Represents an assembly, which is a reusable, versionable, and self-describing building block of a common language runtime application.
class AssemblyAlgorithmIdAttribute
Specifies an algorithm to hash all files in an assembly. This class cannot be inherited.
class AssemblyCompanyAttribute
Defines a company name custom attribute for an assembly manifest.
class AssemblyConfigurationAttribute
Specifies the build configuration, such as retail or debug, for an assembly.
enum AssemblyContentType
Provides information about the type of code contained in an assembly.
class AssemblyCopyrightAttribute
Defines a copyright custom attribute for an assembly manifest.
class AssemblyCultureAttribute
Specifies which culture the assembly supports.
class AssemblyDefaultAliasAttribute
Defines a friendly default alias for an assembly manifest.
class AssemblyDelaySignAttribute
Specifies that the assembly is not fully signed when created.
class AssemblyDescriptionAttribute
Provides a text description for an assembly.
class AssemblyFileVersionAttribute
Instructs a compiler to use a specific version number for the Win32 file version resource. The Win32 file version is not required to be the same as the assembly's version number.
class AssemblyFlagsAttribute
Specifies a bitwise combination of <see cref="T:System.Reflection.AssemblyNameFlags" /> flags for an assembly, describing just-in-time (JIT) compiler options, whether the assembly is retargetable, and whether it has a full or tokenized public key. This class cannot be inherited.
class AssemblyInformationalVersionAttribute
Defines additional version information for an assembly manifest.
class AssemblyKeyFileAttribute
Specifies the name of a file containing the key pair used to generate a strong name.
class AssemblyKeyNameAttribute
Specifies the name of a key container within the CSP containing the key pair used to generate a strong name.
class AssemblyMetadataAttribute
Defines a key/value metadata pair for the decorated assembly.
class AssemblyName
Describes an assembly's unique identity in full.
enum AssemblyNameFlags
Provides information about an <see cref="T:System.Reflection.Assembly" /> reference.
class AssemblyNameProxy
Provides a remotable version of the <see langword="AssemblyName" /> .
class AssemblyProductAttribute
Defines a product name custom attribute for an assembly manifest.
class AssemblySignatureKeyAttribute
Provides migration from an older, simpler strong name key to a larger key with a stronger hashing algorithm.
class AssemblyTitleAttribute
Specifies a description for an assembly.
class AssemblyTrademarkAttribute
Defines a trademark custom attribute for an assembly manifest.
class AssemblyVersionAttribute
Specifies the version of the assembly being attributed.
class Binder
Selects a member from a list of candidates, and performs type conversion from actual argument type to formal argument type.
enum BindingFlags
Specifies flags that control binding and the way in which the search for members and types is conducted by reflection.
enum CallingConventions
Defines the valid calling conventions for a method.
class ConstructorInfo
Discovers the attributes of a class constructor and provides access to constructor metadata.
class ConstructorInvoker
Provides methods to invoke the method specified by the provided <see cref="T:System.Reflection.ConstructorInfo" /> .
class CustomAttributeData
Provides access to custom attribute data for assemblies, modules, types, members and parameters that are loaded into the reflection-only context.
class CustomAttributeExtensions
Contains static methods for retrieving custom attributes.
class CustomAttributeFormatException
The exception that is thrown when the binary format of a custom attribute is invalid.
struct CustomAttributeNamedArgument
Represents a named argument of a custom attribute in the reflection-only context.
struct CustomAttributeTypedArgument
Represents an argument of a custom attribute in the reflection-only context, or an element of an array argument.
class DefaultMemberAttribute
Defines the member of a type that is the default member used by <see cref="M:System.Type.InvokeMember(System.String,System.Reflection.BindingFlags,System.Reflection.Binder,System.Object,System.Object[],System.Reflection.ParameterModifier[],System.Globalization.CultureInfo,System.String[])" /> .
enum EventAttributes
Specifies the attributes of an event.
class EventInfo
Discovers the attributes of an event and provides access to event metadata.
class ExceptionHandlingClause
Represents a clause in a structured exception-handling block.
enum ExceptionHandlingClauseOptions
Identifies kinds of exception-handling clauses.
enum FieldAttributes
Specifies flags that describe the attributes of a field.
class FieldInfo
Discovers the attributes of a field and provides access to field metadata.
enum GenericParameterAttributes
Describes the constraints on a generic type parameter of a generic type or method.
struct ICustomAttributeProvider
Provides custom attributes for reflection objects that support them.
enum ImageFileMachine
Identifies the platform targeted by an executable.
struct InterfaceMapping
Retrieves the mapping of an interface into the actual methods on a class that implements that interface.
class IntrospectionExtensions
Contains methods for converting <see cref="T:System.Type" /> objects.
class InvalidFilterCriteriaException
The exception that is thrown in <see cref="M:System.Type.FindMembers(System.Reflection.MemberTypes,System.Reflection.BindingFlags,System.Reflection.MemberFilter,System.Object)" /> when the filter criteria is not valid for the type of filter you are using.
struct IReflect
Interoperates with the IDispatch interface.
struct IReflectableType
Represents a type that you can reflect over.
class LocalVariableInfo
Discovers the attributes of a local variable and provides access to local variable metadata.
class ManifestResourceInfo
Provides access to manifest resources, which are XML files that describe application dependencies.
class MemberFilter
Represents a delegate that is used to filter a list of members represented in an array of <see cref="T:System.Reflection.MemberInfo" /> objects.
class MemberInfo
Obtains information about the attributes of a member and provides access to member metadata.
enum MemberTypes
Marks each type of member that is defined as a derived class of <see cref="T:System.Reflection.MemberInfo" /> .
enum MethodAttributes
Specifies flags for method attributes. These flags are defined in the corhdr.h file.
class MethodBase
Provides information about methods and constructors.
class MethodBody
Provides access to the metadata and MSIL for the body of a method.
enum MethodImplAttributes
Specifies flags for the attributes of a method implementation.
class MethodInfo
Discovers the attributes of a method and provides access to method metadata.
class MethodInvoker
Provides methods to invoke the method specified by the provided <see cref="T:System.Reflection.MethodBase" /> .
class Missing
Represents a missing <see cref="T:System.Object" /> . This class cannot be inherited.
class Module
Performs reflection on a module.
class ModuleResolveEventHandler
Represents the method that will handle the <see cref="E:System.Reflection.Assembly.ModuleResolve" /> event of an <see cref="T:System.Reflection.Assembly" /> .
class NullabilityInfo
Represents nullability information.
class NullabilityInfoContext
Provides APIs for populating nullability information and context from reflection members: <see cref="T:System.Reflection.ParameterInfo" /> , <see cref="T:System.Reflection.FieldInfo" /> , <see cref="T:System.Reflection.PropertyInfo" /> , and <see cref="T:System.Reflection.EventInfo" /> .
enum NullabilityState
Describes nullability states.
class ObfuscateAssemblyAttribute
Instructs obfuscation tools to use their standard obfuscation rules for the appropriate assembly type.
class ObfuscationAttribute
Instructs obfuscation tools to take the specified actions for an assembly, type, or member.
enum ParameterAttributes
Defines the attributes that can be associated with a parameter. These are defined in CorHdr.h.
class ParameterInfo
Discovers the attributes of a parameter and provides access to parameter metadata.
struct ParameterModifier
Attaches a modifier to parameters so that binding can work with parameter signatures in which the types have been modified.
class Pointer
Provides a wrapper class for pointers.
enum PortableExecutableKinds
Identifies the nature of the code in an executable file.
enum ProcessorArchitecture
Identifies the processor and bits-per-word of the platform targeted by an executable.
enum PropertyAttributes
Defines the attributes that can be associated with a property. These attribute values are defined in corhdr.h.
class PropertyInfo
Discovers the attributes of a property and provides access to property metadata.
class ReflectionContext
Represents a context that can provide reflection objects.
class ReflectionTypeLoadException
The exception that is thrown by the <see cref="M:System.Reflection.Module.GetTypes" /> method if any of the classes in a module cannot be loaded. This class cannot be inherited.
enum ResourceAttributes
Specifies the attributes for a manifest resource.
enum ResourceLocation
Specifies the resource location.
class RuntimeReflectionExtensions
Provides methods that retrieve information about types at run time.
class StrongNameKeyPair
Encapsulates access to a public or private key pair used to sign strong name assemblies.
class TargetException
Represents the exception that is thrown when an attempt is made to invoke an invalid target.
class TargetInvocationException
The exception that is thrown by methods invoked through reflection. This class cannot be inherited.
class TargetParameterCountException
The exception that is thrown when the number of parameters for an invocation does not match the number expected. This class cannot be inherited.
enum TypeAttributes
Specifies type attributes.
class TypeDelegator
Wraps a <see cref="T:System.Type" /> object and delegates methods to that <see langword="Type" /> .
class TypeFilter
Filters the classes represented in an array of <see cref="T:System.Type" /> objects.
class TypeInfo
Represents type declarations for class types, interface types, array types, value types, enumeration types, type parameters, generic type definitions, and open or closed constructed generic types.

System.​Resources

struct IResourceReader
Provides the base functionality for reading data from resource files.
class MissingManifestResourceException
The exception that is thrown if the main assembly does not contain the resources for the neutral culture, and an appropriate satellite assembly is missing.
class MissingSatelliteAssemblyException
The exception that is thrown when the satellite assembly for the resources of the default culture is missing.
class NeutralResourcesLanguageAttribute
Informs the resource manager of an app's default culture. This class cannot be inherited.
class ResourceManager
Represents a resource manager that provides convenient access to culture-specific resources at run time.
class ResourceReader
Enumerates the resources in a binary resources (.resources) file by reading sequential resource name/value pairs.
class ResourceSet
Stores all the resources localized for one particular culture, ignoring all other cultures, including any fallback rules.
class SatelliteContractVersionAttribute
Instructs a <see cref="T:System.Resources.ResourceManager" /> object to ask for a particular version of a satellite assembly.
enum UltimateResourceFallbackLocation
Specifies whether a <see cref="T:System.Resources.ResourceManager" /> object looks for the resources of the app's default culture in the main assembly or in a satellite assembly.

System.​Runtime

class AmbiguousImplementationException
The exception that is thrown when there are multiple incompatible interface methods overriding another method.
class AssemblyTargetedPatchBandAttribute
Specifies patch band information for targeted patching of .NET.
class ControlledExecution
Enables code to be run and aborted asynchronously.
struct DependentHandle
Represents a dependent garbage-collection handle. The handle will conditionally keep a dependent object instance alive as long as a target object instance is alive as well, without representing a strong reference to the target instance.
enum GCLargeObjectHeapCompactionMode
Indicates whether the next blocking garbage collection compacts the large object heap (LOH).
enum GCLatencyMode
Adjusts the time that the garbage collector intrudes in your application.
class GCSettings
Specifies the garbage collection settings for the current process.
class JitInfo
Provides information about the Just In Time compiler. This class cannot be inherited.
class MemoryFailPoint
Checks for sufficient memory resources before executing an operation. This class cannot be inherited.
class ProfileOptimization
Improves the startup performance of application domains in applications that require the just-in-time (JIT) compiler by performing background compilation of methods that are likely to be executed, based on profiles created during previous compilations.
class TargetedPatchingOptOutAttribute
Indicates that the .NET class library method to which this attribute is applied is unlikely to be affected by servicing releases, and therefore is eligible to be inlined across Native Image Generator (NGen) images.

System.​Runtime.​CompilerServices

class AccessedThroughPropertyAttribute
Specifies the name of the property that accesses the attributed field.
class AsyncHelpers
struct AsyncIteratorMethodBuilder
Represents a builder for asynchronous iterators.
class AsyncIteratorStateMachineAttribute
Indicates whether a method is an asynchronous iterator.
class AsyncMethodBuilderAttribute
Indicates the type of the async method builder that should be used by a language compiler to build the attributed type when used as the return type of an async method.
class AsyncStateMachineAttribute
Indicates whether a method is marked with either the Async or async modifier.
struct AsyncTaskMethodBuilder
Represents a builder for asynchronous methods that return a task.
struct AsyncTaskMethodBuilder`1
Represents a builder for asynchronous methods that returns a task and provides a parameter for the result.
struct AsyncValueTaskMethodBuilder
Represents a builder for asynchronous methods that return a <see cref="T:System.Threading.Tasks.ValueTask" /> .
struct AsyncValueTaskMethodBuilder`1
Represents a builder for asynchronous methods that returns a <see cref="T:System.Threading.Tasks.ValueTask`1" /> .
struct AsyncVoidMethodBuilder
Represents a builder for asynchronous methods that do not return a value.
class CallConvCdecl
Indicates that a method should use the <see langword="Cdecl" /> calling convention.
class CallConvFastcall
This calling convention is not supported in this version of .NET.
class CallConvMemberFunction
Indicates that the calling convention used is the member function variant.
class CallConvStdcall
Indicates that a method should use the <see langword="StdCall" /> calling convention.
class CallConvSuppressGCTransition
Indicates that a method should suppress the GC transition as part of the calling convention.
class CallConvSwift
Indicates that a method should using the Swift calling convention.
class CallConvThiscall
Indicates that a method should use the <see langword="ThisCall" /> calling convention.
class CallerArgumentExpressionAttribute
Indicates that a parameter captures the expression passed for another parameter as a string.
class CallerFilePathAttribute
Tags parameter that should be filled with specific caller source file path.
class CallerLineNumberAttribute
Tags parameter that should be filled with specific caller line number.
class CallerMemberNameAttribute
Tags parameter that should be filled with specific caller member name.
class CollectionBuilderAttribute
enum CompilationRelaxations
Specifies parameters that control the strictness of the code generated by the common language runtime's just-in-time (JIT) compiler.
class CompilationRelaxationsAttribute
Controls the strictness of the code generated by the common language runtime's just-in-time (JIT) compiler.
class CompilerFeatureRequiredAttribute
Indicates that compiler support for a particular feature is required for the location where this attribute is applied.
class CompilerGeneratedAttribute
Distinguishes a compiler-generated element from a user-generated element. This class cannot be inherited.
class CompilerGlobalScopeAttribute
Indicates that a class should be treated as if it has global scope.
class CompilerLoweringPreserveAttribute
<para>Represents an attribute that, when applied to an attribute class, instructs the compiler to flow applications of that attribute, from source code down to compiler-generated symbols. This flow can help IL-based analysis tools.</para>
class ConditionalWeakTable`2
Enables compilers to dynamically attach object fields to managed objects.
struct ConfiguredAsyncDisposable
Provides a type that can be used to configure how awaits on an <see cref="T:System.IAsyncDisposable" /> are performed.
struct ConfiguredCancelableAsyncEnumerable`1
Provides an awaitable async enumerable that enables cancelable iteration and configured awaits.
struct ConfiguredTaskAwaitable
Provides an awaitable object that enables configured awaits on a task.
struct ConfiguredTaskAwaitable`1
Provides an awaitable object that enables configured awaits on a task.
struct ConfiguredValueTaskAwaitable
Provides an awaitable type that enables configured awaits on a <see cref="T:System.Threading.Tasks.ValueTask" /> .
struct ConfiguredValueTaskAwaitable`1
Provides an awaitable type that enables configured awaits on a <see cref="T:System.Threading.Tasks.ValueTask`1" /> .
class CustomConstantAttribute
Defines a constant value that a compiler can persist for a field or method parameter.
class DateTimeConstantAttribute
Persists an 8-byte <see cref="T:System.DateTime" /> constant for a field or parameter.
class DecimalConstantAttribute
Stores the value of a <see cref="T:System.Decimal" /> constant in metadata. This class cannot be inherited.
class DefaultDependencyAttribute
Provides a hint to the common language runtime (CLR) indicating how likely a dependency is to be loaded. This class is used in a dependent assembly to indicate what hint should be used when the parent does not specify the <see cref="T:System.Runtime.CompilerServices.DependencyAttribute" /> attribute. This class cannot be inherited.
struct DefaultInterpolatedStringHandler
Provides a handler used by the language compiler to process interpolated strings into <see cref="T:System.String" /> instances.
class DependencyAttribute
Indicates when a dependency is to be loaded by the referring assembly. This class cannot be inherited.
class DisablePrivateReflectionAttribute
Indicates that any private members contained in an assembly's types are not available to reflection.
class DisableRuntimeMarshallingAttribute
Disables the built-in runtime managed/unmanaged marshalling subsystem for P/Invokes, Delegate types, and unmanaged function pointer invocations.
class DiscardableAttribute
Marks a type definition as discardable.
class EnumeratorCancellationAttribute
Allows users of async-enumerable methods to mark the parameter that should receive the cancellation token value from <see cref="M:System.Collections.Generic.IAsyncEnumerable`1.GetAsyncEnumerator(System.Threading.CancellationToken)" /> .
class ExtensionAttribute
Indicates that a method is an extension method, or that a class or assembly contains extension methods.
class ExtensionMarkerAttribute
<para>Represents an attribute that's used to mark extension members and associate them with a specific marker type (which provides detailed information about an extension block and its receiver parameter).</para> <forInternalUseOnly />
class FixedAddressValueTypeAttribute
Fixes the address of a static value type field throughout its lifetime. This class cannot be inherited.
class FixedBufferAttribute
Indicates that a field should be treated as containing a fixed number of elements of the specified primitive type. This class cannot be inherited.
class FormattableStringFactory
Provides a static method to create a <see cref="T:System.FormattableString" /> object from a composite format string and its arguments.
struct IAsyncStateMachine
Represents state machines that are generated for asynchronous methods. This type is intended for compiler use only.
struct ICriticalNotifyCompletion
Represents an awaiter that schedules continuations when an await operation completes.
class IndexerNameAttribute
Indicates the name by which an indexer is known in programming languages that do not support indexers directly.
struct InlineArray10`1
Represents an inline array of <typeparamref name="T" /> with a fixed length of 10.
struct InlineArray11`1
Represents an inline array of <typeparamref name="T" /> with a fixed length of 11.
struct InlineArray12`1
Represents an inline array of <typeparamref name="T" /> with a fixed length of 12.
struct InlineArray13`1
Represents an inline array of <typeparamref name="T" /> with a fixed length of 13.
struct InlineArray14`1
Represents an inline array of <typeparamref name="T" /> with a fixed length of 14.
struct InlineArray15`1
Represents an inline array of <typeparamref name="T" /> with a fixed length of 15.
struct InlineArray16`1
Represents an inline array of <typeparamref name="T" /> with a fixed length of 16.
struct InlineArray2`1
Represents an inline array of <typeparamref name="T" /> with a fixed length of 2.
struct InlineArray3`1
Represents an inline array of <typeparamref name="T" /> with a fixed length of 3.
struct InlineArray4`1
Represents an inline array of <typeparamref name="T" /> with a fixed length of 4.
struct InlineArray5`1
Represents an inline array of <typeparamref name="T" /> with a fixed length of 5.
struct InlineArray6`1
Represents an inline array of <typeparamref name="T" /> with a fixed length of 6.
struct InlineArray7`1
Represents an inline array of <typeparamref name="T" /> with a fixed length of 7.
struct InlineArray8`1
Represents an inline array of <typeparamref name="T" /> with a fixed length of 8.
struct InlineArray9`1
Represents an inline array of <typeparamref name="T" /> with a fixed length of 9.
class InlineArrayAttribute
Indicates that the instance's storage is sequentially replicated <see cref="P:System.Runtime.CompilerServices.InlineArrayAttribute.Length" /> times.
struct INotifyCompletion
Represents an operation that schedules continuations when it completes.
class InternalsVisibleToAttribute
Specifies that types that are ordinarily visible only within the current assembly are visible to a specified assembly.
class InterpolatedStringHandlerArgumentAttribute
Indicates which arguments to a method involving an interpolated string handler should be passed to that handler.
class InterpolatedStringHandlerAttribute
Indicates the attributed type is to be used as an interpolated string handler.
class IsByRefLikeAttribute
Indicates that a structure is byref-like.
class IsConst
Indicates that the modified type has a <see langword="const" /> modifier. This class cannot be inherited.
class IsExternalInit
Reserved to be used by the compiler for tracking metadata. This class should not be used by developers in source code.
class IsReadOnlyAttribute
Marks a program element as read-only.
struct IStrongBox
Defines a property for accessing the value that an object references.
class IsUnmanagedAttribute
Reserved for use by a compiler for tracking metadata. This attribute should not be used by developers in source code.
class IsVolatile
Marks a field as volatile. This class cannot be inherited.
class IteratorStateMachineAttribute
Indicates whether a method in Visual Basic is marked with the <see langword="Iterator" /> modifier.
struct ITuple
Defines a general-purpose Tuple implementation that allows access to Tuple instance members without knowing the underlying Tuple type.
enum LoadHint
Specifies the preferred default binding for a dependent assembly.
enum MethodCodeType
Defines how a method is implemented.
class MethodImplAttribute
Specifies the details of how a method is implemented. This class cannot be inherited.
enum MethodImplOptions
Specifies constants that define the details of how a method is implemented.
class ModuleInitializerAttribute
Used to indicate to the compiler that a method should be called in its containing module's initializer.
class NullableAttribute
Reserved for use by a compiler for tracking metadata. This attribute should not be used by developers in source code.
class NullableContextAttribute
Reserved for use by a compiler for tracking metadata. This attribute should not be used by developers in source code.
class NullablePublicOnlyAttribute
Reserved for use by a compiler for tracking metadata. This attribute should not be used by developers in source code.
class OverloadResolutionPriorityAttribute
Specifies the priority of a member in overload resolution. When unspecified, the default priority is 0.
class ParamCollectionAttribute
Indicates that a method allows a variable number of arguments in its invocation.
struct PoolingAsyncValueTaskMethodBuilder
Represents a builder for asynchronous methods that return a <see cref="T:System.Threading.Tasks.ValueTask" /> .
struct PoolingAsyncValueTaskMethodBuilder`1
Represents a builder for asynchronous methods that returns a <see cref="T:System.Threading.Tasks.ValueTask`1" /> .
class PreserveBaseOverridesAttribute
Ensures that any virtual call to the method, whether it uses the base signature or derived signature of the method, executes the most derived override.
class ReferenceAssemblyAttribute
Identifies an assembly as a reference assembly, which contains metadata but no executable code.
class RefSafetyRulesAttribute
Indicates the language version of the ref safety rules used when the module was compiled.
class RequiredMemberAttribute
Specifies that a type has required members or that a member is required.
class RequiresLocationAttribute
Reserved for use by a compiler for tracking metadata. This attribute should not be used by developers in source code.
class RuntimeCompatibilityAttribute
Specifies whether to wrap exceptions that do not derive from the <see cref="T:System.Exception" /> class with a <see cref="T:System.Runtime.CompilerServices.RuntimeWrappedException" /> object. This class cannot be inherited.
class RuntimeFeature
Defines APIs to determine whether specific features are supported by the common language runtime.
class RuntimeHelpers
Provides a set of static methods and properties that provide support for compilers. This class cannot be inherited.
class RuntimeWrappedException
Wraps an exception that does not derive from the <see cref="T:System.Exception" /> class. This class cannot be inherited.
class ScopedRefAttribute
Reserved for use by a compiler for tracking metadata. This attribute should not be used by developers in source code.
class SkipLocalsInitAttribute
Indicates to the compiler that the .locals init flag should not be set in nested method headers when emitting to metadata.
class SpecialNameAttribute
Indicates that a type or member is treated in a special way by the runtime or tools. This class cannot be inherited.
class StateMachineAttribute
Allows you to determine whether a method is a state machine method.
class StringFreezingAttribute
Deprecated. Freezes a string literal when creating native images using the Ngen.exe (Native Image Generator). This class cannot be inherited.
class StrongBox`1
Holds a reference to a value.
class SuppressIldasmAttribute
Prevents the Ildasm.exe (IL Disassembler) from disassembling an assembly. This class cannot be inherited.
class SwitchExpressionException
Indicates that a switch expression that was non-exhaustive failed to match its input at runtime. The exception optionally contains an object representing the unmatched value.
struct TaskAwaiter
Provides an object that waits for the completion of an asynchronous task.
struct TaskAwaiter`1
Represents an object that waits for the completion of an asynchronous task and provides a parameter for the result.
class TupleElementNamesAttribute
Indicates that the use of a value tuple on a member is meant to be treated as a tuple with element names.
class TypeForwardedFromAttribute
Specifies a source <see cref="T:System.Type" /> in another assembly.
class TypeForwardedToAttribute
Specifies a destination <see cref="T:System.Type" /> in another assembly.
class Unsafe
Contains generic, low-level functionality for manipulating managed and unmanaged pointers.
class UnsafeAccessorAttribute
Provides access to an inaccessible member of a specific type.
enum UnsafeAccessorKind
Specifies the kind of target to which an <see cref="T:System.Runtime.CompilerServices.UnsafeAccessorAttribute" /> is providing access.
class UnsafeAccessorTypeAttribute
Provides access to an inaccessible type.
class UnsafeValueTypeAttribute
Specifies that a type contains an unmanaged array that might potentially overflow. This class cannot be inherited.
struct ValueTaskAwaiter
Provides an awaiter for a <see cref="T:System.Threading.Tasks.ValueTask" /> .
struct ValueTaskAwaiter`1
Provides an awaiter for a <see cref="T:System.Threading.Tasks.ValueTask`1" /> .
struct YieldAwaitable
Provides the context for waiting when asynchronously switching into a target environment.

System.​Runtime.​ConstrainedExecution

enum Cer
Specifies a method's behavior when called within a constrained execution region.
enum Consistency
Specifies a reliability contract.
class CriticalFinalizerObject
Ensures that all finalization code in derived classes is marked as critical.
class PrePrepareMethodAttribute
Instructs the native image generation service to prepare a method for inclusion in a constrained execution region (CER).
class ReliabilityContractAttribute
Defines a contract for reliability between the author of some code, and the developers who have a dependency on that code.

System.​Runtime.​ExceptionServices

class ExceptionDispatchInfo
Represents an exception whose state is captured at a certain point in code.
class ExceptionHandling
class FirstChanceExceptionEventArgs
Provides data for the notification event that is raised when a managed exception first occurs, before the common language runtime begins searching for event handlers.
class HandleProcessCorruptedStateExceptionsAttribute
Enables managed code to handle exceptions that indicate a corrupted process state.

System.​Runtime.​InteropServices

enum Architecture
Indicates the processor architecture.
enum CharSet
Dictates which character set marshaled strings should use.
class ComVisibleAttribute
Controls accessibility of an individual managed type or member, or of all types within an assembly, to COM.
class CriticalHandle
Represents a wrapper class for handle resources.
class ExternalException
The base exception type for all COM interop exceptions and structured exception handling (SEH) exceptions.
class FieldOffsetAttribute
Indicates the physical position of fields within the unmanaged representation of a class or structure.
struct GCHandle
Provides a way to access a managed object from unmanaged memory.
struct GCHandle`1
Represents a strongly typed GC handle to a managed object.
class GCHandleExtensions
Provides extension methods to operate with GC handles.
enum GCHandleType
Represents the types of handles the <see cref="T:System.Runtime.InteropServices.GCHandle" /> type can allocate.
class InAttribute
Indicates that data should be marshaled from the caller to the callee, but not back to the caller.
enum LayoutKind
Controls the layout of an object when exported to unmanaged code.
class MemoryMarshal
Provides methods to interoperate with <see cref="T:System.Memory`1" /> , <see cref="T:System.ReadOnlyMemory`1" /> , <see cref="T:System.Span`1" /> , and <see cref="T:System.ReadOnlySpan`1" /> .
struct OSPlatform
Represents an operating system platform.
class OutAttribute
Indicates that data should be marshaled from callee back to caller.
struct PinnedGCHandle`1
Represents a strongly typed GC handle to a managed object.
class RuntimeInformation
Provides information about the .NET runtime installation.
class SafeBuffer
Provides a controlled memory buffer that can be used for reading and writing. Attempts to access memory outside the controlled buffer (underruns and overruns) raise exceptions.
class SafeHandle
Represents a wrapper class for operating system handles. This class must be inherited.
class StructLayoutAttribute
Lets you control the physical layout of the data fields of a class or structure in memory.
class SuppressGCTransitionAttribute
Indicates that a garbage collection transition should be skipped when an unmanaged function call is made.
enum UnmanagedType
Identifies how to marshal parameters or fields to unmanaged code.
struct WeakGCHandle`1
Represents a strongly typed GC handle to a managed object.

System.​Runtime.​InteropServices.​Marshalling

class ContiguousCollectionMarshallerAttribute
Specifies that this marshaller entry-point type is a contiguous collection marshaller.
class CustomMarshallerAttribute
Indicates an entry point type for defining a marshaller.
enum MarshalMode
Represents the different marshalling modes.
class NativeMarshallingAttribute
Attribute used to provide a default custom marshaller type for a given managed type.
class ReadOnlySpanMarshaller`2
Supports marshalling a <see cref="T:System.ReadOnlySpan`1" /> from managed value to a contiguous native array of the unmanaged values of the elements.
class SafeHandleMarshaller`1
Marshals <see cref="T:System.Runtime.InteropServices.SafeHandle" /> -derived types following the lifetime rules for <see cref="T:System.Runtime.InteropServices.SafeHandle" /> objects.
class SpanMarshaller`2
Supports marshalling a <see cref="T:System.Span`1" /> from managed value to a contiguous native array of the unmanaged values of the elements.

System.​Runtime.​InteropServices.​Swift

struct SwiftError
Represents the Swift error context, indicating that the argument is the error context.
struct SwiftIndirectResult
Represents the Swift return buffer context.
struct SwiftSelf
Represents the Swift 'self' context, indicating that the argument is the self context.
struct SwiftSelf`1
Represents the Swift 'self' context when the argument is Swift frozen struct T, which is either enregistered into multiple registers, or passed by reference in the 'self' register.

System.​Runtime.​Remoting

class ObjectHandle
Wraps marshal-by-value object references, allowing them to be returned through an indirection.

System.​Runtime.​Serialization

struct IDeserializationCallback
Indicates that a class is to be notified when deserialization of the entire object graph has been completed. This interface is not called when you deserialize with <see cref="T:System.Xml.Serialization.XmlSerializer" /> .
struct IFormatterConverter
Provides the connection between an instance of <see cref="T:System.Runtime.Serialization.SerializationInfo" /> and the formatter-provided class best suited to parse the data inside the <see cref="T:System.Runtime.Serialization.SerializationInfo" /> .
struct IObjectReference
Indicates that the current interface implementer is a reference to another object.
struct ISafeSerializationData
Enables serialization of custom exception data in security-transparent code.
struct ISerializable
Allows an object to control its own serialization and deserialization through binary and XML serialization.
class OnDeserializedAttribute
When applied to a method, specifies that the method is called immediately after deserialization of an object in an object graph. The order of deserialization relative to other objects in the graph is non-deterministic.
class OnDeserializingAttribute
When applied to a method, specifies that the method is called during deserialization of an object in an object graph. The order of deserialization relative to other objects in the graph is non-deterministic.
class OnSerializedAttribute
When applied to a method, specifies that the method is called after serialization of an object in an object graph. The order of serialization relative to other objects in the graph is non-deterministic.
class OnSerializingAttribute
When applied to a method, specifies that the method is called during serialization of an object in an object graph. The order of serialization relative to other objects in the graph is non-deterministic.
class OptionalFieldAttribute
Specifies that a field can be missing from a serialization stream so that the <see cref="T:System.Runtime.Serialization.Formatters.Binary.BinaryFormatter" /> and the <see cref="T:System.Runtime.Serialization.Formatters.Soap.SoapFormatter" /> does not throw an exception.
class SafeSerializationEventArgs
Provides data for the <see cref="E:System.Exception.SerializeObjectState" /> event.
struct SerializationEntry
Holds the value, <see cref="T:System.Type" /> , and name of a serialized object.
class SerializationException
The exception thrown when an error occurs during serialization or deserialization.
class SerializationInfo
Stores all the data needed to serialize or deserialize an object. This class cannot be inherited.
class SerializationInfoEnumerator
Provides a formatter-friendly mechanism for parsing the data in <see cref="T:System.Runtime.Serialization.SerializationInfo" /> . This class cannot be inherited.
struct StreamingContext
Describes the source and destination of a given serialized stream, and provides an additional caller-defined context.
enum StreamingContextStates
Defines a set of flags that specifies the source or destination context for the stream during serialization.

System.​Runtime.​Versioning

class ComponentGuaranteesAttribute
Defines the compatibility guarantee of a component, type, or type member that may span multiple versions.
enum ComponentGuaranteesOptions
Describes the compatibility guarantee of a component, type, or type member that may span multiple versions.
class FrameworkName
Represents the name of a version of .NET.
class ObsoletedOSPlatformAttribute
Marks APIs that were obsoleted in a given operating system version.
class OSPlatformAttribute
Base type for all platform-specific API attributes.
class RequiresPreviewFeaturesAttribute
Indicates that an API is in preview. This attribute allows call sites to be flagged with a diagnostic that indicates that a preview feature is used. Authors can use this attribute to ship preview features in their assemblies.
class ResourceConsumptionAttribute
Specifies the resource consumed by the member of a class. This class cannot be inherited.
class ResourceExposureAttribute
Specifies the resource exposure for a member of a class. This class cannot be inherited.
enum ResourceScope
Identifies the scope of a sharable resource.
class SupportedOSPlatformAttribute
Indicates that an API is supported for a specified platform or operating system. If a version is specified, the API cannot be called from an earlier version. Multiple attributes can be applied to indicate support on multiple operating systems.
class SupportedOSPlatformGuardAttribute
Annotates a custom guard field, property or method with a supported platform name and optional version. Multiple attributes can be applied to indicate guard for multiple supported platforms.
class TargetFrameworkAttribute
Identifies the version of .NET that a particular assembly was compiled against.
class TargetPlatformAttribute
Specifies the operating system that a project targets, for example, Windows or iOS.
class UnsupportedOSPlatformAttribute
Marks APIs that were removed or are unsupported in a given operating system version.
class UnsupportedOSPlatformGuardAttribute
Annotates the custom guard field, property or method with an unsupported platform name and optional version. Multiple attributes can be applied to indicate guard for multiple unsupported platforms.
class VersioningHelper
Provides methods to aid developers in writing version-safe code. This class cannot be inherited.

System.​Security

class AllowPartiallyTrustedCallersAttribute
Allows an assembly to be called by partially trusted code. Without this declaration, only fully trusted callers are able to use the assembly. This class cannot be inherited.
struct IPermission
Defines methods implemented by permission types.
struct ISecurityEncodable
Defines the methods that convert permission object state to and from XML element representation.
struct IStackWalk
Manages the stack walk that determines whether all callers in the call stack have the required permissions to access a protected resource.
enum PartialTrustVisibilityLevel
Specifies the default partial-trust visibility for code that is marked with the <see cref="T:System.Security.AllowPartiallyTrustedCallersAttribute" /> (APTCA) attribute.
class PermissionSet
Represents a collection that can contain many different types of permissions.
class SecurityCriticalAttribute
Specifies that code or an assembly performs security-critical operations.
enum SecurityCriticalScope
Specifies the scope of a <see cref="T:System.Security.SecurityCriticalAttribute" /> .
class SecurityElement
Represents the XML object model for encoding security objects. This class cannot be inherited.
class SecurityException
The exception that is thrown when a security error is detected.
class SecurityRulesAttribute
Indicates the set of security rules the common language runtime should enforce for an assembly.
enum SecurityRuleSet
Identifies the set of security rules the common language runtime should enforce for an assembly.
class SecuritySafeCriticalAttribute
Identifies types or members as security-critical and safely accessible by transparent code.
class SecurityTransparentAttribute
Specifies that an assembly cannot cause an elevation of privilege.
class SecurityTreatAsSafeAttribute
Identifies which of the nonpublic <see cref="T:System.Security.SecurityCriticalAttribute" /> members are accessible by transparent code within the assembly.
class SuppressUnmanagedCodeSecurityAttribute
Allows managed code to call into unmanaged code without a stack walk. This class cannot be inherited.
class UnverifiableCodeAttribute
Marks modules containing unverifiable code. This class cannot be inherited.
class VerificationException
The exception that is thrown when the security policy requires code to be type safe and the verification process is unable to verify that the code is type safe.

System.​Security.​Cryptography

class CryptographicException
The exception that is thrown when an error occurs during a cryptographic operation.

System.​Security.​Permissions

class CodeAccessSecurityAttribute
Specifies the base attribute class for code access security.
enum PermissionState
Specifies whether a permission should have all or no access to resources at creation.
enum SecurityAction
Specifies the security actions that can be performed using declarative security.
class SecurityAttribute
Specifies the base attribute class for declarative security from which <see cref="T:System.Security.Permissions.CodeAccessSecurityAttribute" /> is derived.
class SecurityPermissionAttribute
Allows security actions for <see cref="T:System.Security.Permissions.SecurityPermission" /> to be applied to code using declarative security. This class cannot be inherited.
enum SecurityPermissionFlag
Specifies access flags for the security permission object.

System.​Security.​Principal

struct IIdentity
Defines the basic functionality of an identity object.
struct IPrincipal
Defines the basic functionality of a principal object.
enum PrincipalPolicy
Specifies how principal and identity objects should be created for an application domain. The default is <see langword="UnauthenticatedPrincipal" /> .
enum TokenImpersonationLevel
Defines security impersonation levels. Security impersonation levels govern the degree to which a server process can act on behalf of a client process.

System.​Text

class Ascii
Provides helper methods for working with ASCII-encoded text as bytes or characters.
class CompositeFormat
Represents a parsed composite format string.
class Decoder
Converts a sequence of encoded bytes into a set of characters.
class DecoderExceptionFallback
Provides a failure-handling mechanism, called a fallback, for an encoded input byte sequence that cannot be converted to an input character. The fallback throws an exception instead of decoding the input byte sequence. This class cannot be inherited.
class DecoderExceptionFallbackBuffer
Throws <see cref="T:System.Text.DecoderFallbackException" /> when an encoded input byte sequence cannot be converted to a decoded output character. This class cannot be inherited.
class DecoderFallback
Provides a failure-handling mechanism, called a fallback, for an encoded input byte sequence that cannot be converted to an output character.
class DecoderFallbackBuffer
Provides a buffer that allows a fallback handler to return an alternate string to a decoder when it cannot decode an input byte sequence.
class DecoderFallbackException
The exception that is thrown when a decoder fallback operation fails. This class cannot be inherited.
class DecoderReplacementFallback
Provides a failure-handling mechanism, called a fallback, for an encoded input byte sequence that cannot be converted to an output character. The fallback emits a user-specified replacement string instead of a decoded input byte sequence. This class cannot be inherited.
class DecoderReplacementFallbackBuffer
Represents a substitute output string that is emitted when the original input byte sequence cannot be decoded. This class cannot be inherited.
class Encoder
Converts a set of characters into a sequence of bytes.
class EncoderExceptionFallback
Provides a failure-handling mechanism, called a fallback, for an input character that cannot be converted to an output byte sequence. The fallback throws an exception if an input character cannot be converted to an output byte sequence. This class cannot be inherited.
class EncoderExceptionFallbackBuffer
Throws <see cref="T:System.Text.EncoderFallbackException" /> when an input character cannot be converted to an encoded output byte sequence. This class cannot be inherited.
class EncoderFallback
Provides a failure-handling mechanism, called a fallback, for an input character that cannot be converted to an encoded output byte sequence.
class EncoderFallbackBuffer
Provides a buffer that allows a fallback handler to return an alternate string to an encoder when it cannot encode an input character.
class EncoderFallbackException
The exception that is thrown when an encoder fallback operation fails. This class cannot be inherited.
class EncoderReplacementFallback
Provides a failure handling mechanism, called a fallback, for an input character that cannot be converted to an output byte sequence. The fallback uses a user-specified replacement string instead of the original input character. This class cannot be inherited.
class EncoderReplacementFallbackBuffer
Represents a substitute input string that is used when the original input character cannot be encoded. This class cannot be inherited.
class Encoding
Represents a character encoding.
class EncodingInfo
Provides basic information about an encoding.
class EncodingProvider
Provides the base class for an encoding provider, which supplies encodings that are unavailable on a particular platform.
enum NormalizationForm
Defines the type of normalization to perform.
struct Rune
Represents a Unicode scalar value ([ U+0000..U+D7FF ], inclusive; or [ U+E000..U+10FFFF ], inclusive).
class StringBuilder
Represents a mutable string of characters. This class cannot be inherited.
struct StringRuneEnumerator
Provides an enumerator for the <see cref="T:System.Text.Rune" /> values represented by a string.

System.​Text.​Unicode

class Utf8
Provides static methods that convert chunked data between UTF-8 and UTF-16 encodings.

System.​Threading

struct CancellationToken
Propagates notification that operations should be canceled.
struct CancellationTokenRegistration
Represents a callback delegate that has been registered with a <see cref="T:System.Threading.CancellationToken" /> .
class CancellationTokenSource
Signals to a <see cref="T:System.Threading.CancellationToken" /> that it should be canceled.
struct ITimer
Represents a timer that can have its due time and period changed.
enum LazyThreadSafetyMode
Specifies how a <see cref="T:System.Lazy`1" /> instance synchronizes access among multiple threads.
class Lock
Provides a mechanism for achieving mutual exclusion in regions of code between different threads.
class PeriodicTimer
Provides a periodic timer that enables waiting asynchronously for timer ticks.
class Timeout
Contains constants that specify infinite time-out intervals. This class cannot be inherited.
class Timer
Provides a mechanism for executing a method on a thread pool thread at specified intervals. This class cannot be inherited.
class TimerCallback
Represents the method that handles calls from a <see cref="T:System.Threading.Timer" /> .
class WaitHandle
Encapsulates operating system-specific objects that wait for exclusive access to shared resources.
class WaitHandleExtensions
Provides convenience methods to for working with a safe handle for a wait handle.

System.​Threading.​Tasks

class ConcurrentExclusiveSchedulerPair
Provides task schedulers that coordinate to execute tasks while ensuring that concurrent tasks may run concurrently and exclusive tasks never do.
enum ConfigureAwaitOptions
Options to control behavior when awaiting.
class Task
Represents an asynchronous operation.
class Task`1
Represents an asynchronous operation that can return a value.
class TaskAsyncEnumerableExtensions
Provides a set of static methods for configuring <see cref="T:System.Threading.Tasks.Task" /> -related behaviors on asynchronous enumerables and disposables.
class TaskCanceledException
Represents an exception used to communicate task cancellation.
class TaskCompletionSource
Represents the producer side of a <see cref="T:System.Threading.Tasks.Task" /> unbound to a delegate, providing access to the consumer side through the <see cref="T:System.Threading.Tasks.Task" /> property.
class TaskCompletionSource`1
Represents the producer side of a <see cref="T:System.Threading.Tasks.Task`1" /> unbound to a delegate, providing access to the consumer side through the <see cref="P:System.Threading.Tasks.TaskCompletionSource`1.Task" /> property.
enum TaskContinuationOptions
Specifies the behavior for a task that is created by using the <see cref="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" /> or <see cref="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0}},System.Threading.Tasks.TaskContinuationOptions)" /> method.
enum TaskCreationOptions
Specifies flags that control optional behavior for the creation and execution of tasks.
class TaskExtensions
Provides a set of static methods for <see cref="T:System.Threading.Tasks.Task" /> .
class TaskFactory
Provides support for creating and scheduling <see cref="T:System.Threading.Tasks.Task" /> objects.
class TaskFactory`1
Provides support for creating and scheduling <see cref="T:System.Threading.Tasks.Task`1" /> objects.
class TaskScheduler
Represents an object that handles the low-level work of queuing tasks onto threads.
class TaskSchedulerException
Represents an exception used to communicate an invalid operation by a <see cref="T:System.Threading.Tasks.TaskScheduler" /> .
enum TaskStatus
Represents the current stage in the lifecycle of a <see cref="T:System.Threading.Tasks.Task" /> .
class TaskToAsyncResult
Provides methods for using <see cref="T:System.Threading.Tasks.Task" /> to implement the Asynchronous Programming Model pattern based on "Begin" and "End" methods.
class UnobservedTaskExceptionEventArgs
Provides data for the event that is raised when a faulted <see cref="T:System.Threading.Tasks.Task" /> 's exception goes unobserved.
struct ValueTask
Provides an awaitable result of an asynchronous operation.
struct ValueTask`1
Provides a value type that wraps a <see cref="T:System.Threading.Tasks.Task`1" /> and a <typeparamref name="TResult" /> , only one of which is used.

System.​Threading.​Tasks.​Sources

struct IValueTaskSource
Represents an object that can be wrapped by a <see cref="T:System.Threading.Tasks.ValueTask" /> .
struct IValueTaskSource`1
Represents an object that can be wrapped by a <see cref="T:System.Threading.Tasks.ValueTask`1" /> .
struct ManualResetValueTaskSourceCore`1
Provides the core logic for implementing a manual-reset <see cref="T:System.Threading.Tasks.Sources.IValueTaskSource" /> or <see cref="T:System.Threading.Tasks.Sources.IValueTaskSource`1" /> .
enum ValueTaskSourceOnCompletedFlags
Provides flags passed from <see cref="T:System.Threading.Tasks.ValueTask" /> and <see cref="T:System.Threading.Tasks.ValueTask`1" /> to the <see langword="OnCompleted" /> method to control the behavior of a continuation.
enum ValueTaskSourceStatus
Indicates the status of an <see cref="T:System.Threading.Tasks.Sources.IValueTaskSource" /> or <see cref="T:System.Threading.Tasks.Sources.IValueTaskSource`1" /> .