System.Runtime.InteropServices Namespace

Allows an unmanaged method to call a managed method.

Specifies whether the type should be marshaled using the Automation marshaler or a custom proxy and stub.

Controls whether Unicode characters are converted to the closest matching ANSI characters.

Marshals data of type VT_BSTR from managed to unmanaged code. This class cannot be inherited.

Indicates the type of class interface to be generated for a class exposed to COM, if an interface is generated at all.

Specifies the class identifier of a coclass imported from a type library.

An unsafe class that provides a set of methods to access the underlying data representations of collections.

Indicates the COM alias for a parameter or field type.

Permits late-bound registration of an event handler.

Indicates to a COM client that all classes in the current version of an assembly are compatible with classes in an earlier version of the assembly.

Indicates that information was lost about a class or interface when it was imported from a type library to an assembly.

Specifies a default interface to expose to COM. This class cannot be inherited.

Identifies the source interface and the class that implements the methods of the event interface that is generated when a coclass is imported from a COM type library.

Provides methods that enable .NET delegates that handle events to be added and removed from COM objects.

The exception that is thrown when an unrecognized HRESULT is returned from a COM method call.

Indicates that the attributed type was previously defined in COM.

Specifies the method to call when you register an assembly for use from COM; this enables the execution of user-written code during the registration process.

Identifies a list of interfaces that are exposed as COM event sources for the attributed class.

Specifies the method to call when you unregister an assembly for use from COM; this allows for the execution of user-written code during the unregistration process.

Controls accessibility of an individual managed type or member, or of all types within an assembly, to COM.

Class for managing wrappers of COM IUnknown types.

Represents a wrapper class for handle resources.

Wraps objects the marshaler should marshal as a VT_CY.

Specifies the value of the CharSet enumeration. This class cannot be inherited.

Specifies the paths that are used to search for DLLs that provide functions for platform invokes.

Sets the default value of a parameter when called from a language that supports default parameters. This class cannot be inherited.

Wraps objects the marshaler should marshal as a VT_DISPATCH.

Specifies the COM dispatch identifier (DISPID) of a method, field, or property.

Indicates that the attributed method is exposed by an unmanaged dynamic-link library (DLL) as a static entry point.

Attribute required by any type that is returned by GetInterfaceImplementation(RuntimeTypeHandle).

Wraps objects the marshaler should marshal as a VT_ERROR.

The base exception type for all COM interop exceptions and structured exception handling (SEH) exceptions.

Indicates the physical position of fields within the unmanaged representation of a class or structure.

Provides extension methods to operate with GC handles.

Supplies an explicit Guid when an automatic GUID is undesirable.

Tracks outstanding handles and forces a garbage collection when the specified threshold is reached.

An unsafe class that provides a set of methods to access the underlying data representations of immutable collections.

Indicates that the types defined within an assembly were originally defined in a type library.

Indicates that data should be marshaled from the caller to the callee, but not back to the caller.

Indicates whether a managed interface is dual, dispatch-only, or IUnknown -only when exposed to COM.

The exception thrown when an invalid COM object is used.

The exception thrown by the marshaler when it encounters an argument of a variant type that can not be marshaled to managed code.

An unsafe class that provides a set of methods to access the underlying data representations of JSON types.

Indicates that a method's unmanaged signature expects a locale identifier (LCID) parameter.

Indicates that a source generator should create a function for marshalling arguments instead of relying on the runtime to generate an equivalent marshalling function at run time.

Provides support for user customization of interop stubs in managed-to-COM interop scenarios.

Provides a collection of methods for allocating unmanaged memory, copying unmanaged memory blocks, and converting managed to unmanaged types, as well as other miscellaneous methods used when interacting with unmanaged code.

Indicates how to marshal the data between managed and unmanaged code.

The exception that is thrown by the marshaler when it encounters a MarshalAsAttribute it does not support.

Provides methods to interoperate with Memory<T>, ReadOnlyMemory<T>, Span<T>, and ReadOnlySpan<T>.

Provides APIs for managing native libraries.

This class contains methods that are mainly used to manage native memory.

Indicates that a parameter is optional.

Indicates that data should be marshaled from callee back to caller.

Provides data for a PosixSignalRegistration event.

Handles a PosixSignal.

Indicates that the HRESULT signature transformation that takes place during COM interop calls should be suppressed.

Indicates that the attributed assembly is a primary interop assembly.

Allows the user to specify the ProgID of a class.

Provides a collection of static methods that return information about the common language runtime environment.

Provides information about the .NET runtime installation.

The exception thrown when the rank of an incoming SAFEARRAY does not match the rank specified in the managed signature.

The exception thrown when the type of the incoming SAFEARRAY does not match the type specified in the managed signature.

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.

Represents a wrapper class for operating system handles. This class must be inherited.

Represents structured exception handling (SEH) errors.

Provides a collection of methods for interoperating with ReadOnlySequence<T>.

Replaces the standard common language runtime (CLR) free-threaded marshaler with the standard OLE STA marshaler.

