MonoMod.Backports

Indicates that certain members on a specified are accessed dynamically, for example through .

This allows tools to understand which members are being accessed during the execution of a program. This attribute is valid on members whose type is or . When this attribute is applied to a location of type , the assumption is that the string represents a fully qualified type name. When this attribute is applied to a class, interface, or struct, the members specified can be accessed dynamically on instances returned from calling on instances of that class, interface, or struct. If the attribute is applied to a method it's treated as a special case and it implies the attribute should be applied to the "this" parameter of the method. As such the attribute should only be used on instance methods of types assignable to System.Type (or string, but no methods will use it there).

Initializes a new instance of the class with the specified member types.

The types of members dynamically accessed.

Gets the which specifies the type of members dynamically accessed.

Specifies the types of members that are dynamically accessed. This enumeration has a attribute that allows a bitwise combination of its member values.

Specifies no members.

Specifies the default, parameterless public constructor.

Specifies all public constructors.

Specifies all non-public constructors.

Specifies all public methods.

Specifies all non-public methods.

Specifies all public fields.

Specifies all non-public fields.

Specifies all public nested types.

Specifies all non-public nested types.

Specifies all public properties.

Specifies all non-public properties.

Specifies all public events.

Specifies all non-public events.

Specifies all members.

Used to indicate a byref escapes and is not scoped.

There are several cases where the C# compiler treats a as implicitly - where the compiler does not allow the to escape the method. For example: for instance methods. parameters that refer to types. parameters. This attribute is used in those instances where the should be allowed to escape. Applying this attribute, in any form, has impact on consumers of the applicable API. It is necessary for API authors to understand the lifetime implications of applying this attribute and how it may impact their users.

Initializes a new instance of the class.

Reserved to be used by the compiler for tracking metadata. This class should not be used by developers in source code.

