/// <summary>
/// Initializes a new instance of <see cref="BootContainer"/>
/// </summary>
/// <param name="bindings"><see cref="IBindingCollection">Bindings</see> for the <see cref="BootContainer"/></param>
/// <param name="newBindingsNotifier"><see cref="ICanNotifyForNewBindings">Notifier</see> of new <see cref="Binding">bindings</see></param>
public BootContainer(IBindingCollection bindings, ICanNotifyForNewBindings newBindingsNotifier)
{
_bindings = ConvertBindings(bindings);
_bindings[typeof(IContainer)] = this;
newBindingsNotifier.SubscribeTo(_ => ConvertBindings(_).ForEach(_bindings.Add));
}
static void RegisterUpBindingsIntoContainerBuilder(IBindingCollection bindings, ContainerBuilder containerBuilder)
{
bindings.ForEach(binding =>
{
if (binding.Scope is Scopes.SingletonPerTenant)
{
BindingsPerTenantsRegistrationSource.AddBinding(binding);
return;
}
if (binding.Service.ContainsGenericParameters)
{
if (binding.Strategy is Strategies.Type)
{
var registrationBuilder = containerBuilder.RegisterGeneric(((Strategies.Type)binding.Strategy).Target).As(binding.Service);
if (binding.Scope is Scopes.Singleton)
{
registrationBuilder = registrationBuilder.SingleInstance();
}
}
else if (binding.Strategy is Strategies.TypeCallback)
{
OpenGenericTypeCallbackRegistrationSource.AddService(new KeyValuePair <Type, Func <Type> >(binding.Service, ((Strategies.TypeCallback)binding.Strategy).Target));
}
}
else
{
switch (binding.Strategy)
{
case Strategies.Type type: {
var registrationBuilder = containerBuilder.RegisterType(type.Target).As(binding.Service);
if (binding.Scope is Scopes.Singleton)
{
registrationBuilder = registrationBuilder.SingleInstance();
}
} break;
case Strategies.Constant constant:
containerBuilder.RegisterInstance(constant.Target).As(binding.Service);
break;
case Strategies.Callback callback: {
var registrationBuilder = containerBuilder.Register((context) => callback.Target()).As(binding.Service);
if (binding.Scope is Scopes.Singleton)
{
registrationBuilder = registrationBuilder.SingleInstance();
}
} break;
case Strategies.TypeCallback typeCallback: {
var registrationBuilder = containerBuilder.Register((context) => context.Resolve(typeCallback.Target())).As(binding.Service);
if (binding.Scope is Scopes.Singleton)
{
registrationBuilder = registrationBuilder.SingleInstance();
}
} break;
}
}
});
}
/// <summary>
/// Initializes a new instance of the <see cref="BootContainer"/> class.
/// </summary>
/// <param name="bindings"><see cref="IBindingCollection">Bindings</see> for the <see cref="BootContainer"/>.</param>
/// <param name="newBindingsNotifier"><see cref="ICanNotifyForNewBindings">Notifier</see> of new <see cref="Binding">bindings</see>.</param>
public BootContainer(IBindingCollection bindings, ICanNotifyForNewBindings newBindingsNotifier)
{
_bindings = bindings.ToDictionary(_ => _.Service, _ => _.Strategy);
_bindings[typeof(IContainer)] = new Strategies.Constant(this);
_bindings[typeof(GetContainer)] = new Strategies.Constant((GetContainer)(() => this));
newBindingsNotifier.SubscribeTo(_ => _.ToDictionary(_ => _.Service, _ => _.Strategy).ForEach(_bindings.Add));
}
/// <inheritdoc/>
public IContainer Provide(IAssemblies assemblies, IBindingCollection bindings)
{
var containerBuilder = new ContainerBuilder();
containerBuilder.AddDolittle(assemblies, bindings);
var autofacContainer = containerBuilder.Build();
return(new Container(autofacContainer));
}
/// <summary>
/// Initializes a new instance of <see cref="BootResult"/>
/// </summary>
/// <param name="assemblies"><see cref="IAssemblies"/> used</param>
/// <param name="typeFinder"><see cref="ITypeFinder"/> used</param>
/// <param name="bindings"><see cref="IBindingCollection">Bindings</see> setup</param>
public BootResult(
IAssemblies assemblies,
ITypeFinder typeFinder,
IBindingCollection bindings)
{
Assemblies = assemblies;
TypeFinder = typeFinder;
Bindings = bindings;
}
/// <summary>
/// Initialize a new instance of <see cref="BootStageResult"/>
/// </summary>
/// <param name="container"><see cref="IContainer"/> to use</param>
/// <param name="bindings"><see cref="IBindingCollection"/> containing all bindings for the <see cref="BootStage"/>></param>
/// <param name="associations">Associations created during <see cref="BootStage"/></param>
public BootStageResult(
IContainer container,
IBindingCollection bindings,
IDictionary <string, object> associations)
{
Container = container;
Bindings = bindings;
Associations = new ReadOnlyDictionary <string, object>(associations);
}
/// <summary>
/// Initialize a new instanace of <see cref="BootloaderResult"/>
/// </summary>
/// <param name="container"><see cref="IContainer"/> configured</param>
/// <param name="typeFinder"><see cref="ITypeFinder"/> configured</param>
/// <param name="assemblies"><see cref="IAssemblies"/> configured</param>
/// <param name="bindings"><see cref="IBindingCollection"/> configured</param>
/// <param name="bootStageResults"><see cref="BootStageResults">Results from each boot stage</see></param>
public BootloaderResult(
IContainer container,
ITypeFinder typeFinder,
IAssemblies assemblies,
IBindingCollection bindings,
IEnumerable <BootStageResult> bootStageResults)
{
Container = container;
TypeFinder = typeFinder;
Assemblies = assemblies;
Bindings = bindings;
BootStageResults = bootStageResults;
}
public bool MoveBindingFrom(IKey key, IBindingCollection collection, out string errorMessage)
{
if (!FindBinding(key, false, out var binding, out errorMessage))
{
return(false);
}
if (!collection.MoveBindingTo(binding, out errorMessage))
{
return(false);
}
binding.RemovedSignal.ClearCommands();
_bindings.Remove(key);
return(true);
}
public void Test_ToCollection_Extension_Method_Creates_New_Binding_Collection()
{
IBinding <ISample> binding = from b in Bind <ISample>()
select new Sample();
IBinding <ISample> otherBinding = from b in Bind <ISample>()
select new Sample(new object());
IEnumerable <IBinding> bindings = new List <IBinding> {
binding, otherBinding
};
IBindingCollection collection = bindings.ToCollection();
Assert.Equal(1, collection.TypeCount);
Assert.Equal(2, collection.BindingCount);
}
static IContainer DiscoverAndConfigureContainer(
IContainer bootContainer,
IAssemblies assemblies,
ITypeFinder typeFinder,
IBindingCollection bindingCollection)
{
var containerProviderType = typeFinder.FindSingle <ICanProvideContainer>();
ThrowIfMissingContainerProvider(containerProviderType);
var containerProvider = bootContainer.Get(containerProviderType) as ICanProvideContainer;
var container = containerProvider.Provide(assemblies, bindingCollection);
return(container);
}
IDictionary <Type, object> ConvertBindings(IBindingCollection bindings)
{
return(bindings.ToDictionary(
_ => _.Service,
_ => {
switch (_.Strategy)
{
case Strategies.Constant constant: return constant.Target;
case Strategies.Callback callback: return callback.Target;
case Strategies.Type type: return type.Target;
case Strategies.TypeCallback typeCallback: return typeCallback.Target;
}
return null;
}
));
}
public void CreateBindings(IBindingCollection collection)
{
var targetObjectsToId = new Dictionary <int, object>();
var sourceCompileTimeTypes =
_types.GetTypesWithAttributes(typeof(SourceAttribute), typeof(CompileTimeTypeAttribute));
var sourceRunTimeTypes =
_types.GetTypesWithAttributes(typeof(SourceAttribute), typeof(RunTimeTypeAttribute));
foreach (var sourceCompileTimeType in sourceCompileTimeTypes)
{
foreach (var sourceRunTimeType in sourceRunTimeTypes.Where(type => sourceCompileTimeType.IsAssignableFrom(type)))
{
var objects = new List <object>();
var sourceObject = SandboxHelpers.CreateInstance(sourceRunTimeType);
objects.Add(sourceObject);
var targetObjects = ConfigureTargets(sourceCompileTimeType, sourceObject, targetObjectsToId);
objects.AddRange(targetObjects);
var bindingSymbols = GetBindingSymbols(sourceCompileTimeType);
var bindings = new List <IBinding <Attribute> >();
foreach (var bindingSymbol in bindingSymbols)
{
bindings.AddRange(CreateBindings(sourceCompileTimeType, sourceObject, bindingSymbol));
}
if (bindings.Count > 0)
{
var bindingInitializer = (MethodInfo)sourceCompileTimeType.GetMemberWithAttributeInType <BindingInitializerAttribute>();
var bindingSet = new BindingSet(bindings, bindingInitializer, sourceObject);
collection.AddBindingSet(bindingSet, objects);
}
}
}
}
static IBindingCollection DiscoverAndBuildBuildBindings(
IContainer bootContainer,
ITypeFinder typeFinder,
IScheduler scheduler,
ILogger logger,
IBindingCollection initialBindings,
IEnumerable <Binding> bindings)
{
logger.Trace("Discover bindings");
var discoveredBindings = DiscoverBindings(bootContainer, typeFinder, scheduler, logger);
logger.Trace("Create a new binding collection");
var bindingCollection = new BindingCollection(initialBindings, discoveredBindings, bindings);
foreach (var binding in bindingCollection)
{
logger.Trace("Discovered Binding : {bindingServiceName} - {bindingStrategyTypeName}", binding.Service.AssemblyQualifiedName, binding.Strategy.GetType().Name);
}
var asmBindings = bindingCollection.Where(_ => _.Service == typeof(IAssemblies)).ToArray();
return(bindingCollection);
}
/// <summary>
/// Add Dolittle specifics to the <see cref="ContainerBuilder"/>.
/// </summary>
/// <param name="containerBuilder"><see cref="ContainerBuilder"/> to extend.</param>
/// <param name="assemblies">Discovered <see cref="IAssemblies"/>.</param>
/// <param name="bindings"><see cref="IBindingCollection">Bindings</see> to hook up.</param>
public static void AddDolittle(this ContainerBuilder containerBuilder, IAssemblies assemblies, IBindingCollection bindings)
{
var allAssemblies = assemblies.GetAll().ToArray();
containerBuilder.RegisterAssemblyModules(allAssemblies);
var selfBindingRegistrationSource = new SelfBindingRegistrationSource(type =>
!type.Namespace.StartsWith("Microsoft", StringComparison.InvariantCulture) &&
!type.Namespace.StartsWith("System", StringComparison.InvariantCulture))
{
RegistrationConfiguration = HandleLifeCycleFor
};
containerBuilder.AddBindingsPerTenantRegistrationSource();
containerBuilder.RegisterSource(selfBindingRegistrationSource);
containerBuilder.RegisterSource(new FactoryForRegistrationSource());
containerBuilder.RegisterSource(new OpenGenericCallbackRegistrationSource());
containerBuilder.RegisterSource(new OpenGenericTypeCallbackRegistrationSource());
containerBuilder.RegisterModule(new LoggerModule());
DiscoverAndRegisterRegistrationSources(containerBuilder, allAssemblies);
RegisterUpBindingsIntoContainerBuilder(bindings, containerBuilder);
}
/// <summary>
/// Initializes a new instance of <see cref="BootResult"/>
/// </summary>
/// <param name="container">Configured <see cref="IContainer"/></param>
/// <param name="bindings">Configured <see cref="IBindingCollection">bindings</see></param>
public BootResult(IContainer container, IBindingCollection bindings)
{
Container = container;
Bindings = bindings;
}
/// <inheritdoc/>
public void Notify(IBindingCollection bindings)
{
_subscribers(bindings);
}
public bool MoveBindingFrom(IKey key, IBindingCollection collection, out string errorMessage)
{
return(_bindings.MoveBindingFrom(key, collection, out errorMessage));
}