BeatyBit.Armature

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.

Base class for build actions building arguments to inject.

Base class for build actions building arguments to inject into inject points marked with .

Base class for build actions build a list of arguments by using method.

Caches passed object and set it as in .

The simplest eternal singleton. Caches just built Unit in and then set it as in .

Gets the constructor of the type which is marked with the optional ..

Gets the constructor of the type matches specified parameter types list.

Gets the constructor of the type with the largest number of parameters.

Instantiates an object using reflection. See method.

Creates a Unit using specified factory method.

Builds an argument for the constructor/method parameter which is marked with using and as /// as .

Builds an argument for the constructor/method parameter using and specified tag as .

Builds a list of arguments by using method for a constructor/method parameters.

Builds arguments for constructor/method parameters one by one in the direct order.

Gets a default parameter value of the constructor/method parameter.

Builds an argument for the property which is marked with using and as .

Builds an argument for the property using and specified tag as an .

Builds an argument for the property using and specified tag as .

Builds a list of arguments by using method for a property.

Gets a property by specified type.

Gets a list of properties with specified names.

Gets a list of properties marked with with specified tags ..

Injects values into building Unit properties specified for injection

Redirects building of a unit with one to the unit with another . E.g. redirecting interface to the implementation.

Redirects building of a unit of one open generic type to the unit of another open generic type. E.g. redirecting interface to the implementation

This build action is used mostly for "default" build actions applied to any target unit. For example by default we want to find attributed constructor and if there is no any get the constructor with the largest number of parameters, add these two actions in right order as children of to reach such behaviour. If a build action did not build a unit, this build action calls the next child till a unit will be built.

This class implements and has method to make possible compact and readable initialization like new TryInOrder { new GetConstructorByInjectPoint (), new GetConstructorWithMaxParametersCount () }

Thread safe implementation of build action.

Use to build a unit. See for details.

Builds a Unit registered as type

Returns an instance or null if null is registered as a unit. Throws if unit wasn't built by this or any parent containers

Builds a Unit registered as type passing additional they can be values or implementation of . See and for details.

Additional temporary arguments which could be passed into the build session, they are not stored anywhere and used only for this build session. Normally, usual registrations take over these arguments because the weight of runtime arguments is decreased. See for details. Returns an instance or null if null is registered as a unit. Throws if unit wasn't built by this or any parent containers

Builds all units represented by by all build actions in spite of matching weight. This can be useful to build all implementers of an interface.

Returns a list of built units or null if no an instance or null if null is registered as a unit. Throws if no unit was built by this or any parent containers

Builds all units represented by by all build actions in spite of matching weight. This can be useful to build all implementers of an interface.

Additional temporary arguments which could be passed into the build session, they are not stored anywhere and used only for this build session. Normally, registrations take over these arguments because the weight of runtime arguments is decreased. See for details. Returns a list of built units or null if no an instance or null if null is registered as a unit. Throws if not unit was built by this or any parent containers

All other BuildAll... methods should delegate to this one. This is the real implementation

All other Build... methods should delegate to this one. This is the real implementation

Builds a Unit registered as type with an additional tag passed into method.

Builds a Unit registered as type with an additional tag passed into method passing additional they can be values or implementation of . See for details.

Builds all units represented by by all build actions in spite of matching weight with an additional tag passed into method. This can be useful to build all implementers of an interface.

Returns a list of built units or null if no an instance or null if null is registered as a unit. Throws if no unit was built by this or any parent containers

Builds all units represented by by all build actions in spite of matching weight with an additional tag passed into method passing additional they can be values or implementation of . See for details. This can be useful to build all implementers of an interface.

Returns a list of built units or null if no an instance or null if null is registered as a unit. Throws if no unit was built by this or any parent containers

Represents predefined build stages used by Armature framework.

Use objects but int or enum in order to avoid memory traffic on boxing. new (., ., ., .); An action of the . stage will create a unit in the . method. Then an action of the . stage if any will inject dependencies in the . method. Then an action of the . stage if any will subscribe events, log the event of creation, call methods, etc. in the . method. Then an action of the . stage if any will cache the instance in the . method.

