public static void Main(IocBuilder builder)
{
using (var game = new CedrusGame(builder))
{
game.Run();
}
}
public void ScopeResolvesAndDisposesLambdaCorrectly()
{
var container = new IocBuilder()
.Register <IA, A>()
.RegisterPerScope <IB>(c => new B())
.Build();
IA a1 = null;
IA a2 = null;
IB b1 = null;
IB b2 = null;
using (var scope = container.Scope)
{
a1 = scope.Resolve <IA>();
a2 = scope.Resolve <IA>();
b1 = scope.Resolve <IB>();
b2 = scope.Resolve <IB>();
}
Assert.AreNotEqual(a1, a2);
Assert.AreEqual(b1, b2);
b1 = container.Resolve <IB>();
Assert.AreNotEqual(b1, b2);
}
public void ResolveMultipelWithScope()
{
var builder = new IocBuilder();
builder.RegisterSingleton <IA, A>();
builder.Register <IB, B>();
builder.Register <IC, C>();
builder.Register <ID, D>();
builder.Register <ID, D>();
builder.RegisterPerScope <ID, D>();
builder.Register <IF, F>();
var container = builder.Build();
IEnumerable <ID> d1;
using (var scope = container.Scope)
{
d1 = scope.Resolve <IEnumerable <ID> >();
var d2 = scope.Resolve <IEnumerable <ID> >();
//Assert.AreNotEqual(d1.FirstOrDefault().GetHashCode(), d2.LastOrDefault().GetHashCode());
Assert.AreEqual(d1.LastOrDefault(), d2.LastOrDefault());
}
var d3 = container.Resolve <IEnumerable <ID> >();
Assert.AreNotEqual(d1.FirstOrDefault(), d3.LastOrDefault());
Assert.AreNotEqual(d1.LastOrDefault(), d3.LastOrDefault());
}
static void Main(string[] args)
{
var ioc = IocBuilder.Create()
.RegisterType <ITestService, TestServiceImpl>()
.UseLogProvider(MvxLogProviderType.NLog)
.Build();
Console.WriteLine("Hello World!");
// var testService = ioc.Resolve<ITestService>();
ioc.ResolveScope <ITestService>(x =>
{
while (true)
{
var log = ioc.Resolve <ITcLogProvider>();
var logger = log.GetLogFor <Program>();
logger.Info(x.GetIndex().ToString());
Console.WriteLine(x.GetIndex());
var k = Console.ReadLine();
if (k == "a")
{
break;
}
}
});
var service = ioc.Resolve <ITestService>();
while (true)
{
Console.WriteLine(service.GetIndex());
Console.ReadKey();
}
}
public void ResolveMultipleWithSingletonAndMatch()
{
var builder = new IocBuilder();
builder.RegisterSingleton <IA, A>().Match <A>();
builder.Register <IB, B>();
builder.Register <IC, C>();
builder.Register <ID, D>();
builder.Register <ID, D>();
builder.RegisterSingleton <ID, D>().Match <D>();
builder.Register <IF, F>();
var container = builder.Build();
var f1 = container.Resolve <IF>();
var f2 = container.Resolve <IF>();
var a = container.Resolve <A>();
var d = container.Resolve <D>();
Assert.AreNotEqual(f1, f2);
Assert.AreNotEqual(f1.Ds.FirstOrDefault().B, f2.Ds.FirstOrDefault().B);
Assert.AreEqual(f1.Ds.FirstOrDefault().A, f2.Ds.FirstOrDefault().A);
CollectionAssert.AreEqual(f1.Ds.Select(c => c.A).ToArray(), f2.Ds.Select(c => c.A).ToArray());
Assert.AreEqual(f1.Ds.FirstOrDefault().A, a);
Assert.AreEqual(f1.Ds.LastOrDefault(), d);
}
private void CreateModules(IocBuilder iocBuilder, IStartupService startupConfiguration, ICollection <Type> moduleTypes)
{
foreach (var moduleType in moduleTypes)
{
var moduleObject = Activator.CreateInstance(moduleType) as JulyModule;
if (moduleObject == null)
{
throw new InvalidOperationException("This type is not a July Module: " + moduleType.AssemblyQualifiedName);
}
moduleObject.StartupService = startupConfiguration;
var moduleInfo = new JulyModuleInfo(moduleType);
moduleInfo.Instance = moduleObject;
_moduleList.Add(moduleInfo);
if (moduleType == _moduleList.StartupModuleType)
{
StartupModule = moduleInfo;
}
iocBuilder.RegisterInstance(moduleObject).AsSelf().SingleInstance();
Logger.LogDebug("Create module instance: " + moduleType.AssemblyQualifiedName);
}
}
public void Should_Constructor_When_NameIsNotNull_Then_NamePropertyIsSame()
{
const string IOCBUILDERNAME = "IocBuilderName";
var iocBuilder = new IocBuilder(IOCBUILDERNAME);
Assert.Equal(IOCBUILDERNAME, iocBuilder.Name);
}
/// <summary>
/// Creates the test ioc manager.
/// </summary>
/// <returns></returns>
private static IIocManager CreateTestIocManager()
{
IocBuilder builder = new IocBuilder("Demo");
CastleWindsorIocBuilder castleWindsorIocBuilder = builder.UseCastleWindsor();
return(castleWindsorIocBuilder.Create());
}
public override void Register(IocBuilder builder)
{
LogManager.Configuration = new XmlLoggingConfiguration("log.config");
builder
.Register <IAppender, NLogAppender>()
.RegisterPerScope <LoggingContext, LoggingContext>();
}
private static void Main(string[] args)
{
XmlConfigurator.Configure();
var container = IocBuilder.Build();
SetupCommandLineOptions(args, container);
StartSpeedtest(container);
}
protected void Application_Start()
{
IocBuilder.Build();
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
}
public void Should_Instance_When_Initialize_Return_SameNameAndType()
{
IocBuilder builder = new IocBuilder("Demo");
var castleWindsorIocBuilder = builder.UseCastleWindsor();
castleWindsorIocBuilder.Name.ShouldBe("Demo");
castleWindsorIocBuilder.Type.ShouldBe("CastleWindsor");
}
public void MissingRegistrationThrowsExceptionOnContainerBuild()
{
var builder = new IocBuilder();
builder.Register <IA, A>();
builder.Register <IC, C>();
builder.Register <ID, D>();
var container = builder.Build();
}
public static void Main()
{
var builder = new IocBuilder();
using (var game = new CedrusGame(builder))
{
game.Run();
}
}
private static void RegisterDependencies(IocBuilder builder)
{
builder.Register <IRouteHandler>().Concrete <RouteHandler>();
builder.Register <IConfigManager>().Concrete <ConfigManager>().AsSingleton();
builder.Register <IConfigLoader>().Concrete <ConfigLoader>();
builder.Register <IFileSystemProvider>().Concrete <FileSystemProvider>();
builder.Register <IJsonReader>().Concrete <JsonReader>();
}
public override void Register(IocBuilder builder)
{
builder.RegisterSingleton(c =>
RenderingUtilities.CreateRenderTarget(c.Resolve <GraphicsDevice>(), 10, 10))
.IdentifiedAs("background")
.Register(c =>
new Func <Color>(() => Color.White))
.IdentifiedAs("backgroundColor")
.RegisterSingleton <BackgroundLayerRenderer, BackgroundLayerRenderer>();
}
public void ConfigureServices(IocBuilder iocBuilder)
{
var sortedModules = _moduleList.GetSortedModuleListByDependency();
foreach (var module in sortedModules)
{
module.Instance.ConfigureServices(iocBuilder);
Logger.LogDebug($"Module: {module.Type.AssemblyQualifiedName} configure services completed");
}
}
public static void Main()
{
var builder = new IocBuilder();
builder.RegisterModules(Assembly.GetExecutingAssembly());
using (var game = new CedrusGame(builder))
{
game.Run();
}
}
private static IUnityContainer BuildUnityContainer()
{
var container = new UnityContainer();
container.RegisterType <IUserStore <IdentityUser>, UserStore>();
container.RegisterType <IUserManager <IdentityUser>, ApplicationUserManager>();
IocBuilder.BuildContainer(container);
return(container);
}
public void RegisterResolveKeyedFunc()
{
var builder = new IocBuilder();
builder.Register(c => new Func <string>(() => "hello")).IdentifiedAs("test");
var container = builder.Build();
var func = container.ResolveWithId <Func <string> >("test");
Assert.AreEqual("hello", func());
}
public void ResolveSelfRegistered()
{
var builder = new IocBuilder();
builder.Register <A, A>();
var container = builder.Build();
var a = container.Resolve <A>();
var b = container.Resolve <A>();
Assert.AreNotEqual(a, b);
}
public void ResolveSingletonLambda()
{
var builder = new IocBuilder();
builder.RegisterSingleton <IA>(c => new A());
var container = builder.Build();
var a1 = container.Resolve <IA>();
var a2 = container.Resolve <IA>();
Assert.AreEqual(a1, a2);
}
public IServiceProvider ConfigureServices(IServiceCollection services)
{
var builder = IocBuilder.New(services, StartupService);
JulyModuleManager manager = new JulyModuleManager(StartupModule);
manager.Initialize(builder, StartupService);
manager.ConfigureServices(builder);
return(builder.Build());
}
public void SimpleResolve()
{
var builder = new IocBuilder();
builder.Register <IA, A>();
var container = builder.Build();
var a = container.Resolve <IA>();
var b = container.Resolve <IA>();
Assert.AreNotEqual(a, b);
}
public void ResolveMultipleOfSameType()
{
var builder = new IocBuilder();
builder.Register <IA, A>();
builder.Register <IA, A>();
var container = builder.Build();
var a = container.Resolve <IEnumerable <IA> >().ToArray();
Assert.AreEqual(2, a.Count());
Assert.AreNotEqual(a[0], a[1]);
}
public void ResolveKeyed()
{
var builder = new IocBuilder();
builder.Register <G, G>();
builder.RegisterSingleton <IA, A>().IdentifiedAs("test");
var container = builder.Build();
var g = container.Resolve <G>();
var a = container.ResolveWithId <IA>("test");
Assert.AreEqual(g.A, a);
}
public void ResolveEnumerableSingletonWithMatch()
{
var builder = new IocBuilder();
builder.RegisterSingleton <IA, A>().Match <A>();
var container = builder.Build();
var a3 = container.Resolve <IEnumerable <A> >();
var a1 = container.Resolve <IA>();
var a2 = container.Resolve <IA>();
Assert.AreEqual(a1, a2);
Assert.AreEqual(a2, a3.FirstOrDefault());
}
public void ResolveSingletonWithMatch()
{
var builder = new IocBuilder();
builder.RegisterSingleton <IA, A>().Match <A>();
var container = builder.Build();
var a1 = container.Resolve <IA>();
var a2 = container.Resolve <IA>();
var a3 = container.Resolve <A>();
Assert.AreEqual(a1, a2);
Assert.AreEqual(a2, a3);
}
public void ResolveSingletonWithDependencies()
{
var container = new IocBuilder()
.Register <IA, A>()
.Register <IB, B>()
.Register <IC, C>()
.RegisterSingleton <ID, D>()
.Build();
var d1 = container.Resolve <ID>();
var d2 = container.Resolve <ID>();
Assert.AreEqual(d1, d2);
}
public void Configure <T>() where T : IConfigurator, new()
{
var config = new T();
var builder = new MiddlewareBuilder();
config.Configure(builder);
middleware = builder.Build();
var iocBuilder = new IocBuilder();
config.ConfigureServices(iocBuilder);
Services = iocBuilder.Build();
}
