0Harmony

A factory to create delegate types

Instance for the delegate type factory

Exists for API compatibility with Harmony

Creates a delegate type for a method

Type of the return value Types of the arguments The new delegate type for the given type info

Creates a delegate type for a method

Type of the return value Types of the arguments Calling convention. If specified, adds to the delegate type The new delegate type for the given type info

Creates a delegate type for a method

The method The new delegate type

Creates a delegate type for a method

The method Calling convention. If specified, adds to the delegate type. 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.

Patch function helpers

Sorts patch methods by their priority rules

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

Sorts patch methods by their priority rules

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

High-level IL code manipulator for MonoMod that allows to manipulate a method as a stream of CodeInstructions.

Initialize IL transpiler

Body of the method to transpile Whether to always log everything for this instance

Adds a transpiler method that edits the IL of the given method

Transpiler method Currently not implemented

Processes and writes IL to the provided method body. Note that this cleans the existing method body (removes insturctions and exception handlers).

Method body to write to. Original method that transpiler can optionally call into One of IL opcodes contains a CallSide (e.g. calli), which is currently not fully supported. One of IL opcodes with an operand contains a null operand.

Converts all branches to long types. This exists to mimic the behaviour of Harmony 2

Enumerable of instructions Enumerable of fixed instructions

Helper wrapper around ILProcessor to allow emitting code at certain positions

Write method body to a ILDasm -like representation

Method body to write String representation of the method body (locals and instruction) Unexpected exception block type

Patching methods potentially messes up the stack. Especially calls to GetExecutingAssembly won't turn in correct methods

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

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 as instance

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

A MonoMod

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

Specifies the type of method call dispatching mechanics

Call the method using dynamic dispatching if method is virtual (including overriden)

This is the built-in form of late binding (a.k.a. dynamic binding) and is the default dispatching mechanic in C#. This directly corresponds with the instruction. For virtual (including overriden) methods, the instance type's most-derived/overriden implementation of the method is called. For non-virtual (including static) methods, same behavior as : the exact specified method implementation is called. Note: This is not a fully dynamic dispatch, since non-virtual (including static) methods are still called non-virtually. A fully dynamic dispatch in C# involves using the dynamic type (actually a fully dynamic binding, since even the name and overload resolution happens at runtime), which does not support.

Call the method using static dispatching, regardless of whether method is virtual (including overriden) or non-virtual (including static)

a.k.a. non-virtual dispatching, early binding, or static binding. This directly corresponds with the instruction. For both virtual (including overriden) and non-virtual (including static) methods, the exact specified method implementation is called, without virtual/override mechanics.

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