Lets you control the physical layout of the data fields of a class or structure in memory.

Indicates that a garbage collection transition should be skipped when an unmanaged function call is made.

Provides methods to interoperate with Tensor<T>, TensorSpan<T>, and ReadOnlyTensorSpan<T>.

Provides support for type equivalence.

Contains the FUNCFLAGS that were originally imported for this method from the COM type library.

Specifies which Type exclusively uses an interface. This class cannot be inherited.

Contains the TYPEFLAGS that were originally imported for this type from the COM type library.

Contains the VARFLAGS that were originally imported for this field from the COM type library.

Specifies the version number of an exported type library.

Represents an attribute that declares that an assembly should be inspected during type map building.

Represents an attribute that creates a type association between a type and its proxy.

Represents an attribute that defines type mapping between a string and a type.

Represents an entry type for interop type-mapping logic.

Wraps objects the marshaler should marshal as a VT_UNKNOWN.

Specifies the calling convention required to call P/Invoke methods implemented in unmanaged code.

Any method marked with UnmanagedCallersOnlyAttribute can be directly called from native code. The function token can be loaded to a local variable using the address-of operator in C# and passed as a callback to a native method.

Controls the marshaling behavior of a delegate signature passed as an unmanaged function pointer to or from unmanaged code. This class cannot be inherited.

Marshals data of type VT_VARIANT | VT_BYREF from managed to unmanaged code. This class cannot be inherited.

Specifies that the P/Invoke marked with this attribute should be linked in as a WASM import.

Encapsulates an array and an offset within the specified array.

CLong is an immutable value type that represents the long type in C and C++. It is meant to be used as an exchange type at the managed/unmanaged boundary to accurately represent in managed code unmanaged APIs that use the long type. This type has 32-bits of storage on all Windows platforms and 32-bit Unix-based platforms. It has 64-bits of storage on 64-bit Unix platforms.

An application binary interface for function dispatch of a COM interface.

Interface type and pointer to targeted VTable.

CULong is an immutable value type that represents the unsigned long type in C and C++. It is meant to be used as an exchange type at the managed/unmanaged boundary to accurately represent in managed code unmanaged APIs that use the unsigned long type. This type has 32-bits of storage on all Windows platforms and 32-bit Unix-based platforms. It has 64-bits of storage on 64-bit Unix platforms.

Provides a way to access a managed object from unmanaged memory.

Represents a strongly typed GC handle to a managed object.

Wraps a managed object holding a handle to a resource that is passed to unmanaged code using platform invoke.

NFloat is an immutable value type that represents a floating type that has the same size as the native integer size. It is meant to be used as an exchange type at the managed/unmanaged boundary to accurately represent in managed code unmanaged APIs that use a type alias for C or C++'s float on 32-bit platforms or double on 64-bit platforms, such as the CGFloat type in libraries provided by Apple.

Represents an operating system platform.

Represents a strongly typed GC handle to a managed object.

Represents a strongly typed GC handle to a managed object.

Provides a way for clients to access the actual object, rather than the adapter object handed out by a custom marshaler.

Enables users to write activation code for managed objects that extend MarshalByRefObject.

Provides custom wrappers for handling method calls.

Enables developers to provide a custom, managed implementation of the IUnknown::QueryInterface(REFIID riid, void **ppvObject) method.

Interface used to participate in a type cast failure.

Use ITypeLib instead.

Indicates the processor architecture.

Specifies the calling convention required to call methods implemented in unmanaged code.

Dictates which character set marshaled strings should use.

Identifies the type of class interface that is generated for a class.

Identifies how to expose an interface to COM.

Describes the type of a COM member.

Specifies flags for the GetOrCreateComInterfaceForObject(Object, CreateComInterfaceFlags) method.

Specifies flags for CreateObject(IntPtr, CreateObjectFlags, Object, CreatedWrapperFlags).

Specifies flags for the GetOrCreateObjectForComInstance(IntPtr, CreateObjectFlags) method.

Indicates whether the GetComInterfaceForObject(Object, Type, CustomQueryInterfaceMode) method's IUnknown::QueryInterface calls can use the ICustomQueryInterface interface.

Provides return values for the GetInterface(Guid, IntPtr) method.

Specifies the paths that are used to search for DLLs that provide functions for platform invokes.

Represents the types of handles the GCHandle type can allocate.

Controls the layout of an object when exported to unmanaged code.

Specifies a POSIX signal number.

Specifies how strings should be marshalled for generated p/invokes

Describes the original settings of the FUNCFLAGS in the COM type library from where this method was imported.

Describes the original settings of the TYPEFLAGS in the COM type library from which the type was imported.

Describes the original settings of the VARFLAGS in the COM type library from which the variable was imported.

Identifies how to marshal parameters or fields to unmanaged code.

Indicates how to marshal the array elements when an array is marshaled from managed to unmanaged code as a SafeArray.

Provides a delegate used to resolve native libraries via callback.