BeatyBit.Binstate

Indicates that the marked symbol is used implicitly (e.g. via reflection, in external library), so this symbol will be ignored by usage-checking inspections.
You can use and to configure how this attribute is applied.


             [UsedImplicitly]
             public class TypeConverter {}
            
             public class SummaryData
             {
             [UsedImplicitly(ImplicitUseKindFlags.InstantiatedWithFixedConstructorSignature)]
             public SummaryData() {}
             }
            
             [UsedImplicitly(ImplicitUseTargetFlags.WithInheritors | ImplicitUseTargetFlags.Default)]
             public interface IService {}

Can be applied to attributes, type parameters, and parameters of a type assignable from . When applied to an attribute, the decorated attribute behaves the same as . When applied to a type parameter or to a parameter of type , indicates that the corresponding type is used implicitly.

Specifies the details of implicitly used symbol when it is marked with or .

Only entity marked with attribute considered used.

Indicates implicit assignment to a member.

Indicates implicit instantiation of a type with fixed constructor signature. That means any unused constructor parameters won't be reported as such.

Indicates implicit instantiation of a type.

Specifies what is considered to be used implicitly when marked with or .

Members of the type marked with the attribute are considered used.

Inherited entities are considered used.

Entity marked with the attribute and all its members considered used.

This attribute is intended to mark publicly available API, which should not be removed and so is treated as used.

Tells the code analysis engine if the parameter is completely handled when the invoked method is on stack. If the parameter is a delegate, indicates that delegate is executed while the method is executed. If the parameter is an enumerable, indicates that it is enumerated while the method is executed.

Indicates that the marked method builds string by the format pattern and (optional) arguments. The parameter, which contains the format string, should be given in the constructor. The format string should be in -like form.


             [StringFormatMethod("message")]
             void ShowError(string message, params object[] args) { /* do something */ }
            
             void Foo() {
             ShowError("Failed: {0}"); // Warning: Non-existing argument in format string
             }

Specifies which parameter of an annotated method should be treated as the format string

Indicates that the marked parameter is a message template where placeholders are to be replaced by the following arguments in the order in which they appear


             void LogInfo([StructuredMessageTemplate]string message, params object[] args) { /* do something */ }
            
             void Foo() {
             LogInfo("User created: {username}"); // Warning: Non-existing argument in format string
             }

Possible modes of transferring arguments during state transition from the currently active states to the newly activated. When transition is performed the state machine looks up for a required argument in the following order: * Not fallback argument passed to the (or overload) method * Active state and all its parents * Fallback argument passed to the (or overload) method

default value is invalid

All actions performed on 'enter', 'exit', and/or 'transition' of a state involved in child/parent relation should have parameter of the same type in the declared method used as the action. Also, it's possible that some states require an argument but some not.

Each state can have its own argument type. If an argument type of the currently active state is all newly activated actions require arguments of type , TX, and TY will receive corresponding argument. If a newly activated state requires an argument of type it is mixed from the arguments, see for details.

This class is used to configure and build a state machine.

Objects of this type are used as dictionary keys, it's your responsibility to provide valid type and objects. Objects of this type are used as dictionary keys, it's your responsibility to provide valid type and objects.

This class provides syntax-sugar to configure the state machine.

This interface allows you to specify an action that will be called upon entering the state currently being configured.

Specifies a synchronous (blocking) action to be executed upon entering the state.

The synchronous action to execute. An instance for configuring the exit action. Thrown when is null. Thrown when is an 'async void' method.

Specifies a synchronous (blocking) action with access to the state controller, to be executed upon entering the state. This overload provides the ability to perform auto transitions or waiting till the state be exited through .

The synchronous action with access to the state controller. An instance for configuring the exit action. Thrown when is null. Thrown when is an 'async void' method.

Specifies an asynchronous (non-blocking) action to be executed upon entering the state.

The asynchronous action returning a . An instance for configuring the exit action. Thrown when is null. Do not use 'async void' methods; they must return a .

Specifies an asynchronous (non-blocking) action with access to the state controller, to be executed upon entering the state. This overload provides the ability to perform auto transitions or waiting till the state be exited through .

The asynchronous action with access to the state controller, returning a . An instance for configuring the exit action. Thrown when is null. Do not use 'async void' methods; they must return a .

