Interface IAdviceFactory

Gets the immutable ICompilation representing the code before any change done by the current aspect.

Gets the mutable ICompilation that the current aspect builder is working on. It includes all modifications done by the current aspect in the current type using declarative advices and the IAdviceFactory.

Adds a custom annotation to a declaration. An annotation is an arbitrary but serializable object that can then be retrieved using the GetAnnotations<TAnnotation>() method of the Enhancements<T>(T) object. Annotations are a way of communication between aspects or classes of aspects.

Adds a contract to a field, property or indexer. Contracts are usually used to validate the value assigned to fields properties or indexers or to normalize their value (null-to-empty, trimming, normalizing case, ...) before assignment. Alternatively, a contract can be used to validate the value returned by a property or indexer, in which case the direction parameter should be set to Output.

Adds a contract to a parameter. Contracts are usually used to validate parameters (pre- or post-conditions) or to normalize their value (null-to-empty, trimming, normalizing case, ...).

Adds an initializer to a specific constructor by specifying an IStatement.

Adds an initializer to a specific constructor by using a template.

Adds a type or instance initializer by specifying an IStatement.

Adds a type or instance initializer by using a template, specifying whether the initializer should run before or after the call to the base initializer.

Adds a type or instance initializer by using a template.

Makes a type implement a new interface specified as an INamedType. Interface members can be introduced by marking an aspect member by InterfaceMemberAttribute, IntroduceAttribute(IDeclaration, IAttributeData, OverrideStrategy) or programmatically using Introduce methods.

Makes a type implement a new interface specified as a reflection Type. Interface members can be introduced by marking an aspect member by InterfaceMemberAttribute, IntroduceAttribute(IDeclaration, IAttributeData, OverrideStrategy) or programmatically using Introduce methods.

Adds a custom attribute to a given declaration.

Introduces an auto-implemented property to the target type by specifying a property name and IType.

Introduces an auto-implemented property to the target type by specifying a property name and Type.

Introduces a new binary operator or overrides the implementation of the existing one.

Introduces a new class to the target namespace or type.

Introduces a new constructor or overrides the implementation of the existing one.

Introduces a new conversion operator or overrides the implementation of the existing one.

Introduces a new event to the target type, or overrides the implementation of an existing one, by specifying an event template.

Introduces a new event to the target type, or overrides the implementation of an existing one, by specifying individual template methods for the adder, the remover, and the raiser.

Introduces a new extension block into a static class. Extension blocks allow adding extension members (methods, properties, operators) to a type (represented as an IType). Requires C# 14+ and Roslyn 5.0+.

Introduces a new extension block into a static class. Extension blocks allow adding extension members (methods, properties, operators) to a type (represented as a Type). Requires C# 14+ and Roslyn 5.0+.

Introduces a field to the target type by specifying a template.

Introduces a field to the target type by specifying a field name and IType.

Introduces a field to the target type by specifying a field name and Type.

Introduces a finalizer or overrides the implementation of the existing one.

Introduces an indexer to the target type, or overrides the implementation of an existing one, by specifying individual template methods for each accessor.

Introduces an indexer to the target type, or overrides the implementation of an existing one, by specifying individual template methods for each accessor.

Introduces an indexer to the target type, or overrides the implementation of an existing one, by specifying individual template methods for each accessor.

Introduces an indexer to the target type, or overrides the implementation of an existing one, by specifying individual template methods for each accessor.

Introduces a new interface to the target namespace or type.

Introduces a new method or overrides the implementation of the existing one.

Appends a required parameter (i.e. one that has no default value) to a constructor by specifying its name and IType. The framework also emits a forwarding constructor: a compile-time stub with the pre-mutation signature that chains via : this(...) to the now-mutated constructor. The forwarding constructor obtains the new parameter's value from the supplied IPullStrategy (for example, UseExpression(IExpression) for a non-constant expression such as DateTime.Now, or IntroduceParameterAndPull(string?, IType?, IExpression?, IExpression?, bool, bool) to cascade a dependency into chained and derived constructors). Because the pre-mutation signature remains callable, both source and binary compatibility are preserved. This overload is the right choice when binary compatibility matters, when the default must be a non-constant expression, or when a parameterless constructor must remain callable (for example, through CreateInstance<T>() or the new() generic constraint). Pass a custom IConstructorOverloadingStrategy to scope which constructors receive a forwarding constructor, or to opt out entirely.

Appends an optional parameter (i.e. one that has a compile-time-constant default value) to a constructor by specifying its name and IType. The new parameter is added directly to the existing constructor; existing callers can omit the argument, so source compatibility is preserved. Binary compatibility is not preserved. Because the constructor count is unchanged, this overload is the right choice for dependency-injection scenarios where the container requires exactly one applicable constructor (for example, Microsoft.Extensions.DependencyInjection.ActivatorUtilities).

Appends a parameter to a constructor by specifying its name and IType.

Appends a required parameter (i.e. one that has no default value) to a constructor by specifying its name and Type. The framework also emits a forwarding constructor: a compile-time stub with the pre-mutation signature that chains via : this(...) to the now-mutated constructor. The forwarding constructor obtains the new parameter's value from the supplied IPullStrategy (for example, UseExpression(IExpression) for a non-constant expression such as DateTime.Now, or IntroduceParameterAndPull(string?, IType?, IExpression?, IExpression?, bool, bool) to cascade a dependency into chained and derived constructors). Because the pre-mutation signature remains callable, both source and binary compatibility are preserved. This overload is the right choice when binary compatibility matters, when the default must be a non-constant expression, or when a parameterless constructor must remain callable (for example, through CreateInstance<T>() or the new() generic constraint). Pass a custom IConstructorOverloadingStrategy to scope which constructors receive a forwarding constructor, or to opt out entirely.

Appends an optional parameter (i.e. one that has a compile-time-constant default value) to a constructor by specifying its name and Type. The new parameter is added directly to the existing constructor; existing callers can omit the argument, so source compatibility is preserved. Binary compatibility is not preserved. Because the constructor count is unchanged, this overload is the right choice for dependency-injection scenarios where the container requires exactly one applicable constructor (for example, Microsoft.Extensions.DependencyInjection.ActivatorUtilities).

Appends a parameter to a constructor by specifying its name and Type.

Introduces a property to the target type, or overrides the implementation of an existing one, by specifying a property template.

Introduces a property to the target type, or overrides the implementation of an existing one, by specifying individual template methods for each accessor.

Introduces a new unary operator or overrides the implementation of the existing one.

Overrides the implementation of a constructor.

Overrides a field or property by specifying a property template.

Overrides the implementation of a method.

Overrides an event by specifying a template for the adder, the remover, and/or the raiser.

Overrides a field or property by specifying method templates for the getter, the setter, or both.

Overrides a field or property by specifying a method template for the getter, the setter, or both.

Overrides an indexer by specifying method templates for the getter, the setter, or both.

Removes all custom attributes of a given INamedType from a given declaration.

Removes all custom attributes of a given Type from a given declaration.

Returns a copy of the current IAdviceFactory that will use the specified object to find template methods.

Returns a copy of the current IAdviceFactory that will use the specified object to find template methods.