There anyway to use RegisterAssemblyTypes, or other batch registration, to register open generics, when the type is unknown at compile time? AsClosedTypes requires the type to be specififed. I need to derive it from the scanned type.
You want to find generic-types in assemblies and register all implementations without knowing the generic types?
There anyway to use RegisterAssemblyTypes, or other batch registration, to register open generics, when the type is unknown at compile time? AsClosedTypes requires the type to be specififed. I need to derive it from the scanned type.
You want to find generic-types in assemblies and register all implementations without knowing the generic types?
If I understood your requirement correctly, I made a small example on how it'd be possible to do that with Autofac.
https://github.com/alsami/Autofac.GenericTypes.Unknown.git
Keep in mind that there are a few edge-cases where this wouldn't work without some more work. For instance when generic is implemented through a base-class and what not.
I am trying to resolve a type at runtime. Basically the type's constructor accepts both (autofac registered) dependencies as well as other values. This is how my code looks like:
MVVMContextCompositionRootEx.ViewModelCreate += (s, e) =>
{
using (var scope = rootContainer.BeginLifetimeScope(
containerBuilder => containerBuilder.RegisterType(e.RuntimeViewModelType).As(e.ViewModelType)))
{
e.ViewModel = scope.Resolve(e.ViewModelType, e.Parameters.Select(x => new NamedParameter(x.Item1, x.Item2)));
}
};Basically, the constructor arguments are got from e.Parameters but there I want to filter out parameters which are dependencies already registered in autofac.
Hey Guys. Does anyone know of a good blog on updating Autofac to use .Net Core 3.0? We are utilizing an in house core library to control Autofac and the current documentation doesn't answer all of the questions that we have.
I don't know any but I'd be glad to help. Basically there is not much difference when speaking about ASP.NET Core 3 vs 2.x
These links pretty much show the difference:
https://autofac.readthedocs.io/en/latest/integration/aspnetcore.html#asp-net-core-1-1-2-2
https://autofac.readthedocs.io/en/latest/integration/aspnetcore.html#asp-net-core-3-0-and-generic-hosting
I think there changed nothing within .net core 3.0 only with asp.net core 3.0 (see https://autofaccn.readthedocs.io/en/latest/integration/aspnetcore.html#asp-net-core-3-0-and-generic-hosting)
There is no actual ETA but we are working on it
Is there a way to tell Autofac to dispose the scope (and the dependencies it resolved) associated with an object, if all I got is the concrete instance?
For e.g. I got this:
var myService = scope.Resolve(....
// later at some point,
rootContainer.DisposeOff(myService) // <-- this should dispose the lifetime scope of myService, i.e. dispose myService, along with its other dependencies.
.WithMetadata( "__RegistrationOrder", -1), but that throws because the "__RegistrationOrder" metadata has already been added and .WithMetadata does not overwrite
any idea why Owned<T> different than Func<Owner<T>>? it seems just trying to resolve Owned<T> wont create a new lifetimescope
I think you mean Func<Owned<T>> - Func is just scaffolding to scrap boilerplate for creating a factory that has a ILifetimeScope. This is because the signature for a Factory Method pattern is:
public interface IFactory<T>
{
T Create(object context);
}Which can be simplified to just:
public interface IFactory<T>
{
T Create();
}Which can be, if you squint your eyes, converted to just:
Func<T> TFactory => _lifetimeScope.Resolve<T>();and so, when you call TFactory(); you're effectively calling new YourFactory<T>().Create();
object context parameter can be a higher-order parameter by passing it into the object's constructor instead of as a parameter, so that it can be recursively called on any method the factory exposes. But Factories in general just expose a single method, Create();.
This exception was originally thrown at this call stack:
Autofac.Util.TypeExtensions.IsCompatibleWithGenericParameterConstraints(System.Type, System.Type[])
Autofac.Features.OpenGenerics.OpenGenericServiceBinder.TryBindServiceType(Autofac.Core.Service, System.Collections.Generic.IEnumerable<Autofac.Core.Service>, System.Type, out System.Type, out Autofac.Core.Service[])
Autofac.Features.OpenGenerics.OpenGenericRegistrationSource.RegistrationsFor(Autofac.Core.Service, System.Func<Autofac.Core.Service, System.Collections.Generic.IEnumerable<Autofac.Core.IComponentRegistration>>)
Autofac.Core.Registration.ComponentRegistry.GetInitializedServiceInfo(Autofac.Core.Service)
Autofac.Core.Registration.ComponentRegistry.IsRegistered(Autofac.Core.Service)
Autofac.RegistrationExtensions.IfNotRegistered.AnonymousMethod__0(Autofac.Core.IComponentRegistry)
Autofac.RegistrationExtensions.OnlyIf.AnonymousMethod__0(Autofac.Core.IComponentRegistry)
Autofac.ContainerBuilder.Build(Autofac.Core.IComponentRegistry, bool)
Autofac.Module.Configure(Autofac.Core.IComponentRegistry)
Autofac.ContainerBuilder.Build(Autofac.Core.IComponentRegistry, bool)
HResult=0x80131508
Message=Index was outside the bounds of the array.
Resolve<Owned<T>>() or depending on Owned<T> will create a new scope. Check out https://github.com/autofac/Autofac/blob/develop/src/Autofac/Features/OwnedInstances/OwnedInstanceRegistrationSource.cs#L66
Func<> will create a new scope for each invocation of the function, so behavior differs between these two, but both end up creating new scopes by way of Owned<T>. HTH!