public void OpenGenericTypes(IContainerAdapter adapter) { adapter.RegisterTransient(typeof(IGenericService <>), typeof(GenericService <>)); var resolved = adapter.Resolve <IGenericService <int> >(); Assert.NotNull(resolved); }
public Result(IContainerAdapter containerAdapter, string name, string version) { Name = name; Version = version; _containerAdapter = containerAdapter; containerAdapter.Prepare(); }
public SettingsTreeView(IContainerAdapter container) { IoCContainer = container; ShowNodeToolTips = true; HideSelection = false; Dock = DockStyle.Fill; }
protected ServiceStackAppHostBase( IContainerAdapter containerAdapter, string serviceName, params Assembly[] assembliesWithServices) : base(serviceName, 50, 5000, assembliesWithServices) { this.containerAdapter = containerAdapter; }
public void RunTest(IContainerAdapter container, Action <IContainerAdapter> actionToBenchmark, int numberOfThreads) { Stopwatch sw = new Stopwatch(); Warmup2(container); var count = 500000 / numberOfThreads; actionToBenchmark(container); // Run once to prepare method var threads = new List <Thread>(); for (int i = 0; i < numberOfThreads; i++) { threads.Add(new Thread(() => { for (var j = 0; j < count; j++) { actionToBenchmark(container); } })); } sw.Start(); threads.ForEach(t => t.Start()); threads.ForEach(t => t.Join()); sw.Stop(); Console.WriteLine(actionToBenchmark.Method.Name + " using " + numberOfThreads + " threads: " + sw.ElapsedMilliseconds); }
public virtual void Warmup(IContainerAdapter container) { this.MethodToBenchmark(container); ScopedCombined1.Instances = 0; ScopedCombined2.Instances = 0; ScopedCombined3.Instances = 0; Complex1.Instances = 0; Complex2.Instances = 0; Complex3.Instances = 0; ImportConditionObject1.Instances = 0; ImportConditionObject2.Instances = 0; ImportConditionObject3.Instances = 0; ImportGeneric <int> .Instances = 0; ImportGeneric <float> .Instances = 0; ImportGeneric <object> .Instances = 0; ImportMultiple1.Instances = 0; ImportMultiple2.Instances = 0; ImportMultiple3.Instances = 0; ComplexPropertyObject1.Instances = 0; ComplexPropertyObject2.Instances = 0; ComplexPropertyObject3.Instances = 0; Calculator1.Instances = 0; Calculator2.Instances = 0; Calculator3.Instances = 0; Combined1.Instances = 0; Combined2.Instances = 0; Combined3.Instances = 0; Singleton1.Instances = 0; Singleton2.Instances = 0; Singleton3.Instances = 0; Transient1.Instances = 0; Transient2.Instances = 0; Transient3.Instances = 0; }
public void PrepareAndRegisterAndSimpleResolve(IContainerAdapter container) { container.PrepareBasic(); container.Resolve(typeof(IBasicService1)); container.Resolve(typeof(ISingleton1)); container.Dispose(); }
public void OpenGenericTypes(IContainerAdapter adapter) { adapter.RegisterTransient(typeof(IGenericService<>), typeof(GenericService<>)); var resolved = adapter.Resolve<IGenericService<int>>(); Assert.NotNull(resolved); }
public AboutMenuItem(IContainerAdapter container, ISPMLocalization local) { IoCContainer = container; Text = local.GetText("Interface_About_Text"); ToolTipText = local.GetText("Interface_About_ToolTip"); Image = global::Keutmann.SharePointManager.Properties.Resources.about; }
public void GetAssemblyScannedAdapter() { IContainerAdapterAccessor adapterAccessor = new ContainerAdapterAccessor(true); IContainerAdapter adapter = adapterAccessor.GetAdapter(TestConstants.AutofacContainerName); Assert.IsNotNull(adapter); }
private static void CheckInstanceProperties(IContainerAdapter container) { if (Singleton.Instances != 1) { throw new Exception("Singleton instance count must be one"); } if (Transient.Instances < (LoopCount * 2) + 1 || Transient.Instances > (LoopCount * 2) + 4) { throw new Exception( string.Format("Transient count must be between {0} and {1} was {2}", (LoopCount * 2) + 1, (LoopCount * 2) + 4, Transient.Instances)); } if (Combined.Instances != LoopCount + 1 && Combined.Instances != LoopCount + 2) { throw new Exception(string.Format("Combined count must be {0} or {1} was {2}", LoopCount + 1, LoopCount + 2, Combined.Instances)); } if (Complex.Instances != LoopCount + 1 && Complex.Instances != LoopCount + 2) { throw new Exception(string.Format("Complex count must be {0} or {1} was {2}", LoopCount + 1, LoopCount + 2, Complex.Instances)); } if (container.SupportsInterception) { if (Calculator.Instances != LoopCount + 1 && Calculator.Instances != LoopCount + 2) { throw new Exception(string.Format("Calculator count must be {0} or {1} was {2}", LoopCount + 1, LoopCount + 2, Calculator.Instances)); } } }
public TreeViewComponent(IContainerAdapter container) { IoCContainer = container; this.ShowNodeToolTips = true; this.HideSelection = false; ViewLevel = 50; }
public static void Initialize(IMongoClient client, IContainerAdapter containerAdapter) { var componentRegistry = new ComponentRegistry(new MongoMigrationSettings(), containerAdapter); componentRegistry.RegisterComponents(client); Initialize(componentRegistry); }
public void Configure(IContainerAdapter containerAdapter) { containerAdapter.Register <IVirtualPathUtilityService, VirtualPathUtilityService>(); //containerAdapter.Register<ILocalState, HttpLocalState>(); //containerAdapter.Register<ICacheState, HttpRuntimeCache>(); //containerAdapter.Register<ISessionState, HttpSessionState>(); }
public SaveAllMenuItem(IContainerAdapter container, ISPMLocalization local) : base(container) { Text = local.GetText("Interface_SaveAll_Text"); ToolTipText = local.GetText("Interface_SaveAll_ToolTip"); Image = global::Keutmann.SharePointManager.Properties.Resources.saveall; }
public AboutMenuItem(IContainerAdapter container, ISPMLocalization local) { IoCContainer = container; Text = local.GetText("Interface_About_Text"); ToolTipText = local.GetText("Interface_About_ToolTip"); Image = global::Keutmann.SharePointManager.Properties.Resources.about; }
//Func<CustomUnitOfWorkSettings, ITransactionManager> getTransactionManager; /// <summary> /// Configures <see cref="UnitOfWorkScope"/> settings. /// </summary> /// <param name="containerAdapter">The <see cref="IContainerAdapter"/> instance.</param> public void Configure(IContainerAdapter containerAdapter) { var settings = new CustomUnitOfWorkSettings() { AutoCompleteScope = _autoCompleteScope, DefaultIsolation = _defaultIsolation }; containerAdapter.RegisterInstance(settings); containerAdapter.RegisterSingleton <IUnityUnitOfWorkManager, UnityUnitOfWorkManager>(); //containerAdapter.RegisterInstance<ITransactionManager>(getTransactionManager(settings)); containerAdapter.RegisterInstance <IUnitOfWorkGuid>(new UnitOfWorkGuid()); containerAdapter.RegisterSingleton <IUnitOfWorkScopeFactory, UnityUnitOfWorkScopeFactory>(); containerAdapter.Register <IUnitOfWorkScope, UnityUnitOfWorkScope>(); //UnitOfWorkSettings.AutoCompleteScope = _autoCompleteScope; //UnitOfWorkSettings.DefaultIsolation = _defaultIsolation; if (_useBusinessTransaction) { containerAdapter.RegisterSingleton <IBusinessTransactionObservable, BusinessTransactionSubjectWrapper>(); containerAdapter.RegisterSingleton <IBusinessTransactionSubscriber, BusinessTransactionSubjectWrapper>(); containerAdapter.RegisterInstance <IBusinessTransactionSubjectFactory>(new BusinessTransactionSubjectFactory(() => new BusinessTransactionSubject())); } else { var subject = new StubTransactionSubject(); containerAdapter.RegisterInstance <IBusinessTransactionObservable>(subject); containerAdapter.RegisterInstance <IBusinessTransactionSubscriber>(subject); containerAdapter.RegisterInstance <IBusinessTransactionSubjectFactory>(new BusinessTransactionSubjectFactory(() => subject)); } //IBusinessTransactionSubject subject = !_useBusinessTransaction? new StubTransactionSubject(): new BusinessTransactionSubjectWrapper(); //containerAdapter.RegisterInstance<IBusinessTransactionSubjectFactory>(new BusinessTransactionSubjectFactory(!_useBusinessTransaction ? () => subject : () => new BusinessTransactionSubject())); }
/// <summary> /// Called by RCommon <see cref="Configure"/> to configure state storage. /// </summary> /// <param name="containerAdapter">The <see cref="IContainerAdapter"/> instance that can be /// used to register state storage components.</param> public void Configure(IContainerAdapter containerAdapter) { if (_customSessionType != null) { containerAdapter.AddTransient(typeof(ISessionState), _customSessionType); } else { containerAdapter.AddTransient <ISessionStateSelector, DefaultSessionStateSelector>(); containerAdapter.AddTransient <ISessionState, SessionStateWrapper>(); } if (_customLocalStateType != null) { containerAdapter.AddTransient(typeof(IContextState), _customLocalStateType); } else { containerAdapter.AddTransient <IContextStateSelector, DefaultContextStateSelector>(); containerAdapter.AddTransient <IContextState, ContextStateWrapper>(); } if (_customApplicationStateType != null) { containerAdapter.AddSingleton(typeof(IApplicationState), _customApplicationStateType); } else { containerAdapter.AddSingleton <IApplicationState, ApplicationState>(); } containerAdapter.AddTransient <IStateStorage, StateStorageWrapper>(); }
public void IndependentServiceRegisteredAsSelf(IContainerAdapter adapter) { adapter.RegisterType<IndependentService>(); var component = adapter.Resolve<IndependentService>(); Assert.NotNull(component); }
public SettingsTreeView(IContainerAdapter container) { IoCContainer = container; ShowNodeToolTips = true; HideSelection = false; Dock = DockStyle.Fill; }
private static Result MeasurePerformance(string name, IContainerAdapter container) { CollectMemory(); container.Prepare(); WarmUp(container); var result = new Result(); result.Name = name; result.Version = container.Version; result.SingletonTime = MeasureSingleton(container); result.TransientTime = MeasureTransient(container); result.CombinedTime = MeasureCombined(container); if (container.SupportsInterception) { result.InterceptionTime = MeasureProxy(container); } result.SingletonInstances = Singleton.Instances; result.TransientInstances = Transient.Instances; result.CombinedInstances = Combined.Instances; result.InterceptionInstances = Calculator.Instances; Singleton.Instances = 0; Transient.Instances = 0; Combined.Instances = 0; Calculator.Instances = 0; container.Dispose(); return result; }
public void PropertyDependencyIsOptional(IContainerAdapter adapter) { adapter.RegisterType <ServiceWithSimplePropertyDependency>(); var component = adapter.Resolve <ServiceWithSimplePropertyDependency>(); Assert.Null(component.Service); }
public void Configure(IContainerAdapter containerAdapter) { // Register all of the domain services with the Dependency Injection Container. containerAdapter.AddTransient <IDiveLocationService, DiveLocationService>(); containerAdapter.AddTransient <IDiveTypeService, DiveTypeService>(); containerAdapter.AddTransient <IUserService, UserService>(); }
public DependencyInjectionFixture() { _container = new PillarDefaultIoc(); _container.RegisterType <IFoo, Foo>(); _container.RegisterType <IBar, Bar>(); }
private static void CheckInstanceProperties(IContainerAdapter container) { if (Singleton.Instances != 1) { throw new Exception("Singleton instance count must be one"); } if (Transient.Instances < (LoopCount * 2) + 1 || Transient.Instances > (LoopCount * 2) + 4) { throw new Exception( string.Format("Transient count must be between {0} and {1} was {2}", (LoopCount * 2) + 1, (LoopCount * 2) + 4, Transient.Instances)); } if (Combined.Instances != LoopCount + 1 && Combined.Instances != LoopCount + 2) { throw new Exception(string.Format("Combined count must be {0} or {1} was {2}", LoopCount + 1, LoopCount + 2, Combined.Instances)); } if (Complex.Instances != LoopCount + 1 && Complex.Instances != LoopCount + 2) { throw new Exception(string.Format("Complex count must be {0} or {1} was {2}", LoopCount + 1, LoopCount + 2, Complex.Instances)); } if (container.SupportsInterception) { if (Calculator.Instances != LoopCount + 1 && Calculator.Instances != LoopCount + 2) { throw new Exception(string.Format("Calculator count must be {0} or {1} was {2}", LoopCount + 1, LoopCount + 2, Calculator.Instances)); } } }
public SaveAllMenuItem(IContainerAdapter container, ISPMLocalization local) : base(container) { Text = local.GetText("Interface_SaveAll_Text"); ToolTipText = local.GetText("Interface_SaveAll_ToolTip"); Image = global::Keutmann.SharePointManager.Properties.Resources.saveall; }
private static Result MeasurePerformance(string name, IContainerAdapter container) { ClearInstanceProperties(); CollectMemory(); container.Prepare(); WarmUp(container); var result = new Result(); result.Name = name; result.Version = container.Version; MeasureResolvePerformance(container, result); if (container.SupportsInterception) { result.InterceptionTime = MeasureProxy(container); } CheckInstanceProperties(container); container.Dispose(); return(result); }
private void PopulateAdaptersInAssembly(Assembly assembly) { IEnumerable <Type> potentialAdapters; try { potentialAdapters = assembly.GetTypes().Where(IsPotentialAdapter); } catch { return; } foreach (Type potentialAdapter in potentialAdapters) { ConstructorInfo constructor = potentialAdapter.GetConstructor(Type.EmptyTypes); if (potentialAdapter.IsAbstract || constructor == null) { continue; } IContainerAdapter adapter = Activator.CreateInstance(potentialAdapter) as IContainerAdapter; if (adapter == null || !adapter.AllowSelfRegistration) { continue; } AddAdapter(adapter.Name, adapter); } }
public TreeViewComponent(IContainerAdapter container) { IoCContainer = container; this.ShowNodeToolTips = true; this.HideSelection = false; ViewLevel = 50; }
public void PropertyDependencyIsOptional(IContainerAdapter adapter) { adapter.RegisterType<ServiceWithSimplePropertyDependency>(); var component = adapter.Resolve<ServiceWithSimplePropertyDependency>(); Assert.Null(component.Service); }
public BenchmarkRunner(IContainerAdapter container, IBenchmark benchmark) { this.container = container; this.benchmark = benchmark; this.singlethreadedMeasurer = new SinglethreadedBenchmarkMeasurer(container, benchmark); this.multithreadedMeasurer = new MultithreadedBenchmarkMeasurer(container, benchmark); }
private static void MeasurePerformance(string name, IContainerAdapter container) { CollectMemory(); container.Prepare(); WarmUp(container); long singletonTime = MeasureSingleton(container); long transientTime = MeasureTransient(container); long combinedTime = MeasureCombined(container); Console.WriteLine(string.Format( "{0}\t{1}\t\t{2}\t\t{3}\t\t{4}\t\t\t{5}\t\t\t\t{6}", name + " ".Substring(name.Length - 1), singletonTime, transientTime, combinedTime, Singleton.Instances, Transient.Instances, Combined.Instances)); Singleton.Instances = 0; Transient.Instances = 0; Combined.Instances = 0; container.Dispose(); }
public override void MethodToBenchmark(IContainerAdapter container) { container.PrepareBasic(); container.Resolve(typeof(IDummyOne)); container.Resolve(typeof(ISingleton1)); container.Dispose(); }
IBus CreateBus(string serviceName, IContainerAdapter containerAdapter) { var sagaCollectionName = serviceName + ".sagas"; var subscriptionsCollectionName = "rebus.subscriptions"; DropCollection(sagaCollectionName); DropCollection(subscriptionsCollectionName); var inputQueueName = GetEndpoint(serviceName); var queue = messageQueueFactory.GetQueue(inputQueueName); var sagaPersister = new MongoDbSagaPersister(ConnectionString) .SetCollectionName <CheckCreditSagaData>("check_credit_sagas") .SetCollectionName <CheckSomeLegalStuffSagaData>("check_legal_sagas") .SetCollectionName <CustomerInformationSagaData>("customer_information_sagas"); var bus = new RebusBus(containerAdapter, queue.Item1, queue.Item2, new MongoDbSubscriptionStorage(ConnectionString, subscriptionsCollectionName), sagaPersister, this, new JsonMessageSerializer(), new TrivialPipelineInspector(), new ErrorTracker("error")); stuffToDispose.Add(bus); containerAdapter.RegisterInstance(bus, typeof(IBus)); return(bus.Start(5)); }
public BenchmarkRunner(IContainerAdapter container, IBenchmark benchmark) { this.container = container; this.benchmark = benchmark; this.singlethreadedMeasurer = new SinglethreadedBenchmarkMeasurer(container, benchmark); this.multithreadedMeasurer = new MultithreadedBenchmarkMeasurer(container, benchmark); }
public void IndependentServiceRegisteredAsSelf(IContainerAdapter adapter) { adapter.RegisterType <IndependentService>(); var component = adapter.Resolve <IndependentService>(); Assert.NotNull(component); }
public MainMenuStrip(IContainerAdapter container) { this.TabIndex = 0; var items = container.ResolveBind<IMenuItem>(this.GetType()); this.Items.AddRange(items.Cast<ToolStripItem>().ToArray()); }
public SPNodeProvider(SPFarm farm, IEnumerable <IRule <ISPNode> > rules, IContainerAdapter container) { ViewLevel = 100; Farm = farm; IoCContainer = container; _ruleEngine = new FirstAcceptRuleEngine <ISPNode>(rules); }
public void PropertyDependencyDoesNotNeedCustomAttribute(IContainerAdapter adapter) { var property = typeof(ServiceWithSimplePropertyDependency).GetProperty("Service"); var attributes = property.GetCustomAttributes(false); var attributesFromThisFramework = attributes.Where(a => a.GetType().Assembly == adapter.Assembly); Assert.Empty(attributesFromThisFramework); }
public void TransientLifetime(IContainerAdapter adapter) { adapter.RegisterTransient <IService, IndependentService>(); var instance1 = adapter.Resolve <IService>(); var instance2 = adapter.Resolve <IService>(); Assert.NotSame(instance1, instance2); }
public SPNodeProvider(SPFarm farm, IEnumerable<IRule<ISPNode>> rules, IContainerAdapter container) { ViewLevel = 100; Farm = farm; IoCContainer = container; _ruleEngine = new FirstAcceptRuleEngine<ISPNode>(rules); }
public void SingletonLifetime(IContainerAdapter adapter) { adapter.RegisterSingleton <IService, IndependentService>(); var instance1 = adapter.Resolve <IService>(); var instance2 = adapter.Resolve <IService>(); Assert.Same(instance1, instance2); }
protected override void DoSetUp() { SomeDisposable.Reset(); Console.WriteLine("Running setup for {0}", typeof(TFactory)); factory = new TFactory(); adapter = factory.Create(); RebusLoggerFactory.Current = new ConsoleLoggerFactory(false); }
public void LoadModel(IContainerAdapter container) { Model = new MenuItemViewModel(container, this.GetType()); if (Model.Items != null && Model.Items.Count() > 0) { this.DropDownItems.AddRange(Model.Items.Cast <ToolStripItem>().ToArray()); } }
public void PropertyDependencyDoesNotNeedCustomAttribute(IContainerAdapter adapter) { var property = typeof(ServiceWithSimplePropertyDependency).GetProperty("Service"); var attributes = property.GetCustomAttributes(false); var attributesFromThisFramework = attributes.Where(a => a.GetType().Assembly == adapter.Assembly); Assert.Empty(attributesFromThisFramework); }
public void SingletonLifetime(IContainerAdapter adapter) { adapter.RegisterSingleton<IService, IndependentService>(); var instance1 = adapter.Resolve<IService>(); var instance2 = adapter.Resolve<IService>(); Assert.Same(instance1, instance2); }
public void PrebuiltInstance(IContainerAdapter adapter) { var instance = new IndependentService(); adapter.RegisterInstance<IService>(instance); var resolved = adapter.Resolve<IService>(); Assert.Same(instance, resolved); }
public void MissingPrimitive(IContainerAdapter adapter) { adapter.RegisterType<IService, IndependentService>(); adapter.RegisterType<ServiceWithDependencyAndOptionalInt32Parameter>(); var component = adapter.Resolve<ServiceWithDependencyAndOptionalInt32Parameter>(); Assert.NotNull(component); }
public void MissingPrimitiveDefaultValue(IContainerAdapter adapter) { adapter.RegisterType<IService, IndependentService>(); adapter.RegisterType<ServiceWithDependencyAndOptionalInt32Parameter>(); var component = adapter.Resolve<ServiceWithDependencyAndOptionalInt32Parameter>(); Assert.Equal(5, component.Optional); }
public void ConstrainsForOpenGenerics(IContainerAdapter adapter) { adapter.RegisterTransient(typeof(IGenericService<>), typeof(GenericService<>)); adapter.RegisterTransient(typeof(IGenericService<>), typeof(GenericServiceWithIService2Constraint<>)); var resolved = adapter.ResolveAll<IGenericService<IndependentService>>().ToArray(); Assert.Equal(1, resolved.Length); Assert.IsType<GenericService<IndependentService>>(resolved[0]); }
public MainWindow(IContainerAdapter container) { Text = SPMEnvironment.Version.Title; IoCContainer = container; InitializeComponent(); Shown += MainWindow_Shown; Load +=new EventHandler(MainWindow_Load); }
public TimerServiceValidator(IContainerAdapter container) : base() { IoCContainer = container; this.QuestionString = "The application needs to run on a frontend server with SharePoint Foundation installed"; this.SuccessString = "Microsoft SharePoint Timer Service found"; this.ErrorString = "Microsoft SharePoint Timer Service missing"; }
/// <summary> /// Adds an adapter for serving /// </summary> /// <param name="key">The adapter key</param> /// <param name="adapter">The adapter</param> public void AddAdapter(string key, IContainerAdapter adapter) { if (adapters.ContainsKey(key)) { throw new InvalidDataException("An adapter has already been registered with this key"); } adapters.Add(key, adapter); }
public void NotCreatingLazyPrematurely(IContainerAdapter adapter) { adapter.RegisterType<IService, IndependentService>(); adapter.RegisterType<ServiceWithSimpleConstructorDependency>(); var lazy = adapter.Resolve<Lazy<ServiceWithSimpleConstructorDependency>>(); Assert.NotNull(lazy); Assert.False(lazy.IsValueCreated); }
public void BasicLazySupport(IContainerAdapter adapter) { adapter.RegisterType<IService, IndependentService>(); adapter.RegisterType<ServiceWithSimpleConstructorDependency>(); var lazy = adapter.Resolve<Lazy<ServiceWithSimpleConstructorDependency>>(); Assert.NotNull(lazy); Assert.NotNull(lazy.Value); }
public void ComponentIsDisposedAtTheEndOfRequest(IContainerAdapter adapter) { adapter.RegisterPerWebRequest<DisposableService>(); BeginRequest(adapter); var service = adapter.Resolve<DisposableService>(); EndRequest(adapter); Assert.True(service.Disposed); }
public override void MethodToBenchmark(IContainerAdapter container) { var result1 = (ICalculator1)container.Resolve(typeof(ICalculator1)); var result2 = (ICalculator2)container.Resolve(typeof(ICalculator2)); var result3 = (ICalculator3)container.Resolve(typeof(ICalculator3)); result1.Add(5, 10); result2.Add(5, 10); result3.Add(5, 10); }
public void ConstructorDependency(IContainerAdapter adapter) { adapter.RegisterType<IService, IndependentService>(); adapter.RegisterType<ServiceWithSimpleConstructorDependency>(); var component = adapter.Resolve<ServiceWithSimpleConstructorDependency>(); Assert.NotNull(component.Service); Assert.IsAssignableFrom<IndependentService>(component.Service); }
public void ConstructorDependencyUsingInstance(IContainerAdapter adapter) { var instance = new IndependentService(); adapter.RegisterInstance<IService>(instance); adapter.RegisterType<ServiceWithSimpleConstructorDependency>(); var dependent = adapter.Resolve<ServiceWithSimpleConstructorDependency>(); Assert.Same(instance, dependent.Service); }