Stage to perform some operations with for diagnostic purpose

Stage of intercepting any unit returned by the build process.

Stage of building when already built and cached object can be reused.

Stage for notifying any concerned party that object was created

Stage of processing fully initialized object, e.g. subscribe events or add it to object pool etc.

Stage of injecting dependencies into newly created unit.

Stage of creating a unit, injects dependencies into a constructor, due it must be called to create the unit.

Provides an access to internal members of tuners. See inheritors of for details.

Appends a branch of nodes from the to and return the deepest of appended nodes.

Adds a branch of nodes to the Tree Root and returns the deepest of added nodes.

Creates an instance of and register passed . Then the tree can be passed to as additional, runtime registrations.

Returns null if no arguments provided

Creates an instance of and register passed if any. Then the tree can be passed to as additional, runtime registrations.

Builds a for a by building a unit represented by (, ) via current build session.

Builds an argument to inject into the property representing by

This is the default build action used by and . You can set your own build action which will be used by these tuners.

Provides possibility to extent the framework with custom Tuners by providing access to internal stuff. Other "tuner" interfaces do not inherit this interface in order to not expose "internals" needed in rare advanced cases. Use and other extension methods from Armature.Sdk namespace to access it.

The "parent" tuner or null if this is a root of a tuning sequence.

The root of the tree containing patterns to match a build stack.

Adds a build stack pattern produced by this tuner as a child of or gets already added one.

Returns the actual build stack pattern node, newly added or obtained from the

The weight used to amend the weight of build stack patterns added by the tuner.

These tags are used by Armature to build such units as a constructor needed to instantiate an object, or an argument for the method parameter and so on. If you need to extend the set of special tags with your own, make a derived class and create tags using protected constructor.

Is used to "build" a for a type

Is used to build a collection of properties of a type

Is used to build an argument for the inject point

Returns a if is a type, otherwise throws exception.

Returns a if is a type, otherwise null.

Inherit this class to extend an enum pattern with custom weights if you extend Armature with your own build stack, unit, or injection point patterns which require to re-balance the weighting system.

Weight of argument matched by assignability to a parameter/property.

Weight of injection point (method parameter or property) matched by strict equality of a parameter/property type.

Weight of argument matched by an attribute used to mark a parameter/property.

Weight of argument matched by a parameter name.

Weights of is about two orders of magnitude higher than weights of in order to registrations like builder.GetOrAddNode(new IfFirstUnit(Unit.Of(typeof(string)), WeightOf.InjectionPoint.ByName)) .GetOrAddNode(new IfFirstUnit(new IsInheritorOf(typeof(BaseType)), WeightOf.UnitPattern.SubtypePattern)) never "wins" builder.GetOrAddNode(new IfFirstUnit(Unit.Of(typeof(string)), WeightOf.InjectionPoint.ByType)) .GetOrAddNode(new IfFirstUnit(new Unit.Of(typeof(ChildType)), WeightOf.UnitPattern.ExactTypePattern)) because the second one is narrower case than the first one

Weight of a type matched by open generic type, unit pattern and for details

Weight of a type matched by base type, unit pattern

Weight of a type matched by exact type

This interface is used as a marker of a tuner which tunes rules for building arguments. It's needed to ensure that not suitable tuner like is not passed to

Adds build actions to build arguments for injection points defined by and tuners.

Use the as an argument for the injection point.

Use an instance returned by as an argument for the injection point.

Shortcut methods to set rules how to build arguments for the constructor and method parameters.

Adds the build action which builds arguments for a method in the order as parameters specified in the method signature.

Adds the build action which builds an argument using method parameter type as a

Adds the build action which builds an argument using method parameter name as a

Provides methods to tune up how to build arguments for method parameters.

Tunes up how to build an argument to inject into method parameter of type .

Tunes up how to build an argument to inject into method parameter named .

Tunes up how to build and argument to inject into a method parameter marked with with the specified .