Sandbox.Hotload

Provides methods for replacing loaded assemblies with new versions at runtime.

Attempts to get the default value for a newly created field on an existing type. Returns true if successful.

This value should not be cached, but evaluated for each instance. Works by finding the CIL that initializes the given field and generating a dynamic method, which is then cached and invoked. Field to retrieve a default value for. If successful, contains the default value.

Stack size delta for each stack behaviour.

Find the number of arguments that invoking the given method will pop.

Anonymous types are generic types with a type parameter for each property's type. That means the compiler will reuse the same type definition as long as property names match.

Generic type definition for the anonymous type. Names of the anonymous type's properties.

Anonymous types are generic types with a type parameter for each property's type. That means the compiler will reuse the same type definition as long as property names match.

Generic type definition for the anonymous type. Names of the anonymous type's properties.

Generic type definition for the anonymous type.

Names of the anonymous type's properties.

Anonymous types are equivalent as long as the property names match.

Pattern:
^<(?<name>[^>]+)>j__TPar$
Explanation:


            ○ Match if at the beginning of the string.

            ○ Match '<'.

            ○ "name" capture group.

                ○ Match a character other than '>' atomically at least once.

            ○ Match the string ">j__TPar".

            ○ Match if at the end of the string or if before an ending newline.

If is an anonymous type, gets a description of its properties. Otherwise, returns null.

Find an anonymous type in a hotloaded assembly with matching property names, or null if not found.

A mapping of assembles to swap with new versions.

Assemblies that are being loaded in this hotload, either as a swap or replacing null.

A list of assemblies containing members that should be skipped during a reference update.

If true, the static field or watched object that instances are found under will be stored in . Defaults to false.

If true, keep track of the path to instances to include in logging. Defaults to false.

If true, record per-type timing information.

If true, record instance processor timing information.

Optional resolver required for features like setting default values of newly-added fields.

Optional formatter when pretty-printing assembly names in logs.

Default constructor that includes Sandbox.Hotload.dll and Mono.Cecil.dll to the ignored assembly list.

Any fields declared on types defined in the given assembly will be skipped during future reference updates.

Assembly to ignore the members of.

Any fields declared on types defined in the given assembly will be skipped during future reference updates.

Any fields declared on types defined in the named assembly will be skipped during future reference updates.

To be called when one assembly is being replaced by another, is loaded for the first time, or unloaded for the last time. This will add to be watched (if not null), and remove from being watched (if not null). If both assemblies aren't null, they will be added to be swapped when is next called, and true is returned.

Returns the queue of assemblies that will be swapped when is called. These are added using the method.

The mapping of assembly replacements.

Interface to implement a custom object instance upgrade process for types that match a condition. Instances of any derived types will be created and added to a instance that uses on the declaring assembly of the derived type, unless a has been specified. You can configure which order s are queried by using , and / or .

A mapping of assembles to swap with new versions.

When hotswapping this will switch types from the old assembly into the type from the new assembly.

The old type. The new type, or null if no substitution exists. The old type will be returned if it's still valid (not from a swapped assembly).

Returns an upgraded version of the given object, replacing any types from a swapped-out assembly with their new up-to-date types. The result is cached, so if you pass the same object to this method multiple times it will always return the same instance. Fields inside the new instance may not be initialized until later in the hotload.

Object to upgrade. An upgraded version of the given object.

Logs a message in the current hotload.

Logs an exception in the current hotload.

Called when this upgrader has been added to a instance.

Called between hotloads, should clear up any cached resources that won't be needed in future hotloads.

Check to see if this upgrader can possibly handle the given type.

Type to upgrade an instance of. True if this upgrader should attempt to upgrade an instance of the given type.

If this upgrader supports upgrading the given , returns true and assigns to be the value that should replace . This method doesn't need to copy the inner state of the instance across, but just creates an empty instance to be populated later.

It's safe to just directly assign to if the type isn't declared in a replaced assembly. Returning true will cause to be called immediately after this method, which schedules copying the state of the old instance to the new one. Instance that should be replaced / upgraded. If this method returns true, this should contain the instance that replaces , or itself if no replacement is necessary. True if this upgrader handles the replacement of the given .

Called immediately after if it returned true, or on instances from fields that can't be re-assigned (see ). This method determines what kind of extra processing is required for the given replacement.

