The Unity container will automatically resolve any type that it can figure out on its own without the need for manual registration. That's good in some ways, but the problem I have is that it uses a TransientLifetimeManager for this type of resolution, while I almost always want a ContainerControlledLifetimeManager. I can still register my types as singletons manually, of course, but if I forget, instead of getting an unhandled exception at startup, the app will launch successfully and everything will appear to work. But there will eventually be bugs, possibly very subtle, hard-to-diagnose ones, due to the fact that there are multiple instances of a type that's meant to be a singleton.
So my question is: Is there a way I can either specify a different default lifetime manager or disable the default auto-resolution behavior completely and limit the container to types I register myself (directly or by my own conventions)?
Is there a way I can either specify a different default lifetime manager
Yes, you can use a container extension that will use a different lifetime manager. See Request for configurable default lifetimemanager for an example.
or disable the default auto-resolution behavior completely and limit the container to types I register myself
Yes, a container extension can do this as well.
First during explicit registration record the BuildKey of the registration. Then before creating the object check if the BuildKey was explicitly registered.
public class RegistrationTrackingExtension : UnityContainerExtension
{
private ConcurrentDictionary<NamedTypeBuildKey, bool> registrations =
new ConcurrentDictionary<NamedTypeBuildKey, bool>();
protected override void Initialize()
{
base.Context.Registering += Context_Registering;
base.Context.Strategies.Add(
new ValidateRegistrationStrategy(this.registrations), UnityBuildStage.PreCreation);
}
private void Context_Registering(object sender, RegisterEventArgs e)
{
var buildKey = new NamedTypeBuildKey(e.TypeTo, e.Name);
this.registrations.AddOrUpdate(buildKey, true, (key, oldValue) => true);
}
public class ValidateRegistrationStrategy : BuilderStrategy
{
private ConcurrentDictionary<NamedTypeBuildKey, bool> registrations;
public ValidateRegistrationStrategy(ConcurrentDictionary<NamedTypeBuildKey, bool> registrations)
{
this.registrations = registrations;
}
public override void PreBuildUp(IBuilderContext context)
{
if (!this.registrations.ContainsKey(context.BuildKey))
{
Exception e = new Exception("Type was not explicitly registered in the container.");
throw new ResolutionFailedException(context.BuildKey.Type, context.BuildKey.Name, e, context);
}
}
}
}
Then add the extension, register some classes and resolve. If the class was not explicitly registered then an exception will be thrown.
IUnityContainer container = new UnityContainer();
// Add container extension
container.AddNewExtension<RegistrationTrackingExtension>();
// Register types
container.RegisterType<MyClass>();
container.RegisterType<IMyClass, MyClass>();
container.RegisterType<IMyClass, MyClass>("A");
// These succeed because they were explicitly registered
container.Resolve<IMyClass>();
container.Resolve<IMyClass>("A");
container.Resolve<MyClass>();
// MyClass2 was not registered so this will throw an exception
container.Resolve<MyClass2>();
I tried the DefaultLifetimeManegerExtension but somehow it didnt work. (Maybe Unity has changed?). Anyways if you dont want to use an Extension you can also make use of the RegsiterByConvention feature.
container.RegisterTypes(AllClasses.FromLoadedAssemblies(), WithMappings.None, WithName.Default, x => new DisposingTransientLifetimeManager());
This will register all Classes with the "DisposingTransientLifetimeManager" which I chose to use as a default one. Note that you should do this at the beginning of your registrations since all registrations will overwrite any previous registrations of the same Type and Name.