This definition is provided by the IsExternalInit NuGet package (https://www.nuget.org/packages/IsExternalInit). Please see https://github.com/manuelroemer/IsExternalInit for more information.

Provides a handler used by the language compiler to process interpolated strings into instances.

Expected average length of formatted data used for an individual interpolation expression result.

This is inherited from string.Format, and could be changed based on further data. string.Format actually uses `format.Length + args.Length * 8`, but format.Length includes the format items themselves, e.g. "{0}", and since it's rare to have double-digit numbers of items, we bump the 8 up to 11 to account for the three extra characters in "{d}", since the compiler-provided base length won't include the equivalent character count.

Minimum size array to rent from the pool.

Same as stack-allocation size used today by string.Format.

Optional provider to pass to IFormattable.ToString or ISpanFormattable.TryFormat calls.

Array rented from the array pool and used to back .

The span to write into.

Position at which to write the next character.

Whether provides an ICustomFormatter.

Custom formatters are very rare. We want to support them, but it's ok if we make them more expensive in order to make them as pay-for-play as possible. So, we avoid adding another reference type field to reduce the size of the handler and to reduce required zero'ing, by only storing whether the provider provides a formatter, rather than actually storing the formatter. This in turn means, if there is a formatter, we pay for the extra interface call on each AppendFormatted that needs it.

Creates a handler used to translate an interpolated string into a .

The number of constant characters outside of interpolation expressions in the interpolated string. The number of interpolation expressions in the interpolated string. This is intended to be called only by compiler-generated code. Arguments are not validated as they'd otherwise be for members intended to be used directly.

Creates a handler used to translate an interpolated string into a .

The number of constant characters outside of interpolation expressions in the interpolated string. The number of interpolation expressions in the interpolated string. An object that supplies culture-specific formatting information. This is intended to be called only by compiler-generated code. Arguments are not validated as they'd otherwise be for members intended to be used directly.

Creates a handler used to translate an interpolated string into a .

The number of constant characters outside of interpolation expressions in the interpolated string. The number of interpolation expressions in the interpolated string. An object that supplies culture-specific formatting information. A buffer temporarily transferred to the handler for use as part of its formatting. Contents may be overwritten. This is intended to be called only by compiler-generated code. Arguments are not validated as they'd otherwise be for members intended to be used directly.

Derives a default length with which to seed the handler.

The number of constant characters outside of interpolation expressions in the interpolated string. The number of interpolation expressions in the interpolated string.

Gets the built .

The built string.

Gets the built and clears the handler.

The built string. This releases any resources used by the handler. The method should be invoked only once and as the last thing performed on the handler. Subsequent use is erroneous, ill-defined, and may destabilize the process, as may using any other copies of the handler after ToStringAndClear is called on any one of them.

Clears the handler, returning any rented array to the pool.

Gets a span of the written characters thus far.

Writes the specified string to the handler.

The string to write.

Writes the specified string to the handler.

The string to write.

Writes the specified value to the handler.

The value to write. The type of the value to write.

Writes the specified value to the handler.

The value to write. The format string. The type of the value to write.

Writes the specified value to the handler.

The value to write. Minimum number of characters that should be written for this value. If the value is negative, it indicates left-aligned and the required minimum is the absolute value. The type of the value to write.

Writes the specified value to the handler.

The value to write. The format string. Minimum number of characters that should be written for this value. If the value is negative, it indicates left-aligned and the required minimum is the absolute value. The type of the value to write.

Writes the specified character span to the handler.

The span to write.

Writes the specified string of chars to the handler.

The span to write. Minimum number of characters that should be written for this value. If the value is negative, it indicates left-aligned and the required minimum is the absolute value. The format string.

Writes the specified value to the handler.

The value to write.

Writes the specified value to the handler.

The value to write. Slow path to handle a custom formatter, potentially null value, or a string that doesn't fit in the current buffer.

Writes the specified value to the handler.

Gets whether the provider provides a custom formatter.

Formats the value using the custom formatter from the provider.

The value to write. The format string. The type of the value to write.

Handles adding any padding required for aligning a formatted value in an interpolation expression.

The position at which the written value started. Non-zero minimum number of characters that should be written for this value. If the value is negative, it indicates left-aligned and the required minimum is the absolute value.

Ensures has the capacity to store beyond .

Fallback for fast path in when there's not enough space in the destination.

The string to write.

Fallback for for when not enough space exists in the current buffer.

The span to write.

Grows to have the capacity to store at least beyond .

Grows the size of .

Grow the size of to at least the specified .

Disables the built-in runtime managed/unmanaged marshalling subsystem for P/Invokes, Delegate types, and unmanaged function pointer invocations.

Note: This does nothing on runtimes older than .NET 7. It is provided entirely for forward compatibility. The built-in marshalling subsystem has some behaviors that cannot be changed due to backward-compatibility requirements. This attribute allows disabling the built-in subsystem and instead uses the following rules for P/Invokes, Delegates, and unmanaged function pointer invocations: - All value types that do not contain reference type fields recursively (unmanaged in C#) are blittable - Value types that recursively have any fields that have [StructLayout(LayoutKind.Auto)] are disallowed from interop. - All reference types are disallowed from usage in interop scenarios. - SetLastError support in P/Invokes is disabled. - varargs support is disabled. - LCIDConversionAttribute support is disabled.

Indicates the attributed type is to be used as an interpolated string handler.

Initializes the .

Indicates which arguments to a method involving an interpolated string handler should be passed to that handler.

Initializes a new instance of the class.

The name of the argument that should be passed to the handler. may be used as the name of the receiver in an instance method.

Initializes a new instance of the class.

The names of the arguments that should be passed to the handler. may be used as the name of the receiver in an instance method.

Gets the names of the arguments that should be passed to the handler.

may be used as the name of the receiver in an instance method.

This interface is required for types that want to be indexed into by dynamic patterns.

The number of positions in this data structure.

Get the element at position .

Used to indicate to the compiler that a method should be called in its containing module's initializer.

When one or more valid methods with this attribute are found in a compilation, the compiler will emit a module initializer which calls each of the attributed methods. Certain requirements are imposed on any method targeted with this attribute: - The method must be `static`. - The method must be an ordinary member method, as opposed to a property accessor, constructor, local function, etc. - The method must be parameterless. - The method must return `void`. - The method must not be generic or be contained in a generic type. - The method's effective accessibility must be `internal` or `public`. The specification for module initializers in the .NET runtime can be found here: https://github.com/dotnet/runtime/blob/main/docs/design/specs/Ecma-335-Augments.md#module-initializer

Extensions to providing consistent access to APIs introduced after the type.

Returns approximate reciprocal of the divisor: ceil(2**64 / divisor).

This should only be used on 64-bit.

Performs a mod operation using the multiplier pre-computed with .

This should only be used on 64-bit.

Schedules a callback roughly every gen 2 GC (you may see a Gen 0 an Gen 1 but only once) (We can fix this by capturing the Gen 2 count at startup and testing, but I mostly don't care)

Schedule 'callback' to be called in the next GC. If the callback returns true it is rescheduled for the next Gen 2 GC. Otherwise the callbacks stop.

Schedule 'callback' to be called in the next GC. If the callback returns true it is rescheduled for the next Gen 2 GC. Otherwise the callbacks stop. NOTE: This callback will be kept alive until either the callback function returns false, or the target object dies.

Extensions to providing consistent access to APIs introduced after the type.

Returns clamped to the inclusive range of and .