In this method we can call things like , or to handle copying values from the old instance to the new one. If should be cached as the canonical replacement for , call here. If finalization should be suppressed, call . Original instance that is being replaced / upgraded from. New instance that replaces , or itself if no replacement is necessary. True if was created outside of the hotloading system, for example when the containing field has set to true. Otherwise, when false, will have been called just before this method.

Perform extra field processing on a new instance that has previously been created by this upgrader in . This is a good place to discover any other instances that should be upgraded that are stored in , which can be upgraded by calling .

The original instance that was upgraded. Upgraded version of , or even the same object if no upgrade was required. Roughly how many instances were processed by this method. Only used for performance stats.

Merge chains of swaps. For example, if A is swapped with B, and B is swapped with C, simplify to A swapping with C.

Cycle though all types in all watched assemblies. Find statics, iterate over all their fields recursively. Replace any instances of classes that are defined in the assemblies added using ReplacingAssembly

Make sure a candidate type substitution isn't at all defined in a swapped-out assembly. This can go wrong if assembly B references assembly A, but only assembly A was swapped.

In a swapped assembly find a replacement type for this type. Return null if no replacement is found.

Currently watched assemblies, to enumerate the static fields of. This will contain assemblies added with , along with (after a hotload) the most recent replacing assemblies passed to .

Currently watched object instances. Use to add to this set.

Look for instances to replace in the static fields of types defined in the given assembly.

Assembly to watch the static fields of. Only test static fields in types that pass this filter.

Look for instances to replace in the static fields of types defined in the defining assembly of .

Type defined in the assembly to watch the static fields of.

Look for instances to replace in the static fields of types defined in the given assembly.

Name of the assembly to watch the static fields of. Only test static fields in types that pass this filter.

Stop watching static fields of types defined in the given assembly.

Assembly to stop watching the static fields of.

Look for instances to replace in the fields of the given object.

Object to watch the fields of.

Stop looking for instances to replace in the fields of the given object.

Object to stop watching the fields of.

See Microsoft.CodeAnalysis.CSharp.Symbols.GeneratedNameKind

See Microsoft.CodeAnalysis.CSharp.Symbols.GeneratedNames.MakeMethodScopedSynthesizedName

Used to categorize messages emitted when performing a hotload.

Used for messages related to debugging or profiling.

Used for general messages.

Hotload couldn't upgrade an instance, so you should reload the game to avoid runtime bugs.

Something went wrong during the hotload that Facepunch should fix.

Contains information for an individual hotload result message or error.

Hotload result category.

Contains the main information of the result.

If the result type is , contains the exception thrown.

When relevant, contains the member that this result relates to.

Returns a string that represents the current object.

A string that represents the current object.

Total number of instances processed.

Total time taken processing instances.

Holds information about the number of instances and total time taken when processing instances in a certain category.

The full names and instance count for each static field that instances were found under. Only populated if is set to true.

Contains information about an assembly hotload event, including any warnings or errors emitted, the time taken to process instances of different types, and the total number of instances processed.

Contains timing information for each type processed during the hotload.

Contains timing information for each IInstanceProcessor during the hotload.

If true, at least one error was emitted during the hotload. Information about the error(s) can be found in .

If true, at least one warning was emitted during the hotload. Information about the error(s) can be found in .

If true, the hotload was skipped because no replacement assemblies were specified since the last hotload.

Total time elapsed during the hotload (in milliseconds)

If true, no errors were emitted during the hotload.

Total number of instances processed during the hotload.

Retrieves all warnings, errors and other messages emitted during the hotload.

Types that were automatically determined to be safely skippable.

Retrieves all error messages emitted during the hotload.

Retrieves all warning messages emitted during the hotload.

A fast path hotload that patches the existing assemblies IL when applicable

All active detours within an Assembly

Make sure we have an initialized detour factory, as it takes a small while to load

True if is supported on this platform.

Replace any references to types or members in with references in . Returns an array of referenced compiler-generated methods that should also be detoured.

Generate an ordering based on a set of first-most and last-most items, and individual constraints between pairs of items. All first-most items will be ordered before all last-most items, and any other items will be put in the middle unless forced to be elsewhere by a constraint.

True if a deep copy was required.

