0Harmony

A factory to create delegate types

Default constructor

Creates a delegate type for a method

The method The new delegate type

A getter delegate type

Type that getter gets field/property value from Type of the value that getter gets The instance get getter uses An delegate

A setter delegate type

Type that setter sets field/property value for Type of the value that setter sets The instance the setter uses The value the setter uses An delegate

A constructor delegate type

Type that constructor creates An delegate

A helper class for fast access to getters and setters

Creates an instantiation delegate

Type that constructor creates The new instantiation delegate

Creates an getter delegate for a property

Type that getter reads property from Type of the property that gets accessed The property The new getter delegate

Creates an getter delegate for a field

Type that getter reads field from Type of the field that gets accessed The field The new getter delegate

Creates an getter delegate for a field (with a list of possible field names)

Type that getter reads field/property from Type of the field/property that gets accessed A list of possible field names The new getter delegate

Creates an setter delegate

Type that setter assigns property value to Type of the property that gets assigned The property The new setter delegate

Creates an setter delegate for a field

Type that setter assigns field value to Type of the field that gets assigned The field The new getter delegate

A delegate to invoke a method

The instance The method parameters The method result

A helper class to invoke method with delegates

Creates a fast invocation handler from a method

The method to invoke Controls if boxed value object is accessed/updated directly The The directBoxValueAccess option controls how value types passed by reference (e.g. ref int, out my_struct) are handled in the arguments array passed to the fast invocation handler. Since the arguments array is an object array, any value types contained within it are actually references to a boxed value object. Like any other object, there can be other references to such boxed value objects, other than the reference within the arguments array. For example,


            var val = 5;
            var box = (object)val;
            var arr = new object[] { box };
            handler(arr); // for a method with parameter signature: ref/out/in int

If directBoxValueAccess is true, the boxed value object is accessed (and potentially updated) directly when the handler is called, such that all references to the boxed object reflect the potentially updated value. In the above example, if the method associated with the handler updates the passed (boxed) value to 10, both box and arr[0] now reflect the value 10. Note that the original val is not updated, since boxing always copies the value into the new boxed value object. If directBoxValueAccess is false (default), the boxed value object in the arguments array is replaced with a "reboxed" value object, such that potential updates to the value are reflected only in the arguments array. In the above example, if the method associated with the handler updates the passed (boxed) value to 10, only arr[0] now reflects the value 10.

A low level memory helper

Mark method for no inlining (currently only works on Mono)

The method/constructor to change

Detours a method

The original method/constructor The replacement method/constructor An error string

Writes a jump to memory

The memory address Jump destination An error string

Gets the start of a method in memory

The method/constructor [out] Details of the exception The method start address special parameter names that can be used in prefix and postfix methods

Patch function helpers

Adds a prefix

The patch info The owner (Harmony ID) The annotation info

Removes a prefix

The patch info The owner (Harmony ID)

Adds a postfix

The patch info The owner (Harmony ID) The annotation info

Removes a postfix

The patch info The owner (Harmony ID)

Adds a transpiler

The patch info The owner (Harmony ID) The annotation info

Removes a transpiler

The patch info The owner (Harmony ID)

Adds a finalizer

The patch info The owner (Harmony ID) The annotation info

Removes a finalizer

The patch info The owner (Harmony ID)

Removes a patch method

The patch info The patch method

Gets sorted patch methods

The original method Patches to sort Use debug mode The sorted patch methods

Creates new replacement method with the latest patches and detours the original method

The original method Information describing the patches The newly created replacement method

Creates a patch sorter

Array of patches that will be sorted Use debugging

Sorts internal PatchSortingWrapper collection and caches the results. After first run the result is provided from the cache.

The original method The sorted patch methods

Checks if the sorter was created with the same patch list and as a result can be reused to get the sorted order of the patches.

List of patches to check against true if equal

Removes one unresolved dependency from the least important patch.

Outputs all unblocked patches from the waiting list to results list

Adds patch to both results list and handled patches set

Patch to add

Wrapper used over the Patch object to allow faster dependency access and dependency removal in case of cyclic dependencies

Create patch wrapper object used for sorting

Patch to wrap

Determines how patches sort

The other patch integer to define sort order (-1, 0, 1)

Determines whether patches are equal

The other patch true if equal

Hash function

A hash code

Bidirectionally registers Patches as after dependencies

List of dependencies to register

Bidirectionally registers Patches as before dependencies

List of dependencies to register

Bidirectionally removes Patch from after dependencies

Patch to remove

Bidirectionally removes Patch from before dependencies

Patch to remove

Specifies the type of method

This is a normal method

This is a getter

This is a setter

This is a constructor

This is a static constructor

Specifies the type of argument

This is a normal argument

This is a reference argument (ref)

This is an out argument (out)

This is a pointer argument (&)

Specifies the type of patch

Any patch

A prefix patch

A postfix patch

A transpiler

A finalizer

A reverse patch

Specifies the type of reverse patch

Use the unmodified original method (directly from IL)

Use the original as it is right now including previous patches but excluding future ones

The base class for all Harmony annotations (not meant to be used directly)

The common information for all attributes

Annotation to define your Harmony patch methods

An empty annotation can be used together with TargetMethod(s)

An annotation that specifies a class to patch

The declaring class/type