Specifies a synchronous (blocking) action with an argument, to be executed upon entering the state.

The type of the argument. The synchronous action with an argument. An instance for configuring the exit action. Thrown when is null. Thrown when is an 'async void' method. Refer to for argument usage details.

Specifies a synchronous (blocking) action with an argument and access to the state controller, to be executed upon entering the state. This overload provides the ability to perform auto transitions or waiting till the state be exited through .

The type of the argument. The synchronous action with an argument and access to the state controller. An instance for configuring the exit action. Thrown when is null. Thrown when is an 'async void' method. Refer to for argument usage details.

Specifies an asynchronous (non-blocking) action with an argument, to be executed upon entering the state.

The type of the argument. The asynchronous action with an argument, returning a . An instance for configuring the exit action. Thrown when is null. Do not use 'async void' methods; they must return a . Refer to for argument usage details.

Specifies an asynchronous (non-blocking) action with an argument and access to the state controller, to be executed upon entering the state. This overload provides the ability to perform auto transitions or waiting till the state be exited through .

The type of the argument. The asynchronous action with an argument and access to the state controller, returning a . An instance for configuring the exit action. Thrown when is null. Do not use 'async void' methods; they must return a . Refer to for argument usage details. Read about arguments in method documentation. Read about arguments in method documentation. Read about arguments in method documentation. Read about arguments in method documentation.

This interface allows you to specify an action that will be called upon exiting the state currently being configured.

Specifies an action to be executed upon exiting the state.

The action to execute. An instance for configuring possible transitions. Thrown when is null.

Specifies an action with an argument to be executed upon exiting the state.

The type of the argument. The action to execute. An instance for configuring possible transitions. Thrown when is null. Refer to for argument usage details.

This interface is used to configure which transitions allowed from the currently configured state.

Defines a transition from the currently configured state to the state specified by when the is raised. Optionally, specify an action to be executed upon the transition before 'exit' action.

The event that triggers the transition. The ID of the state to transition to. An optional action to be executed upon the transition. The instance for chaining configuration. Thrown when or is null.

Defines a dynamic transition from the currently configured state to the state returned by when the is raised. If returns null, the transition is cancelled.

Use this overload if you use a ValueType (e.g. enum) as a and the default value of the value type as a valid State id. Otherwise, consider using method as more simple. The event that triggers the transition. A delegate that returns the ID of the state to transition to, or null to cancel the transition. The instance for chaining configuration. Thrown when or is null.

Defines a dynamic transition from the currently configured state to the state returned by when the is raised. If returns null, the transition is cancelled.

Use this overload if you use a reference type (class) as a or the default value of the value type doesn't represent a valid State id. If you use a value type (e.g. enum) as a and the default value of the value type is a valid State id you must use method. The event that triggers the transition. A delegate that returns the ID of the state to transition to, or null to cancel the transition. The instance for chaining configuration. Thrown when or is null.

Defines a re-entrant transition from the current state to itself when the is raised. In such transition, no actions are executed. Use and specify "its own" State ID as a target state to create reentrancy transition which calls 'enter', 'exit', and 'transition' actions if any.

The event that triggers the re-entrant transition. Thrown when is null.

Defines a transition from the currently configured state to the state specified by when the is raised. Specifies an action with an argument of type to be executed upon the transition before the 'exit' action.

The type of the argument passed to the action. The event that triggers the transition. The ID of the state to transition to. The action to be executed upon the transition, accepting an argument of type . The instance for chaining configuration. Thrown when , , or is null.

This interface is used to configure which transitions allowed from the currently configured state.

This interface allows you to define composite states, allowing a state to be designated as a substate of another.

Designates the currently configured state as a substate of the specified parent state.

The ID of the parent state. An instance for further configuration. Thrown when is null.

Creates a builder of a state machine, use it to define state and configure transitions.

All exception thrown from 'enter', 'exit', and 'transition' actions passed to the state machine are caught in order not break the state of the state machine. Use this action to be notified about these exceptions. Configuration options for the state machine builder.

Defines the new state in the state machine, if it is already defined throws an exception.

ID of the state; is used to reference it from other elements of the state machine. Use returned syntax-sugar object to configure the new state.

Defines the new state in the state machine, if it is already defined, returns the configurator.

