public IDependencyContainer Init()
{
var depCon = new SimpleDependencyContainer();
RegisterRepositories(depCon);
Entity.DepCon = depCon;
return(depCon);
}
public static void Test()
{
IDependencyContainer dependencyContainer = new SimpleDependencyContainer();
dependencyContainer.Definitions
.AddScoped <ResolveUrl>(dependencyContainer.ScopeName, new ResolveUrl(ResolveUrl));
ResolveUrl resolveUrl = dependencyContainer.Resolve <ResolveUrl>();
resolveUrl("~/root");
}
public void Test__CircularDependency()
{
// Arrange
var container = SimpleDependencyContainer.New().AddMap <ICircularDependency, CircularDependency>();
// Act
var exception = Record.Exception(() => container.Resolve <CircularDependency>());
// Assert
Assert.IsType <ArgumentException>(exception);
}
public void Test__TypeMap()
{
// Arrange
var container = SimpleDependencyContainer.New().AddMap <IDummyInterface, DummyClass>();
// Act
var model = container.Resolve <ModelWithInterface>();
// Assert
Assert.NotNull(model);
}
public void Test__RegisterInstance()
{
// Arrange
var expected = _fixture.Create <FlatModelSource>();
var container = SimpleDependencyContainer.New().RegisterInstance(expected);
// Act
var flatModelSource = container.Resolve <FlatModelSource>();
// Assert
Assert.Equal(expected, flatModelSource);
}
public void Base()
{
IDependencyContainer root = new SimpleDependencyContainer();
IReflectionService reflectionService = ReflectionFactory.FromCurrentAppDomain();
using (ITypeExecutorService executorService = reflectionService.PrepareTypeExecutors())
{
executorService.AddQueryHandlers(root);
}
IQueryHandler <Q1, R1> handler1 = root.Resolve <IQueryHandler <Q1, R1> >();
IQueryHandler <Q2, R2> handler2 = root.Resolve <IQueryHandler <Q2, R2> >();
}
public void Test__ResolvableCircularDependency()
{
// Arrange
var container = SimpleDependencyContainer.New();
// Act
var simple = container.Resolve <ResolvableCircularDependency>();
var lazy = container.Resolve <ResolvableCircularDependencyLazy>();
var func = container.Resolve <ResolvableCircularDependencyFunc>();
// Assert
Assert.NotNull(simple);
Assert.NotNull(func.ResolvableCircularDependency());
Assert.NotNull(lazy.ResolvableCircularDependency.Value);
}
public void Test__GetInstance()
{
// Arrange
var expected = _fixture.Create <FlatModelSource>();
var container = SimpleDependencyContainer.New()
.RegisterDependency(x => x.SetType(typeof(FlatModelSource))
.SetArgs(new object[] { expected.Name, expected.Age, expected.DateOfBith })
.Compile());
// Act
var flatModelSource = container.Resolve <FlatModelSource>();
// Assert
Assert.Equal(expected, flatModelSource);
}
private static HelloService Sequence()
{
IDependencyContainer dependencyContainer = new SimpleDependencyContainer();
dependencyContainer.Definitions
.AddScoped <string>(dependencyContainer.ScopeName, "Hi")
.AddScoped <TextWriter>(dependencyContainer.ScopeName, Console.Out);
SequenceBootstrapper bootstrapper = new SequenceBootstrapper(task => dependencyContainer.Resolve <IBootstrapTask>(task));
bootstrapper.Register <Sequence.WriterBootstrapTask>();
bootstrapper.Register <Sequence.HelloBootstrapTask>();
bootstrapper.Initialize();
//return Engine.Environment.With<HelloService>();
throw new NotImplementedException();
}
public static void Start()
{
//HtmlContext.alert("Hell, World!");
IDependencyContainer dependencyContainer = new SimpleDependencyContainer();
dependencyContainer.Definitions
.AddTransient <Presenter>()
.AddScoped <MainView>();
Presenter p1 = dependencyContainer.Resolve <Presenter>();
p1.Render();
Presenter p2 = dependencyContainer.Resolve <Presenter>();
p2.Render();
}
public void ConcreteType()
{
IDependencyContainer root = new SimpleDependencyContainer();
IReflectionService reflectionService = ReflectionFactory.FromCurrentAppDomain();
using (ITypeExecutorService executorService = reflectionService.PrepareTypeExecutors())
{
executorService.AddQueryHandlers(root);
}
IQueryHandler <Q3, R3> handler1 = root.Resolve <IQueryHandler <Q3, R3> >();
try
{
IQueryHandler <Q4, R4> handler2 = root.Resolve <IQueryHandler <Q4, R4> >();
Assert.Fail("Handler for Q4 should not be registered");
}
catch (DependencyRegistrationFailedException)
{ }
}
public static void UseSimpleDependencyContainer()
{
var dependencyResolver = new SimpleDependencyContainer();
var registrarInterface = typeof(IDependencyRegistrar);
var registrars = AppDomain.CurrentDomain.GetAssemblies().ToList()
.SelectMany(assembly => assembly.GetTypes())
.Where(type => type != registrarInterface && registrarInterface.IsAssignableFrom(type))
.Select(type => Activator.CreateInstance(type) as IDependencyRegistrar);
if (registrars.Count() > 0)
{
foreach (var registrar in registrars)
registrar.RegisterDependencies(dependencyResolver);
dependencyResolver.RegisterCreator<IDependencyRegistry>(() => dependencyResolver);
dependencyResolver.RegisterCreator<INamedDependencyResolver>(() => dependencyResolver);
MvcDependencyResolver.SetResolver(dependencyResolver);
}
}
public Bootstrapper()
{
var depCon = new SimpleDependencyContainer();
Entity.DepCon = depCon;
}
