public Result(IContainerAdapter containerAdapter, string name, string version)
 {
     Name = name;
     Version = version;
     _containerAdapter = containerAdapter;
     containerAdapter.Prepare();
 }

 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 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;
 }

        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();
        }

        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));
                }
            }
        }

        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 SettingsTreeView(IContainerAdapter container)
 {
     IoCContainer = container;
     ShowNodeToolTips = true;
     HideSelection = false;
     Dock = DockStyle.Fill;
 }

 public TreeViewComponent(IContainerAdapter container)
 {
     IoCContainer = container;
     this.ShowNodeToolTips = true;
     this.HideSelection = false;
     ViewLevel = 50;
 }

 public override void MethodToBenchmark(IContainerAdapter container)
 {
     container.PrepareBasic();
     container.Resolve(typeof(IDummyOne));
     container.Resolve(typeof(ISingleton1));
     container.Dispose();
 }

 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 void PropertyDependencyIsOptional(IContainerAdapter adapter)
        {
            adapter.RegisterType<ServiceWithSimplePropertyDependency>();
            var component = adapter.Resolve<ServiceWithSimplePropertyDependency>();

            Assert.Null(component.Service);
        }

        public void OpenGenericTypes(IContainerAdapter adapter)
        {
            adapter.RegisterTransient(typeof(IGenericService<>), typeof(GenericService<>));
            var resolved = adapter.Resolve<IGenericService<int>>();

            Assert.NotNull(resolved);
        }

        public SPNodeProvider(SPFarm farm, IEnumerable<IRule<ISPNode>> rules, IContainerAdapter container)
        {
            ViewLevel = 100;
            Farm = farm;
            IoCContainer = container;

            _ruleEngine = new FirstAcceptRuleEngine<ISPNode>(rules);
        }

        public MainMenuStrip(IContainerAdapter container)
        {
            this.TabIndex = 0;

            var items = container.ResolveBind<IMenuItem>(this.GetType());

            this.Items.AddRange(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);
        }

        /// <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 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";
        }

        public void MissingPrimitive(IContainerAdapter adapter)
        {
            adapter.RegisterType<IService, IndependentService>();
            adapter.RegisterType<ServiceWithDependencyAndOptionalInt32Parameter>();

            var component = adapter.Resolve<ServiceWithDependencyAndOptionalInt32Parameter>();

            Assert.NotNull(component);
        }