ID of the state; is used to reference it from other elements of the state machine. Use returned syntax-sugar object to configure the new state.

Validates consistency and builds the state machine using provided configuration.

The initial state of the state machine. Throws if there are any inconsistencies in the provided configuration.

Validates consistency and builds the state machine using provided configuration.

The initial state of the state machine. If initial state requires argument use this overload to pass it Throws if there are any inconsistencies in the provided configuration.

Restores a state machine instance from serialized data.

A JSON string representing the previously saved state machine's state. See . An optional serializer used for state argument restoration. If not primitive or string type is used as or an argument passed to custom serializer should be provided. A restored instance of the state machine configured with the states and active state from the provided serialized data.

Creates and initializes the states of the state machine using the configuration data provided in the builder. This method also validates the state transitions and ensures that the argument transfer rules are consistent.

Returns a dictionary containing the states of the state machine, where the key is the state ID and the value is the corresponding state object.

Validates that transitions don't reference not-defined states.

Create a unique signature for this instance based on _options and _stateConfigurators.

The accumulates all data about a state machine's state in this class during configuration and then uses it to create an implementation of for use in .

There are two types of the state in the system with and w/o Argument. To make a code type safe and avoid boxing of value type arguments, the class has TArgument generic argument. What type will be used depends on the state 'enter', 'exit', and 'transition' actions configuration and becomes known during calling method. If no arguments required the type is used as a TArgument, and it is treated by the implementation as "no argument required".

Just the base type for the to simplify the syntax of instantiating

Configuration options for the state machine builder.

Specifies whether the 'default' value can be used as a valid State ID when the type represented by TState is a , such as . This is necessary if, for some reason, you have to use a type as TState that you did not create and cannot modify. In all other cases, it is recommended to disallow the use of the default value as a valid value to prevent errors.

The mode of transferring arguments to the newly activated states. See for details.

Specifies whether the state machine supports persistence. When enabled, the state machine can be persisted and restored. To serialize the state machine in the current state call .

A delegate to be used with . This delegate allows using the 'default' value of in case it's used as as a valid state.

The state to which transition should be performed. Returns false if no transition should be performed.

This interface is used in 'enter' actions to control execution and to perform 'auto transitions'

Gets a value indicating whether the state machine is currently in the state for which the executing 'enter' action is defined.

Asynchronously raises an event to trigger a state transition.

The event to raise. Synchronously returns true if a transition is performed; otherwise, false if no transition was found. Thrown if the 'enter' action of the target state requires an argument. User-defined exceptions from 'enter', 'exit', and 'dynamic transition' actions are caught and reported using the delegate passed to .

Asynchronously raises an event with an argument to trigger a state transition.

The type of the argument. The event to raise. The argument to pass with the event. Indicates whether this argument is used only as a fallback; if a state-specific argument is available, it will be used instead. Synchronously returns true if a transition is performed; otherwise, false if no transition was found. Thrown if the 'enter' action of the target state requires an argument. User-defined exceptions from 'enter', 'exit', and 'dynamic transition' actions are caught and reported using the delegate passed to . The argument is required if the 'enter' action of the target state or 'exit' action of the current state is configured to accept it. See .

Defines the interface for a state machine, providing methods to raise events and manage state transitions.

Raises an event synchronously, blocking until all related actions are completed.

Waits for the completion of 'exit' and 'enter' actions (if defined) of the current state. If the 'enter' action of the target state is synchronous, it blocks until the action completes. If the 'enter' action of the target state is asynchronous, it returns immediately after the state change. The event to raise. true if the state was changed; otherwise, false. Thrown if the 'enter' action of the target state requires an argument. User-defined exceptions from 'enter', 'exit', and 'dynamic transition' actions are caught and reported using the delegate passed to .

Raises an event with an argument synchronously, blocking until all related actions are completed.

The type of the argument. Waits for the completion of 'exit' and 'enter' actions (if defined) of the current state. If the 'enter' action of the target state is synchronous, it blocks until the action completes. If the 'enter' action of the target state is asynchronous, it returns immediately after the state change. The event to raise. The argument to pass with the event. Indicates whether this argument is used only as a fallback; if a state-specific argument is available, it will be used instead. true if the state was changed; otherwise, false. Thrown if the 'enter' action of the target state does not require an argument or requires an argument of an incompatible type. User-defined exceptions from 'enter', 'exit', and 'dynamic transition' actions are caught and reported using the delegate passed to .

