public XypericoDependencyResolver(IObjectContainer container)
        {
            Container = container;

              //
              //  Register all controller types so the container will be able to resolve them
              //
              Logger.Debug("Dependency resolver scanning for controllers");
              //foreach (Assembly a in AppDomain.CurrentDomain.GetAssemblies())
              foreach (Assembly a in BuildManager.GetReferencedAssemblies())
              {
            try
            {
              Logger.DebugFormat("Scanning assembly {0}", a.FullName);
              foreach (Type controllerType in (from t in a.GetTypes() where typeof(IController).IsAssignableFrom(t) select t))
              {
            Logger.DebugFormat("Adding {0} as a controller", controllerType);
            Container.AddTransientComponent(controllerType, controllerType);
            // OLD: AddComponentLifeStyle(controllerType.ToString(), controllerType, Castle.Core.LifestyleType.Transient);
              }
            }
            catch (ReflectionTypeLoadException ex)
            {
              Logger.Warn(string.Format("Could not load assembly {0}.", a.FullName), ex);
              foreach (Exception ex2 in ex.LoaderExceptions)
            Logger.Warn("Loader exception", ex2);

            }
            catch (Exception ex)
            {
              Logger.Warn(string.Format("Could not load assembly {0}.", a.FullName), ex);
            }
              }
        }

 public static void SetFirstCar(IObjectContainer db)
 {
     Pilot pilot = new Pilot("Rubens Barrichello", 99);
     Car car = new Car("BMW");
     car.Pilot = pilot;
     db.Store(car);
 }

 private static void StoreData(IObjectContainer container, Random rnd)
 {
     for (int i = 0; i < rnd.Next(4096); i++)
     {
         container.Store(new DataObject(rnd));
     }
 }

 private static void StoreOtherPeople(IObjectContainer container)
 {
     for (int i = 0; i < PopulationSize; i++)
     {
         container.Store(new Person("Citizen No " + i));
     }
 }

 public static void RetrieveAllPilots(IObjectContainer db)
 {
     IQuery query = db.Query();
     query.Constrain(typeof(Pilot));
     IObjectSet result = query.Execute();
     ListResult(result);
 }

 private void StoreData(IObjectContainer container)
 {
     container.Store(new Person("Roman","Stoffel")
                         {
                             Address = new Address()
                                           {
                                               City = "Zurich",
                                               Street = "FunStreet"
                                           }
                         });    
     container.Store(new Person("Joe","Cool")
                         {
                             Address = new Address()
                                           {
                                               City = "FunTown",
                                               Street = "Fun Plaza"
                                           }
                         });
     container.Store(new Person("Joanna", "Awesome")
     {
         Address = new Address()
         {
             City = "More Fun Town",
             Street = "Plaza"
         }
     });          
 }

        private void ShowReport(IObjectContainer container)
        {
            // #example: Run a report with db4o
            var dataToShow = from Person p in container
                             where p.FirstName.Contains("o")
                             select p;

            var reportViewer = new ReportViewer
            {
                ProcessingMode = ProcessingMode.Local
            };

            // Put the data into the datasource which you are using
            // in your report. Here it's named 'MainData'
            reportViewer.LocalReport.DataSources.Add(
                new ReportDataSource("MainData", dataToShow));
            reportViewer.Dock = DockStyle.Fill;

            // The report can be an embedded resource
            reportViewer.LocalReport.ReportEmbeddedResource = "Db4oDoc.Code.Reporting.ExampleReport.rdlc";
            // or can be a file
            // reportViewer.LocalReport.ReportPath = "path/to/your/report"; 

            // After that you can use the report viewer in your app
            this.Controls.Add(reportViewer);
            reportViewer.RefreshReport();
            // #end example
        }

		static void ActivateList(IObjectContainer db, IList list)
		{
			foreach (var obj in list)
			{
				db.Activate(obj, int.MaxValue);
			}
		}

        public virtual void RegisterDefaults(IObjectContainer container)
        {
            var serviceProvider = container.Resolve<IServiceProvider>();
            RegisterVsDependencies(container, serviceProvider);

            container.RegisterTypeAs<InstallServices, InstallServices>();
            container.RegisterTypeAs<VsBrowserGuidanceNotificationService, IGuidanceNotificationService>();
            container.RegisterTypeAs<WindowsFileAssociationDetector, IFileAssociationDetector>();
            container.RegisterTypeAs<RegistryStatusAccessor, IStatusAccessor>();

            container.RegisterTypeAs<IntegrationOptionsProvider, IIntegrationOptionsProvider>();
            container.RegisterInstanceAs<IIdeTracer>(VsxHelper.ResolveMefDependency<IVisualStudioTracer>(serviceProvider));
            container.RegisterInstanceAs(VsxHelper.ResolveMefDependency<IProjectScopeFactory>(serviceProvider));

            container.RegisterTypeAs<TestRunnerEngine, ITestRunnerEngine>();
            container.RegisterTypeAs<TestRunnerGatewayProvider, ITestRunnerGatewayProvider>();
            container.RegisterTypeAs<MsTestRunnerGateway, ITestRunnerGateway>(TestRunnerTool.VisualStudio2010MsTest.ToString());
            container.RegisterTypeAs<ReSharper5TestRunnerGateway, ITestRunnerGateway>(TestRunnerTool.ReSharper5.ToString());
            container.RegisterTypeAs<ReSharper6TestRunnerGateway, ITestRunnerGateway>(TestRunnerTool.ReSharper.ToString());
            container.RegisterTypeAs<SpecRunTestRunnerGateway, ITestRunnerGateway>(TestRunnerTool.SpecRun.ToString());
            container.RegisterTypeAs<VS2012RunnerGateway, ITestRunnerGateway>(TestRunnerTool.VisualStudio2012.ToString());
            container.RegisterTypeAs<AutoTestRunnerGateway, ITestRunnerGateway>(TestRunnerTool.Auto.ToString());

            container.RegisterTypeAs<StepDefinitionSkeletonProvider, IStepDefinitionSkeletonProvider>();
            container.RegisterTypeAs<DefaultSkeletonTemplateProvider, ISkeletonTemplateProvider>();
            container.RegisterTypeAs<StepTextAnalyzer, IStepTextAnalyzer>();

            RegisterCommands(container);
        }

        // #end example

        private static void StoreExampleObjects(IObjectContainer container)
        {
            for (int i = 0; i < 100; i++)
            {
                container.Store(new Item(i));
            }
        }

        public static void Setup(IObjectContainer container)
        {
            Chimera.Authentication.Views.MongoDB.Utility.Initialize(container);

              container.AddComponent<INameValueContextCollection, CallContextNamedValueCollection>();
              container.AddComponent<IUserAccountViewBuilder, UserAccountViewBuilder>();
        }

 public FreespaceListener(IObjectContainer container)
 {
     _totalFreespaceCounter = Db4oPerformanceCounters.CounterFor(PerformanceCounterSpec.TotalFreespace, container, false);
     _averageSlotSizeCounter = Db4oPerformanceCounters.CounterFor(PerformanceCounterSpec.FreespaceAverageSlotSize, container, false);
     _freespaceSlotsCounter = Db4oPerformanceCounters.CounterFor(PerformanceCounterSpec.FreespaceSlotCount, container, false);
     _reusedSlotsCounter = Db4oPerformanceCounters.CounterFor(PerformanceCounterSpec.FreespaceReusedSlotsPerSec, container, false);
 }

 public virtual IObjectSet Query(IObjectContainer db)
 {
     var query = db.Query();
     query.Constrain(this);
     query.Descend("_flag").Constrain(true).Not();
     return query.Execute();
 }

 public virtual object OnStore(IObjectContainer container, object applicationObject
     )
 {
     var t = (Thing) applicationObject;
     AddToCache(t);
     return t.name;
 }

 private static IObjectContainer RootContainer()
 {
     lock (sync)
     {
         return database ?? (database = CreateRootContainer());
     }
 }

		public MockMarshallingContext(IObjectContainer objectContainer)
		{
			_objectContainer = objectContainer;
			_header = new ByteArrayBuffer(1000);
			_payLoad = new ByteArrayBuffer(1000);
			_current = _header;
		}

 public static void SetSecondCar(IObjectContainer db)
 {
     Pilot pilot = new Pilot("Michael Schumacher", 100);
     Car car = new Car("Ferrari");
     car.Pilot = pilot;
     db.Store(car);
 }

 public TestRunnerManager(IObjectContainer globalContainer, IContainerBuilder containerBuilder, RuntimeConfiguration runtimeConfiguration, IRuntimeBindingRegistryBuilder bindingRegistryBuilder)
 {
     this.globalContainer = globalContainer;
     this.containerBuilder = containerBuilder;
     this.runtimeConfiguration = runtimeConfiguration;
     this.bindingRegistryBuilder = bindingRegistryBuilder;
 }

        public static void ConfigureContainer(IObjectContainer container, ApplicationConfiguration config)
        {
            if (config == null || config.ContainerConfiguration == null) return;
            if (container == null) return;

            foreach (object item in config.ContainerConfiguration.Items)
            {
                ObjectContainerAdd add = item as ObjectContainerAdd;
                if (item != null)
                {
                    Type tKey = Type.GetType(add.KeyType, true, true);
                    Type tObj = Type.GetType(add.ObjectType, true, true);

                    container.Register(tKey, Activator.CreateInstance(tObj));
                    continue;
                }

                ObjectContainerRemove remove = item as ObjectContainerRemove;
                if (item != null)
                {
                    throw new NotImplementedException("Removing an object is not supported yet.");
                }

                ObjectContainerClear clear = item as ObjectContainerClear;
                if (item != null)
                {
                    container.Clear();
                    continue;
                }
            }
        }

 public Boolean cadastrarStatus(clsStatus objStatus)
 {
     try
     {
         if (!temDuplicidade(objStatus, "Cadastrar"))
         {
             objStatus.Codigo = obtemNovoId(); //Executa a solicitação de um novo id
             db = ServidorSingleton.obterServidor().OpenClient();
             db.Store(objStatus);
             db.Commit();
             return true;
         }
         else {
             return false;
         }
     }
     catch (Exception ex)
     {
         db.Rollback();
         throw new Exception("Erro cadastrando o status :" + ex.ToString());
     }
     finally {
         db.Close();
         db.Dispose();
     }
 }