public void NInject()
{
var configuration = new KernelConfiguration();
foreach (var type in _types)
{
configuration.Bind(type).To(type);
}
var container = configuration.BuildReadonlyKernel();
int length = 0;
if (Scenario == ResolveScenario.ResolveOne)
{
length = 1;
}
else if (Scenario == ResolveScenario.ResolveHalf)
{
length = _types.Length / 2;
}
else if (Scenario == ResolveScenario.ResolveAll)
{
length = _types.Length;
}
for (var i = 0; i < length; i++)
{
container.GetService(_types[i]);
}
container.Dispose();
}
public void TestLoad()
{
//
// 1.测试读取测试配置
//
KernelConfiguration configuration = null;
XmlDocument doc = new XmlDocument();
XmlNode node;
doc.Load(path);
node = doc.GetElementsByTagName(KernelConfiguration.SectionName)[0];
XmlSerializer ser = new XmlSerializer(typeof(KernelConfiguration));
configuration = (KernelConfiguration)ser.Deserialize(new XmlNodeReader(node));
Assert.IsNotNull(configuration);
//
// 2.测试读取默认应用配置
//
configuration = KernelConfigurationView.Instance.Configuration;
Assert.IsNotNull(configuration);
}
public void GlobalSetup()
{
var ninjectSettings = new NinjectSettings
{
// Disable to reduce memory pressure
ActivationCacheDisabled = true,
LoadExtensions = false
};
_kernelConfiguration = new KernelConfiguration(ninjectSettings);
_kernelConfiguration.Bind <IWarrior>().To <SpecialNinja>().WhenInjectedExactlyInto <NinjaBarracks>();
_kernelConfiguration.Bind <IWarrior>().To <Samurai>().WhenInjectedExactlyInto <Barracks>();
_kernelConfiguration.Bind <IWarrior>().To <FootSoldier>().WhenInjectedExactlyInto <Barracks>();
_kernelConfiguration.Bind <IWarrior>().To <FootSoldier>();
_kernelConfiguration.Bind <IWeapon>().To <Shuriken>().WhenInjectedExactlyInto <Barracks>();
_kernelConfiguration.Bind <IWeapon>().To <Sword>();
_kernelConfiguration.Bind <ICleric>().To <Monk>();
_kernelConfiguration.Bind(typeof(ICollection <>)).To(typeof(List <>));
_kernelConfiguration.Bind(typeof(IList <>)).To(typeof(List <>));
_kernelConfiguration.Bind <ISingleton>().To <Singleton>().InSingletonScope();
_kernelConfiguration.Bind <IRouteProvider>().To <RouteProvider>();
_kernelConfiguration.Bind <IRouteRepository>().To <RouteRepository>();
_kernelConfiguration.Bind <ITrainPlanner>().To <TrainPlanner>();
_kernelConfiguration.Bind <IRealtimeEventSource>().To <RealtimeEventSource>();
_readOnlyKernel = _kernelConfiguration.BuildReadOnlyKernel();
ClearCache(_readOnlyKernel);
}
public void GlobalSetup()
{
var ninjectSettingsWithConstructorAndPropertyInjection = new NinjectSettings
{
// Disable to reduce memory pressure
ActivationCacheDisabled = true,
LoadExtensions = false,
PropertyInjection = true,
MethodInjection = false
};
var ninjectSettingsWithOnlyConstructorInjection = new NinjectSettings
{
// Disable to reduce memory pressure
ActivationCacheDisabled = true,
LoadExtensions = false,
PropertyInjection = false,
MethodInjection = false
};
_kernelConfigurationWithConstructorAndPropertyInjection = CreateKernelConfiguration(ninjectSettingsWithConstructorAndPropertyInjection);
_kernelConfigurationWithOnlyConstructorInjection = CreateKernelConfiguration(ninjectSettingsWithOnlyConstructorInjection);
_kernelWithConstructorAndPropertyInjection = _kernelConfigurationWithConstructorAndPropertyInjection.BuildReadOnlyKernel();
_kernelWithOnlyConstructorInjection = _kernelConfigurationWithOnlyConstructorInjection.BuildReadOnlyKernel();
_weaponRequest = _kernelWithConstructorAndPropertyInjection.CreateRequest(typeof(IWeapon), null, Array.Empty <IParameter>(), false, true);
_clericRequest = _kernelWithConstructorAndPropertyInjection.CreateRequest(typeof(ICleric), null, Array.Empty <IParameter>(), false, true);
_reflectRequest = _kernelWithConstructorAndPropertyInjection.CreateRequest(typeof(IReflect), null, Array.Empty <IParameter>(), false, true);
_barracksRequest = _kernelWithConstructorAndPropertyInjection.CreateRequest(typeof(NinjaBarracks), null, Array.Empty <IParameter>(), false, true);
_leasureRequest = _kernelWithConstructorAndPropertyInjection.CreateRequest(typeof(ILeasure), null, new IParameter[] { new ConstructorArgument("immediately", true, true) }, false, true);
}
public void Create_ShouldUseConstructorArgumentsForBestConstructor()
{
var seq = new MockSequence();
var injectorOneMock = new Mock <ConstructorInjector>(MockBehavior.Strict);
var injectorTwoMock = new Mock <ConstructorInjector>(MockBehavior.Strict);
var directiveOne = new ConstructorInjectionDirective(GetMyServiceWeaponAndWarriorConstructor(), injectorOneMock.Object);
var directiveTwo = new ConstructorInjectionDirective(GetMyServiceClericAndName(), injectorTwoMock.Object);
var name = new Random().Next().ToString();
var cleric = new Monk();
var instance = new object();
var parameters = new List <IParameter>
{
new ConstructorArgument("name", name),
new ConstructorArgument("weapon", new Dagger()),
new ConstructorArgument("cleric", cleric),
};
var kernelConfiguration = new KernelConfiguration(_ninjectSettings);
var context = CreateContext(kernelConfiguration, kernelConfiguration.BuildReadOnlyKernel(), parameters, typeof(NinjaBarracks), _providerCallbackMock.Object, _ninjectSettings);
context.Plan = new Plan(typeof(MyService));
context.Plan.Add(directiveOne);
context.Plan.Add(directiveTwo);
_constructorScorerMock.InSequence(seq).Setup(p => p.Score(context, directiveOne)).Returns(2);
_constructorScorerMock.InSequence(seq).Setup(p => p.Score(context, directiveTwo)).Returns(3);
injectorTwoMock.InSequence(seq).Setup(p => p(cleric, name)).Returns(instance);
var actual = _standardProvider.Create(context);
Assert.Same(instance, actual);
}
private static IReadOnlyKernel BuildKernel(INinjectSettings ninjectSettings)
{
var kernelConfiguration = new KernelConfiguration(ninjectSettings);
kernelConfiguration.Bind <IWarrior>().To <SpecialNinja>().WhenInjectedExactlyInto <NinjaBarracks>();
kernelConfiguration.Bind <IWarrior>().To <Samurai>().WhenInjectedExactlyInto <Barracks>();
kernelConfiguration.Bind <IWarrior>().To <FootSoldier>().WhenInjectedExactlyInto <Barracks>();
kernelConfiguration.Bind <IWarrior>().To <FootSoldier>();
kernelConfiguration.Bind <IWeapon>().To <Shuriken>().WhenInjectedExactlyInto <Barracks>();
kernelConfiguration.Bind <IWeapon>().To <ShortSword>().WhenInjectedExactlyInto <NinjaBarracks>();
kernelConfiguration.Bind <IWeapon>().To <Sword>();
kernelConfiguration.Bind <IWeapon>().To <Dagger>();
kernelConfiguration.Bind <ICleric>().To <Monk>();
kernelConfiguration.Bind(typeof(ICollection <>)).To(typeof(List <>));
kernelConfiguration.Bind(typeof(IList <>)).To(typeof(List <>));
kernelConfiguration.Bind <ISingletonService>().To <SingletonService>().InSingletonScope();
kernelConfiguration.Bind <IThreadLocalService>().To <ThreadLocalService>().InThreadScope();
kernelConfiguration.Bind <ILeasure>()
.To <TakeAWalk>()
.WithParameter(new ConstructorArgument("walkTime", TimeSpan.FromMinutes(5), true));
kernelConfiguration.Bind <IAnimal>()
.To <Dog>()
.WhenInjectedExactlyInto <TakeAWalk>();
kernelConfiguration.Bind <IWeapon>()
.To <Dagger>()
.WhenInjectedExactlyInto <TakeAWalk>();
return(kernelConfiguration.BuildReadOnlyKernel());
}
private IReadOnlyKernel RegisterApplicationComponents(IApplicationBuilder app, ILoggerFactory loggerFactory, TokenValidationParameters tokenParams)
{
IKernelConfiguration config = new KernelConfiguration();
// Add JWT generation endpoint:
var secretKey = Configuration["secret"];
var signingKey = new SymmetricSecurityKey(Encoding.ASCII.GetBytes(secretKey));
var options = new TokenProviderOptions
{
Audience = tokenParams.ValidAudience,
Issuer = tokenParams.ValidIssuer,
SigningCredentials = new SigningCredentials(tokenParams.IssuerSigningKey, SecurityAlgorithms.HmacSha256)
};
config.Bind <TokenProviderOptions>().ToConstant(options).InSingletonScope();
// Register application services
//config.Bind(app.GetControllerTypes()).ToSelf().InScope(RequestScope);//todo fix
config.Bind <HomeController>().ToSelf().InScope(RequestScope);
config.Bind <BooksController>().ToSelf().InScope(RequestScope);
var dataContext = new DataContext(Configuration.GetConnectionString("DefaultConnection"));
//config.Bind<IUserService>().To<AspNetUserService>().InScope(RequestScope);
config.Bind <IDataContext>().ToConstant(dataContext).InSingletonScope();
config.Bind <IUserRepository>().ToConstant(dataContext.Users).InSingletonScope();
config.Bind <IBookRepository>().ToConstant(dataContext.Books).InSingletonScope();
//config.Bind<CustomMiddleware>().ToSelf();
// Cross-wire required framework services
config.BindToMethod(app.GetRequestService <IViewBufferScope>);
config.Bind <ILoggerFactory>().ToConstant(loggerFactory);
return(config.BuildReadonlyKernel());
}
public CacheBenchmark()
{
var ninjectSettings = new NinjectSettings
{
// Disable to reduce memory pressure
ActivationCacheDisabled = true,
LoadExtensions = false,
};
_cache = new Cache(new Pipeline(Enumerable.Empty <IActivationStrategy>(), new ActivationCache(new NoOpCachePruner())), new NoOpCachePruner());
_kernelConfiguration = new KernelConfiguration();
_readOnlyKernel = _kernelConfiguration.BuildReadOnlyKernel();
_instanceForScopeWithZeroEntries = new object();
_instanceReferenceForScopeWithZeroEntries = new InstanceReference {
Instance = _instanceForScopeWithZeroEntries
};
_scopeWithNoCache = new object();
_scopeWithOneEntryForBindingConfiguration = new object();
_scopeWithZeroEntriesForBindingConfiguration = new object();
_scopeWithMoreThanOneEntryForBindingConfiguration = new object();
_contextWithNoCache = CreateContext(_kernelConfiguration, _readOnlyKernel, typeof(string), _scopeWithNoCache, ninjectSettings);
_contextWithZeroEntriesForBindingConfiguration = CreateContext(_kernelConfiguration, _readOnlyKernel, typeof(string), _scopeWithZeroEntriesForBindingConfiguration, ninjectSettings);
_contextWithOneEntryForBindingConfiguration = CreateContext(_kernelConfiguration, _readOnlyKernel, typeof(string), _scopeWithOneEntryForBindingConfiguration, ninjectSettings);
_contextWithMoreThanOneEntryForBindingConfiguration = CreateContext(_kernelConfiguration, _readOnlyKernel, typeof(string), _scopeWithMoreThanOneEntryForBindingConfiguration, ninjectSettings);
}
public void GlobalSetup()
{
var ninjectSettings = new NinjectSettings {
LoadExtensions = false
};
var kernelConfiguration = new KernelConfiguration(ninjectSettings);
kernelConfiguration.Bind <IWarrior>().To <SpecialNinja>().WhenInjectedExactlyInto <NinjaBarracks>();
kernelConfiguration.Bind <IWarrior>().To <Samurai>().WhenInjectedExactlyInto <Barracks>();
kernelConfiguration.Bind <IWarrior>().To <FootSoldier>().WhenInjectedExactlyInto <Barracks>();
kernelConfiguration.Bind <IWeapon>().To <Shuriken>().WhenInjectedExactlyInto <Barracks>();
kernelConfiguration.Bind <IWeapon>().To <ShortSword>().WhenInjectedExactlyInto <Spartan>();
_injectorFactory = new ExpressionInjectorFactory();
_contextWithParams = CreateContext(kernelConfiguration,
kernelConfiguration.BuildReadOnlyKernel(),
new List <IParameter>
{
new ConstructorArgument("height", 34),
new PropertyValue("name", "cutter"),
new ConstructorArgument("width", 17),
new ConstructorArgument("location", "Biutiful")
},
typeof(StandardConstructorScorerBenchmark),
ninjectSettings);
_contextWithoutParams = CreateContext(kernelConfiguration,
kernelConfiguration.BuildReadOnlyKernel(),
Enumerable.Empty <IParameter>(),
typeof(StandardConstructorScorerBenchmark),
ninjectSettings);
_injectCtor = typeof(NinjaBarracks).GetConstructor(new[] { typeof(IWarrior), typeof(IWeapon) });
_injectCtorDirective = new ConstructorInjectionDirective(_injectCtor, _injectorFactory.Create(_injectCtor));
_defaultCtor = typeof(NinjaBarracks).GetConstructor(new Type[0]);
_defaultCtorDirective = new ConstructorInjectionDirective(_defaultCtor, _injectorFactory.Create(_defaultCtor));
_knifeCtor = typeof(Knife).GetConstructor(new[] { typeof(int), typeof(int) });
_knifeCtorDirective = new ConstructorInjectionDirective(_knifeCtor, _injectorFactory.Create(_knifeCtor));
_knifeDefaultsCtor = typeof(Knife).GetConstructor(new[] { typeof(bool), typeof(string) });
_knifeDefaultsCtorDirective = new ConstructorInjectionDirective(_knifeDefaultsCtor, _injectorFactory.Create(_knifeDefaultsCtor));
_spartanNameAndAgeCtor = typeof(Spartan).GetConstructor(new[] { typeof(string), typeof(int) });
_spartanNameAndAgeCtorDirective = new ConstructorInjectionDirective(_spartanNameAndAgeCtor, _injectorFactory.Create(_spartanNameAndAgeCtor));
_spartanHeightAndWeaponCtor = typeof(Spartan).GetConstructor(new[] { typeof(string), typeof(int) });
_spartanHeightAndWeaponCtorDirective = new ConstructorInjectionDirective(_spartanHeightAndWeaponCtor, _injectorFactory.Create(_spartanHeightAndWeaponCtor));
_barracksCtor = typeof(Barracks).GetConstructor(new[] { typeof(IWarrior), typeof(IWeapon) });
_barracksCtorDirective = new ConstructorInjectionDirective(_barracksCtor, _injectorFactory.Create(_barracksCtor));
_monasteryCtor = typeof(Monastery).GetConstructor(new[] { typeof(IWarrior), typeof(IWeapon) });
_monasteryCtorDirective = new ConstructorInjectionDirective(_monasteryCtor, _injectorFactory.Create(_monasteryCtor));
_standardConstructorScorer = new StandardConstructorScorer(ninjectSettings);
}
static void Main()
{
// Use the assembly GUID as the name of the mutex which we use to detect if an application instance is already running
var mutexName = Assembly.GetExecutingAssembly().GetType().GUID.ToString();
using (var mutex = new Mutex(false, mutexName, out var createdNew))
{
if (!createdNew)
{
// Only allow one instance
return;
}
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
try
{
var kernel = new KernelConfiguration(new MainModule(), new CoreModule()).BuildReadonlyKernel();
var context = kernel.Get <STAApplicationContext>();
Application.Run(context);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
public IKernelConfiguration CreateKernelConfiguration(ILogger log)
{
var config = new KernelConfiguration();
config.Bind <ILogger>().ToConstant(log);
return(config);
}
public StandardProviderBenchmark()
{
var ninjectSettings = new NinjectSettings
{
// Disable to reduce memory pressure
ActivationCacheDisabled = true,
LoadExtensions = false
};
var kernelConfigurationWithoutBindings = new KernelConfiguration(ninjectSettings);
#region FromConstructorArguments
_contextWithConstructorArguments = CreateContext(kernelConfigurationWithoutBindings,
kernelConfigurationWithoutBindings.BuildReadOnlyKernel(),
new List <IParameter>
{
new ConstructorArgument("location", "Biutiful"),
new PropertyValue("warrior", "cutter"),
new ConstructorArgument("warrior", new Monk()),
new ConstructorArgument("weapon", new Dagger()),
},
typeof(NinjaBarracks),
ninjectSettings);
_contextWithConstructorArguments.Plan = kernelConfigurationWithoutBindings.Components.Get <IPlanner>().GetPlan(typeof(NinjaBarracks));
#endregion FromConstructorArguments
#region FromBindings
var kernelConfigurationWithBindings = new KernelConfiguration(ninjectSettings);
kernelConfigurationWithBindings.Bind <IWarrior>().To <Monk>().InSingletonScope();
kernelConfigurationWithBindings.Bind <IWeapon>().To <Dagger>().InSingletonScope();
_contextWithoutConstructorArguments = CreateContext(kernelConfigurationWithBindings,
kernelConfigurationWithBindings.BuildReadOnlyKernel(),
new List <IParameter>(),
typeof(NinjaBarracks),
ninjectSettings);
_contextWithoutConstructorArguments.Plan = kernelConfigurationWithBindings.Components.Get <IPlanner>().GetPlan(typeof(NinjaBarracks));
#endregion FromBindings
#region FromDefaultConstructor
_contextWithDefaultConstructor = CreateContext(kernelConfigurationWithBindings,
kernelConfigurationWithBindings.BuildReadOnlyKernel(),
new List <IParameter>(),
typeof(Dagger),
ninjectSettings);
_contextWithDefaultConstructor.Plan = kernelConfigurationWithBindings.Components.Get <IPlanner>().GetPlan(typeof(Dagger));
#endregion FromDefaultConstructor
_warriorParameterTarget = CreateWarriorParameterTarget();
_standardProvider = new StandardProvider(typeof(StandardProviderBenchmark),
kernelConfigurationWithoutBindings.Components.Get <IPlanner>(),
kernelConfigurationWithoutBindings.Components.Get <IConstructorScorer>());
}
public IKernelConfiguration CreateKernelConfiguration(ILogger log)
{
var config = new KernelConfiguration();
config.Bind <IFakeService>().To <FakeService>().InSingletonScope();
config.Bind <ILogger>().ToConstant(log);
return(config);
}
public NinjectBenchmark()
{
var config = new KernelConfiguration();
config.Bind <ISingleton>().To <Singleton>().InSingletonScope();
config.Bind <ITransient>().To <Transient>().InTransientScope();
config.Bind <ICombined>().To <Combined>().InTransientScope();
kernel = config.BuildReadonlyKernel();
}
public static async Task RegisterAccounts(int count)
{
var registrarKernelConfiguration = new KernelConfiguration(
new BehindTheNameGeneratorModule(),
new DungeonCrawlRegistrarAccountBotModule(DungeonCrawlServerLabels.Akrasiac, ProxyList),
new PasswordGeneratorModule(),
new EmailGeneratorModule());
var registrarReadonlyKernel = registrarKernelConfiguration.BuildReadonlyKernel();
var dungeonCrawlRegistrarAccountBot = registrarReadonlyKernel.Get <DungeonCrawlRegistrarAccountBot>();
await dungeonCrawlRegistrarAccountBot.RegisterAccount(count);
}
protected ReadOnlyKernelContext()
{
var settings = new NinjectSettings
{
// Disable to reduce memory pressure
ActivationCacheDisabled = true,
LoadExtensions = false,
};
Configuration = new KernelConfiguration(settings);
}
public static void Setup()
{
var kcfg = new KernelConfiguration(
new FitsArchiveLibModule(),
new ViewModelsModule(),
new ViewsModule()
);
PreKernelBuild(kcfg);
Kernel = kcfg.BuildReadonlyKernel();
PostKernelBuild();
}
public static INForumApplicationBuilder WithNinject(this INForumApplicationBuilder app)
{
IKernelConfiguration config = new KernelConfiguration();
// Register application services
config.Bind(app.ApplicationBuilder.GetControllerTypes()).ToSelf().InScope(RequestScope);
config.Bind <IUserService>().To <AspNetUserService>().InScope(RequestScope);
//config.Bind<CustomMiddleware>().ToSelf();
// Cross-wire required framework services
config.BindToMethod(app.GetRequestService <IViewBufferScope>);
//config.Bind<ILoggerFactory>().ToConstant(loggerFactory);
config.Bind <ICommandDispatcher>().To <CommandDispatcher>();
config.Bind <IQueryDispatcher>().To <QueryDispatcher>();
config.Bind <IHttpContextAccessor>().ToMethod((context) => {
return(app.ApplicationServices.GetRequiredService <IHttpContextAccessor>());
}).InScope(RequestScope);
config.Bind <IPrincipal>().ToMethod((context) => {
return(context.Kernel.Get <IHttpContextAccessor>().HttpContext.User);
}).InScope(RequestScope);
config
.Bind(typeof(IGenericValidationCommandHandlerDecorator <>))
.To(typeof(GenericValidationCommandHandlerDecorator <>));
config
.Bind(typeof(IGenericPermissionCheckCommandHandlerDecorator <>))
.To(typeof(GenericPermissionCheckCommandHandlerDecorator <>));
config
.Bind(typeof(IGenericValidationQueryHandlerDecorator <,>))
.To(typeof(GenericValidationQueryHandlerDecorator <,>));
config
.Bind(typeof(IGenericPermissionCheckQueryHandlerDecorator <,>))
.To(typeof(GenericPermissionCheckQueryHandlerDecorator <,>));
Assembly coreAssembly = typeof(NForum.CQS.CommandWithStatus).GetTypeInfo().Assembly;
config.BindQueryHandlers(coreAssembly);
config.BindCommandHandlers(coreAssembly);
config.BindPermissionChecks(coreAssembly);
config.BindValidators(coreAssembly);
kernel = config.BuildReadonlyKernel();
return(builder);
}
public void UseReflectionBasedInjection_Disabled()
{
var settings = new NinjectSettings {
UseReflectionBasedInjection = false
};
var kernelConfiguration = new KernelConfiguration(settings);
var injectorFactories = kernelConfiguration.Components.GetAll <IInjectorFactory>();
Assert.Single(injectorFactories);
Assert.Single(injectorFactories, s => s is ExpressionInjectorFactory);
}
/// <summary>重新加载</summary>
public void Reload()
{
this.configuration = KernelConfigurationView.Instance.Configuration;
string authenticationManagementType = KernelConfigurationView.Instance.AuthenticationManagementType;
this.authenticationManagement = (IAuthenticationManagement)CreateObject(authenticationManagementType);
// -------------------------------------------------------
// 设置定时器
// -------------------------------------------------------
// 定时清理临时目录下的临时文件 设置为 3 天
if (!Directory.Exists(KernelConfigurationView.Instance.ApplicationTempPathRoot))
{
DirectoryHelper.Create(KernelConfigurationView.Instance.ApplicationTempPathRoot);
}
timer.Enabled = true;
// 每天检测一次目录
timer.Interval = 24 * 60 * 60 * 1000;
timer.Elapsed += delegate(object sender, ElapsedEventArgs e)
{
try
{
string[] files = Directory.GetFiles(KernelConfigurationView.Instance.ApplicationTempPathRoot, "*.*", SearchOption.AllDirectories);
foreach (string file in files)
{
DateTime createdTime = File.GetCreationTime(file);
if (createdTime.AddDays(KernelConfigurationView.Instance.ApplicationTempFileRemoveTimerInterval) < DateTime.Now)
{
File.Delete(file);
logger.Info("Delete expired temporary file:" + file);
}
}
}
catch (Exception ex)
{
logger.Error(ex);
}
};
timer.Start();
}
private IReadOnlyKernel RegisterApplicationComponents(IApplicationBuilder app, ILoggerFactory loggerFactory)
{
IKernelConfiguration config = new KernelConfiguration();
// Register application services
config.Bind(app.GetControllerTypes()).ToSelf().InScope(RequestScope);
// Cross-wire required framework services
config.BindToMethod(app.GetRequestService <IViewBufferScope>);
config.Bind <ILoggerFactory>().ToConstant(loggerFactory);
config.Bind <IConfiguration>().ToConstant(Configuration);
return(config.BuildReadonlyKernel());
}
public void PropertyInjection_Disabled()
{
var settings = new NinjectSettings {
PropertyInjection = false
};
var kernelConfiguration = new KernelConfiguration(settings);
var planningStrategies = kernelConfiguration.Components.GetAll <IPlanningStrategy>();
Assert.Empty(planningStrategies.Where(p => p is PropertyReflectionStrategy));
var activationStrategies = kernelConfiguration.Components.GetAll <IActivationStrategy>();
Assert.Empty(planningStrategies.Where(p => p is PropertyInjectionStrategy));
}
public static async Task GoToUser(string userName, int count)
{
var botKernelConfiguration = new KernelConfiguration(
new DungeonCrawlBotModule(DungeonCrawlServerLabels.Akrasiac, ProxyList));
var botReadonlyKernel = botKernelConfiguration.BuildReadonlyKernel();
using (var dungeonCrawlBot = botReadonlyKernel.Get <DungeonCrawlBot>())
{
await dungeonCrawlBot.Connect(count);
await dungeonCrawlBot.Login();
await dungeonCrawlBot.WatchUser(userName);
}
}
private static void PreKernelBuild(KernelConfiguration kcfg)
{
var path = Path.GetDirectoryName(typeof(Bootstrap).Assembly.Location);
var logFile = Path.Combine(path, "fitsarchive.log");
// Default ILog binding is the common log.
kcfg.Bind <ILog>().ToMethod((context) =>
{
var ls = context.Kernel.Get <ILogService>();
return(ls.HasLog(CommonLogName) ? ls.GetLog(CommonLogName) : ls.InitializeLog(CommonLogName, logFile));
});
// Bind ViewModelProvider
kcfg.Bind <IViewModelProvider>().ToMethod(context => new ViewModelProvider(Kernel)).InSingletonScope();
}
public void PropertyInjection_Enabled()
{
var settings = new NinjectSettings {
PropertyInjection = true
};
var kernelConfiguration = new KernelConfiguration(settings);
var planningStrategies = kernelConfiguration.Components.GetAll <IPlanningStrategy>();
Assert.NotNull(planningStrategies.SingleOrDefault(p => p is PropertyReflectionStrategy));
var activationStrategies = kernelConfiguration.Components.GetAll <IActivationStrategy>();
Assert.NotNull(activationStrategies.SingleOrDefault(p => p is PropertyInjectionStrategy));
}
public void Setup()
{
var kernelConfig = new KernelConfiguration(new ResolverModule());
_useCaseInteractor = Substitute.For <IInteractor <MockUseCase, IMockOutputPort> >();
_globalMiddleware = Substitute.For <IMiddleware>();
_globalMiddleware.Execute(
Arg.Any <MockUseCase>(),
d => Task.FromResult(new UseCaseResult(true)),
Arg.Any <CancellationToken>())
.ReturnsForAnyArgs(x => new UseCaseResult(true))
.AndDoes(x => x.Arg <Func <MockUseCase, Task <UseCaseResult> > >().Invoke(x.Arg <MockUseCase>()));
_middleware1 = Substitute.For <IMiddleware <MockUseCase, IMockOutputPort> >();
_middleware1.Execute(
Arg.Any <MockUseCase>(),
Arg.Any <IMockOutputPort>(),
d => Task.FromResult(new UseCaseResult(true)),
Arg.Any <CancellationToken>())
.ReturnsForAnyArgs(x => new UseCaseResult(true))
.AndDoes(x => x.Arg <Func <MockUseCase, Task <UseCaseResult> > >().Invoke(x.Arg <MockUseCase>()));
_middleware2 = Substitute.For <IMiddleware <MockUseCase, IMockOutputPort> >();
_middleware2.Execute(
Arg.Any <MockUseCase>(),
Arg.Any <IMockOutputPort>(),
d => Task.FromResult(new UseCaseResult(true)),
Arg.Any <CancellationToken>())
.ReturnsForAnyArgs(x => new UseCaseResult(true))
.AndDoes(x => x.Arg <Func <MockUseCase, Task <UseCaseResult> > >().Invoke(x.Arg <MockUseCase>()));
kernelConfig.Bind <IMiddleware <MockUseCase, IMockOutputPort> >()
.ToMethod(context => _middleware1);
kernelConfig.Bind <IMiddleware <MockUseCase, IMockOutputPort> >()
.ToMethod(context => _middleware2);
kernelConfig.Bind <IInteractor <MockUseCase, IMockOutputPort> >()
.ToMethod(context => _useCaseInteractor);
kernelConfig.Bind <IMiddleware>()
.ToMethod(context => _globalMiddleware);
var kernel = kernelConfig.BuildReadonlyKernel();
_interactorHub = kernel.Get <IInteractorHub>();
}
public void TestSave()
{
KernelConfiguration configuration = new KernelConfiguration();
KernelConfigurationKey key1 = new KernelConfigurationKey("HostName", "http://www.kanf.cn");
KernelConfigurationKey key2 = new KernelConfigurationKey("Version", "1.0.0.0");
KernelConfigurationKey key3 = new KernelConfigurationKey("Author", "X3Platform");
KernelConfigurationKey key4 = new KernelConfigurationKey("ApplicationPathRoot", "E:\\Workspace\\X3Platform\\branches\\1.0.0\\trunk\\Kernel\\Kernel.TestSuite\\");
configuration.Keys.Add(key1);
configuration.Keys.Add(key2);
configuration.Keys.Add(key3);
configuration.Keys.Add(key4);
// KernelConfigurationView.Instance.Serialize(path, KernelConfiguration.SectionName, configuration);
}
/// <summary></summary>
/// <param name="configuration"></param>
public InnerConnectionPlugin(KernelConfiguration configuration)
{
this.dictionary = new Dictionary <string, string>();
foreach (KernelConfigurationKey key in configuration.Keys)
{
if (!this.dictionary.ContainsKey(key.Name))
{
this.dictionary.Add(key.Name, key.Value);
}
else
{
this.dictionary[key.Name] = key.Value;
}
}
}
public RequestBenchmark()
{
_ninjectSettings = new NinjectSettings
{
// Disable to reduce memory pressure
ActivationCacheDisabled = true,
LoadExtensions = false
};
_kernelConfiguration = new KernelConfiguration(_ninjectSettings);
_kernel = _kernelConfiguration.BuildReadOnlyKernel();
_service = typeof(MyInstrumentedService);
_target = CreatePropertyTarget(_service);
_constraint = null;
_scopeCallback = null;
_cachePruner = new GarbageCollectionCachePruner(_ninjectSettings);
_pipeline = new Pipeline(Enumerable.Empty <IActivationStrategy>(), new ActivationCache(_cachePruner));
_cache = new Cache(_pipeline, _cachePruner);
_planner = new Planner(Enumerable.Empty <IPlanningStrategy>());
_exceptionFormatter = new ExceptionFormatter();
_emptyParameters = Array.Empty <IParameter>();
_requestParameterWithMixOfShouldInheritSetToTrueAndFalse = new List <IParameter>
{
new ConstructorArgument("foo1", 1, true),
new ConstructorArgument("foo3", 3, true),
new ConstructorArgument("foo3", 3, false),
new ConstructorArgument("foo5", 5, false)
};
_bindingParameterWithMixOfShouldInheritSetToTrueAndFalse = new List <IParameter>
{
new ConstructorArgument("foo1", 1, true),
new ConstructorArgument("foo2", 2, true),
new ConstructorArgument("foo3", 3, false),
new ConstructorArgument("foo4", 4, false),
};
_rootRequestWithoutParameters = CreateRootRequest(_emptyParameters);
_rootRequestWithMixOfShouldInheritSetToTrueAndFalse = CreateRootRequest(_requestParameterWithMixOfShouldInheritSetToTrueAndFalse);
_bindingWithoutParameters = CreateBinding(Array.Empty <IParameter>());
_contextWithoutRequestAndBindingParameters = CreateContext(_rootRequestWithoutParameters, _bindingWithoutParameters);
_bindingWithParameters = CreateBinding(_bindingParameterWithMixOfShouldInheritSetToTrueAndFalse);
_contextWithRequestAndBindingParameters = CreateContext(_rootRequestWithMixOfShouldInheritSetToTrueAndFalse, _bindingWithParameters);
_childRequestWithoutParameters = CreateChildRequest(_contextWithoutRequestAndBindingParameters, _target);
_childRequestWithRequestAndBindingParameters = CreateChildRequest(_contextWithRequestAndBindingParameters, _target);
}
public void BuildReadOnlyKernelShouldCloneBindings()
{
var kernelConfiguration = new KernelConfiguration();
kernelConfiguration.Bind <IWeapon>().To <Shuriken>();
kernelConfiguration.Bind <IWeapon>().To <Sword>();
kernelConfiguration.Bind <ICleric>().To <Monk>();
var readOnlyKernel = kernelConfiguration.BuildReadOnlyKernel();
kernelConfiguration.RemoveBinding(kernelConfiguration.GetBindings(typeof(IWeapon)).First());
kernelConfiguration.Unbind(typeof(ICleric));
Assert.NotNull(readOnlyKernel);
Assert.Equal(2, readOnlyKernel.GetBindings(typeof(IWeapon)).Count());
Assert.Single(readOnlyKernel.GetBindings(typeof(ICleric)));
}