Raises an event asynchronously, allowing control of completion through the returned .

Waits for the completion of 'exit' and 'enter' actions (if defined) of the current state. If the 'enter' action of the target state is synchronous, the completes when the action completes. If the 'enter' action of the target state is asynchronous, the completes immediately after the state change. The event to raise. A that completes with true if a transition was found; otherwise, false. Thrown if the 'enter' action of the target state requires an argument. User-defined exceptions from 'enter', 'exit', and 'dynamic transition' actions are caught and reported using the delegate passed to .

Raises an event with an argument asynchronously, allowing control of completion through the returned .

The type of the argument. Waits for the completion of 'exit' and 'enter' actions (if defined) of the current state. If the 'enter' action of the target state is synchronous, the completes when the action completes. If the 'enter' action of the target state is asynchronous, the completes immediately after the state change. The event to raise. The argument to pass with the event. Indicates whether this argument is used only as a fallback; if a state-specific argument is available, it will be used instead. A that completes with true if a transition was found; otherwise, false. Thrown if the 'enter' action of the target state does not require an argument or requires an argument of an incompatible type. User-defined exceptions from 'enter', 'exit', and 'dynamic transition' actions are caught and reported using the delegate passed to .

Serializes the StateMachine in its current state to string representation. It can be restored using method.

If not primitive or string type is used as TState in or an argument passed to custom serializer should be provided.

This data structure is used if a state needs to accept two arguments at once, usually one is passed to method and the second one is obtained from the previously active states during transition automatically. But they could be both from the active states. Interface is used to make argument types invariant to pass arguments of compatible types.

Equals doesn't check the exact type of the other object, only if it can be cast to

Defines serialization and deserialization methods for custom data handling.

Serializes the specified value into its string representation.

The type of the value to be serialized. The value to serialize.

Deserializes the specified string into an object instance.

An object instance created from the serialized string.

Provides functionality for persisting and restoring the state of a state machine. Contains nested classes for handling state data and serialization.

Provides serialization and deserialization methods specifically for types. This class is designed to handle the persistence of enum instances by converting them into a serializable format and vice versa.

Gets the singleton instance of the class.

Serializes an enumeration value into a representation.

The type of the enum to serialize. Must be an enum type; otherwise, an exception is thrown. The enumeration value to serialize. A serialized that represents the enum value. Thrown when is null. Thrown when is not an enum type.

Deserializes a back into the corresponding enumeration value.

The to deserialize. The deserialized enumeration value. Thrown when is null. Thrown when the does not represent an enum type.

Represents a serializable item with type information and value. Used to persist state machine state or arguments.

String description of the type.

Serialized value.

This class contains tools and logic for setting arguments to their consumers.

Validation of the argument and target type should be performed on the caller side

This property is set from protected by lock part of the code so it's no need synchronization see implementation for details.

can be called earlier then of the activated state, see implementation for details. In this case it should wait till be called and exited, before call exit action

This event is used to wait while state's 'enter' action is finished before call 'exit' action and change the active state of the state machine. See usages for details.

This event is used to avoid race condition when method is called before method. See usages for details.

This task is used to wait while state's 'enter' action is finished before call 'exit' action and change the active state of the state machine in case of async OnEnter action. See usages for details.

can be called earlier then of the activated state, see implementation for details. In this case it should wait till will be called and exited, before call exit action

The state machine implementation. Use to configure and build a state machine.

The map of all defined states

This is implemented as a separate method rather than constructor logic to be able specifying generic argument . While the is set in constructor to use not nullable type for it.

Argument for the initial state

Performing transition is split into two parts, the first one is "readonly", preparing and checking all the data, can throw an exception.

Returns null if: no transition found by specified from the current state dynamic transition returns 'null' Throws if passed argument doesn't match the 'enter' action of the target state.

Performs changes in the state machine state. Doesn't throw any exceptions, exceptions from the user code, 'enter' and 'exit' actions are translated into the delegate passed to

Doesn't acquire lock itself, caller should care about safe context

Returns an action which should be called to call 'enter' action of the state

See usage for details

Returns transition to the no matter what is passed

Means a transition targets the predefined state in opposite to the calculated dynamical runtime