private void BuildApplicationObjectGraph(ContainerBuilder builder, params Assembly[] assemblies)
{
// Instantiate and store all controllers...
// These must be executed in the order of dependency. For example the RulesController requires a NewRuleController so the NewRuleController must be instantiated first.
IContainer container = builder.Build();
Logger = container.Resolve <ILogger>();
foreach (Assembly assembly in assemblies)
{
var requiredPropertyInjections = DefaultIoCRegistrations.ProcessPropertyInjection(assembly);
foreach (PropertyInjectionDependencyRequirement requirement in requiredPropertyInjections)
{
// Some reasonably awkard Autofac usage here to allow testibility. (Extension methods aren't easy to test)
IComponentRegistration registration;
bool success = container.ComponentRegistry.TryGetRegistration(new TypedService(requirement.DependencyRequired), out registration);
if (success)
{
object dependency = container.ResolveComponent(registration, Enumerable.Empty <Parameter>());
requirement.PropertyInjectionAssignment(dependency);
}
}
}
// Kick it off
ConstructUiContext(container);
this.disposables.AddIfSomething(container.Resolve <ICredentialStore>() as IDisposable);
ShellController = container.Resolve <ShellController>();
ShellWindow = new ShellWindow {
DataContext = ShellController
};
}
public void ProcessPropertyInjectionShouldThrowGivenNullAssembly()
{
IEnumerable <PropertyInjectionDependencyRequirement> result = DefaultIoCRegistrations.ProcessPropertyInjection(null);
result.Any();
Assert.Fail();
}
private static void ComposeTypesWithDefaultImplementations(Assembly assembly, ContainerBuilder builder)
{
var dependencies = DefaultIoCRegistrations.RegisterAutoMappingsFromAssembly(assembly);
foreach (var dependency in dependencies)
{
IRegistrationBuilder <object, ConcreteReflectionActivatorData, SingleRegistrationStyle> registration;
if (dependency.IsSingleInstance)
{
// Singleton
registration = builder.RegisterType(dependency.DependencyRequired).SingleInstance();
}
else
{
// Transient
registration = builder.RegisterType(dependency.DependencyRequired).InstancePerDependency();
}
if (dependency.NamedInstanceName.IsSomething())
{
// Named Dependency
registration = registration.Named(dependency.NamedInstanceName, dependency.DependencyRequired);
}
registration.AsImplementedInterfaces().AsSelf();
// Register as custom type, other than its own class name, and directly implemented interfaces.
if (dependency.AdditionalRegistrationType != null)
{
registration.As(dependency.AdditionalRegistrationType);
}
}
}
public void EnsureAllInterfacesAreRegisteredWithIoC()
{
try
{
List <DependencyRegistrationRequirement> dependencies = DefaultIoCRegistrations.RegisterAutoMappingsFromAssembly(typeof(StatementModel).Assembly).ToList();
dependencies.AddRange(DefaultIoCRegistrations.RegisterAutoMappingsFromAssembly(typeof(SecureStringCredentialStore).Assembly));
IEnumerable <Type> interfaces = typeof(StatementModel).Assembly.GetTypes().Where(t => t.IsInterface);
List <string> exemptionListNames = ExemptionList.Select(e => e.FullName).ToList();
foreach (var interfaceType in interfaces.Except(ExemptionList))
{
Console.Write("Interface: {0}", interfaceType.Name);
if (exemptionListNames.Contains(interfaceType.FullName))
{
continue;
}
if (!dependencies.Any(d => d.AdditionalRegistrationType == interfaceType || IsSelfRegistered(interfaceType, d)))
{
Assert.Fail($"Interface: {interfaceType.FullName} is not registered.");
}
Console.WriteLine(" registered.");
}
}
catch (ReflectionTypeLoadException ex)
{
foreach (var exception in ex.LoaderExceptions)
{
Debug.WriteLine(exception);
}
Assert.Fail();
}
}
private IContainer BuildApplicationObjectGraph(ContainerBuilder builder, params Assembly[] assemblies)
{
// Build Application Object Graph
var container = builder.Build();
Logger = container.Resolve <ILogger>();
// Ensure anything requiring property injection is assigned a value.
foreach (Assembly assembly in assemblies)
{
var requiredPropertyInjections = DefaultIoCRegistrations.ProcessPropertyInjection(assembly);
foreach (PropertyInjectionDependencyRequirement requirement in requiredPropertyInjections)
{
// Some reasonably awkard Autofac usage here to allow testibility. (Extension methods aren't easy to test)
IComponentRegistration registration;
bool success = container.ComponentRegistry.TryGetRegistration(new TypedService(requirement.DependencyRequired), out registration);
if (success)
{
object dependency = container.ResolveComponent(registration, Enumerable.Empty <Parameter>());
requirement.PropertyInjectionAssignment(dependency);
}
}
}
ConstructUiContext(container);
return(container);
}
public void RegisterAutoMappings_ShouldThrowGivenNullAssembly()
{
IEnumerable <DependencyRegistrationRequirement> result = DefaultIoCRegistrations.RegisterAutoMappingsFromAssembly(null);
result.ToList();
Assert.Fail();
}
public void ProcessPropertyInjection_ShouldBeAbleToAssignLoggerToProperty()
{
var logger = new FakeLogger();
IEnumerable <PropertyInjectionDependencyRequirement> result = DefaultIoCRegistrations.ProcessPropertyInjection(GetType().Assembly);
result.First().PropertyInjectionAssignment(logger);
Assert.AreSame(logger, AutoRegisterWithIoCProcessorPropertyInjectionTestSource.Logger);
}
public void RegisterAutoMappings_ShouldReturnFakeLoggerRegistration()
{
IEnumerable <DependencyRegistrationRequirement> result = DefaultIoCRegistrations.RegisterAutoMappingsFromAssembly(GetType().Assembly);
var loggerRegistration = result.Last();
Assert.AreEqual(typeof(FakeLogger), loggerRegistration.DependencyRequired);
Assert.IsTrue(loggerRegistration.IsSingleInstance);
Assert.AreEqual("Named Logger", loggerRegistration.NamedInstanceName);
}
public LocalDiskReaderWriterSelector([NotNull] IEnumerable <IFileReaderWriter> allReaderWriters)
{
if (allReaderWriters == null)
{
throw new ArgumentNullException(nameof(allReaderWriters));
}
var fileReaderWriters = allReaderWriters.ToList();
this.encryptedReaderWriter = DefaultIoCRegistrations.GetNamedInstance(fileReaderWriters, StorageConstants.EncryptedInstanceName);
this.unprotectedRaderWriter = DefaultIoCRegistrations.GetNamedInstance(fileReaderWriters, StorageConstants.UnprotectedInstanceName);
}
public void ProcessPropertyInjection_ShouldFindOnePropertyInjectionDependency()
{
IEnumerable <PropertyInjectionDependencyRequirement> result = DefaultIoCRegistrations.ProcessPropertyInjection(GetType().Assembly);
Assert.AreEqual(1, result.Count());
}
public void RegisterAutoMappings_ShouldReturnTwoGivenThisAssembly()
{
IEnumerable <DependencyRegistrationRequirement> result = DefaultIoCRegistrations.RegisterAutoMappingsFromAssembly(GetType().Assembly);
Assert.AreEqual(2, result.Count());
}
public void ProcessPropertyInjection_ShouldFindStaticClassWithILoggerProperty()
{
IEnumerable <PropertyInjectionDependencyRequirement> result = DefaultIoCRegistrations.ProcessPropertyInjection(GetType().Assembly);
Assert.AreEqual(typeof(ILogger), result.First().DependencyRequired);
}
