.WithParameter(
new ResolvedParameter(
(pi, ctx) => pi.ParameterType == typeof(IReadonlyRepository),
(pi, ctx) => ctx.Parent.Type == typeof(SomeType) ? ctx.Resolve<NonDefaultReadonlyRepository>() : ctx.Resolve<DefaultReadonlyRepository>())
Is it possible to transitively perform property injection? What I want to do is for every Form instantiated, recursively walk the child tree of Controls and inject properties on the concrete types. My previous solution using Unity was to make every Form and User Control derive from a special class that, in its constructor, would inject properties on itself. The issue with this is that it breaks lifecycle management because everything uses the root container. Sadly also now code has started to depend on properties being injected before/during construction of the object. So I need an elegant, transparent two-phase initialization process for these winforms objects. It's really tough.
As a workaround, I created a IUserControlPropertyInjector service that I inject in any forms which it uses to inject properties in child UserControl objects. But it's a very manual process and requires me to refactor each class.
I think Stack Overflow has been ineffective in getting help for this, so I'm happy to patiently wait for a helpful response here.
I don't personally come into Gitter, I won't lie. There are too many existing avenues to monitor from Stack Overflow to Twitter to newsgroups to issues and I don't make it in here. I don't see that changing in the future; honestly, I'd just as soon shut the Gitter down to remove the impression that this is super active, but if the community can help the community, awesome.
Windows Forms apps don't have any sort of built-in DI support. There's no "standard way" to handle it, there aren't any "hooks," and I haven't seen any "patterns" [that I'm aware of, anyway]. However you do end up implementing it is going to be app-specific. You're not getting a response from the Autofac folks on Stack Overflow because we don't have an answer for you - the people who need to help you are Windows Forms developers who have implemented DI. Why the Windows Forms audience isn't helping isn't something I can speak to. I'm sorry you didn't get an answer to your question; I'm afraid I don't have an answer, either. I'd recommend doing a bit of Googling on "windows forms di" - it appears there are several forum posts and blog entries that may help, but since I don't develop Windows Forms apps nor is there any specific Autofac support for them... that's the best I can offer.
I realized that a singleton registered in a root container will not be able to resolve overrides in a child lifetime scope of an interface also registered at the root, even if the singleton is resolved through a child lifetime scope. But my understanding is this is only useful for lifetimes managed by a scope to begin with. InstancePerDependency isn't auto-disposed by the container, so why can't singletons pull overridden dependencies from a child container?
Migrating from Unity this is one thing that bit me. I ended up using Multitenant to solve the issue and instead of SingleInstance I use InstancePerTenant. But even that isn't a 100% solution if you switch tenants and expect the same singleton instance between them, AFAIK.
Wanted to open an SO question for this but this is a low-effort question on purpose.
And how should a singleton pull dependencies from a childscope? This would either promote the childscope to rootscope or the singleton would be on childscope level and not root level. What should happen if Singleton A gets a Dependency B from a child scope with
B: IDisposable and the child-scope gets disposed?
I don't view this as a singleton pulling dependencies from a child scope because I resolved the singleton through the child scope to begin with. Non-singleton types can already resolve overrides from the container that was used to resolve the original type, so I sort of feel like that should work for singletons too (for ephemeral, non-disposed instances). And even if InstancePerDependency types implement IDisposable, the container/lifetime scope will likely outlive the resolved instance, so why would it keep track of it and dispose it? Either I'm missing something or that doesn't make sense.
Again I understand why instances must be resolved within the container of the singleton. I did enough reading on that. But I'm assuming InstancePerDependency types are not disposed by the container, since it's very likely the container will outlive them. So I'm hoping that if disposal semantics don't take place, then there's no reason for types to only be resolved in the container that the singleton was registered in (instead, we can use the registrations from the lifetime scope the original Resolve() method was called on like everything else)
Lazy<IMyService> use the root context to resolve its type instead of the multitenant context? I can't quite figure it out. The type it is resolving is registered in the root container that was passed to the multitenant container when it was constructed.