Determine if the size and field layout of a struct has changed. This should only return true if it is safe to bitwise copy from old instances of the struct to new instances. This will return true if the struct contains reference-type members.

Return true if type is to be thought of as a primitive ie - a type that never changes, and can just be copied such as a bool, string, float, pointer.

This field is initialized by a named method, for use when hotloading. If no method name is given, the field is deliberately left uninitialized.

This upgrader will use reflection to go through each field of a new instance, and populate it with an equivalent value found from the old instance. For newly-added fields, it attempts to determine a default value from the constructor of the type.

Get all fields on this type, and types it inherits from, that we should process.

For each type in 's hierarchy, try to find a matching type in 's hierarchy. If no match is found, yields (null, dstType). Ordered by most derived type first.

For each field in , try to find the matching field in . If no match is found, yields (null, dstField), so we can initialize the new field to a default value.

The lambda captures nothing local. Method is declared in a nested "<>c" class in the context's declaring type. Method is named like "<{ContextName:ident}>b__{ContextIndex:int}_{LambdaIndex:int}".

The lambda captures only an instance of the context's declaring type. Method is declared in the context's declaring type itself. Method is named like "<{ContextName:ident}>b__{ContextIndex:int}_{LambdaIndex:int}".

The lambda captures other local values from the context. Method is declared in a nested "<>__DisplayClass{ContextIndex:int}_{DisplayClassIndex:int}" class. Method is named like "<{ContextName:ident}>b__{LambdaIndex:int}".

Types that we can safely skip, that we can't add a to.

Instance upgrader that will try to automatically find types are definitely skippable. This upgrader isn't added automatically, you can enable it by calling .

We attempt this almost last (just before ) so that any upgraders that handle specific types will be chosen first, and therefore stop those types from being skipped. Adds any skippable types it finds to a cache, and forces to process them. This performs an under-approximation, but you can use to mark any types it misses that you know are safe to skip.

The set of types that have been determined to be safe to skip.

Custom handling for to reduce hotload processing time.

Base upgrader for implementations.

Base class for upgraders that process collections that store items with unique keys, like and .

Which collection type does this upgrader process?

Collection accessor to avoid reflection if there isn't already a non-generic interface.

Look for a property named Comparer in the given .

Look for a constructor in with exactly one parameter, with that parameter matching the type of the property found with .

Upgrader for so that we only process its live elements. Without this, hotload would process the whole inner array, even if the list was cleared.

System.Text.Json keeps a bunch of generated methods cached that we can't upgrade properly. Let's just clear the cache, and warn if the cache got populated again during the hotload.

Can't get the count of a , so returns .

Only use and to determine ordering within a .

Try to put this upgrader as close to the start of the given group as possible.

Try to put this upgrader as close to the end of the given group as possible.

Use this attribute to specify that a should attempt to process each object before all other specified types.

types that should attempt to process each object after the type this attribute is on.

Create an instance of with a list of types.

One or more types.

Use this attribute to specify that a should attempt to process each object after all other specified types.

types that should attempt to process each object before the type this attribute is on.

Create an instance of with a list of types.

One or more types.

Used to organize s into groups that update in a particular order. Use to specify which group an upgrader should be added to.

A list of s added to this group, where this group is their immediate parent.

Indices into , sorted by .

For each , caches which s should attempt to process instances of that type, as given by .

Should be sorted?

Works out which child group to add the given upgrader to, or whether to add it to this group.

Returns a flat array of upgraders that can process the given type, in order of precedence. This array won't contain s, but it will contain upgraders found within those groups.

Type to find upgraders for.

Custom -derived type for the AnonymousTypeParamNameRegex method.

Cached, thread-safe singleton instance.

Initializes the instance.

Provides a factory for creating instances to be used by methods on .

Creates an instance of a used by methods on .

Provides the runner that contains the custom logic implementing the specified regular expression.

Scan the starting from base.runtextstart for the next match.

The text being scanned by the regular expression.

Search starting from base.runtextpos for the next location a match could possibly start.

The text being scanned by the regular expression. true if a possible match was found; false if no more matches are possible.

Determine whether at base.runtextpos is a match for the regular expression.

The text being scanned by the regular expression. true if the regular expression matches at the current position; otherwise, false.

Helper methods used by generated -derived implementations.

Default timeout value set in , or if none was set.

Whether is non-infinite.