Class ImportDependencyAdviceInstance

An aspect returns an ImportDependencyAdviceInstance from ProvideAdvices(object), so that the request can depend on the configuration of the target. The target class is the class to which the aspect is applied, or the declaring class of the member to which it is applied. For each target class, the request does the following:

1. If the class declares or inherits a field of the dependency type that it can access, the request resolves to this field, and nothing else changes. Otherwise, if the class declares or inherits a readable instance property of the dependency type that it can access, the request resolves to this property in the same way; several such properties cause the error LA0286. The field or the property is trusted: the request does not check that the class initializes it.
2. Otherwise, a private read-only field of the dependency type is introduced, as an IntroduceFieldAdviceInstance without a name and with Ignore does. When the field is not private, as specified by Visibility, or when the dependency is lazy, the field stays private and a getter-only property of the dependency type exposes it. A class whose base class exposes the same dependency by such a property uses that property.
3. A parameter of the dependency type is appended to the instance constructors of the class, and to those of the classes that derive from it, whose base(...) calls pass it, also when they are in another assembly that PostSharp processes. A constructor that already has a parameter of exactly the dependency type uses it.
4. Each original constructor is kept as a forwarder that passes null for the dependency. A public forwarder becomes protected internal, or internal in a sealed class, so that a dependency injection container sees only the constructors that receive the dependency, while the code of the assembly and the derived classes in other assemblies can still call it.
5. The constructors assign the field just after the base constructor call, as C# assigns a field from a constructor parameter, and before the aspects are initialized and the body of the constructor runs. When the argument is null, the dependency is resolved from RunTimeServiceLocator: GetRequiredService<T>() for a required dependency, which throws InvalidOperationException when no service is registered, and GetService<T>() for an optional one.

The advices of the aspect instance that made the request receive the dependency through a parameter annotated with ImportMemberAttribute: by the Name of the request, whatever the names of the field and of the property, or without a name, by the dependency type. The parameter receives the property when there is one, and the field otherwise. On a static target, it receives null.

An object of the class can still be created with new in the project, through a forwarder: its dependencies are then resolved from RunTimeServiceLocator, where the application registers a factory for each service. The request also works with OnInstanceConstructedAdvice: the dependencies are assigned before the advice runs.

Applying such an aspect to a public class changes its public constructors. This is a binary breaking change for the consumers of the class. Several requests for the same dependency type in a class give one field and one parameter, which is required when one of the requests is.