//private readonly IRepositoryBulkReader BulkReader;
		//private readonly Lazy<World>[] LazyWorlds = new Lazy<World>[512];

		public Context(IObjectFactory factory, IDatabaseQueryManager manager)
		{
			var scope = factory.CreateScope(null);
			scope.RegisterInterfaces(manager.StartQuery(false));
			WorldRepository = scope.Resolve<IPersistableRepository<World>>();
			FortuneRepository = scope.Resolve<IQueryableRepository<Fortune>>();
			//BulkReader = scope.BulkRead(ChunkedMemoryStream.Static());
		}

		public PollAnswerViewModel(IPoll poll,
			IObjectFactory<IPollOption> objectFactory, short optionPosition)
		{
			this.poll = poll;
			this.objectFactory = objectFactory;
			this.optionPosition = optionPosition;
		}

        public void Initialize(IObjectFactory factory)
        {
            if (!LogCommands)
                return;
            factory.RegisterTypes(new[] { typeof(ProcessingCommandsIntercepter), typeof(RestCommandsIntercepter) });
            var processingInterceptor = factory.Resolve<ProcessingCommandsIntercepter>();
            var restInterceptor = factory.Resolve<RestCommandsIntercepter>();
            var aspectRegistrator = factory.Resolve<IAspectRegistrator>();

            var tpe = typeof(IProcessingEngine);
            var tcc = typeof(ICommandConverter);
            var tre = typeof(IRestApplication);
            aspectRegistrator.Before(
                tpe,
                tpe.GetMethod("Execute"),
                (e, args) => processingInterceptor.LogCommands((dynamic)(args[0])));
            aspectRegistrator.Around(
                tcc,
                tcc.GetMethod("PassThrough"),
                (e, args, baseCall) => restInterceptor.PassThrough(args, baseCall));
            aspectRegistrator.Around<IRestApplication, Stream>(
                r => r.Get(),
                restInterceptor.Get);
            aspectRegistrator.Around<IRestApplication, Stream, Stream>(
                r => r.Post(null),
                (_, s, bc) => restInterceptor.Post(s, bc));
        }

 public DefaultActivator(IObjectFactory objectFactory, IServiceDependencyInspector serviceDependencyInspector, IServiceEntryResolver serviceEntryResolver, ServiceEntry entry)
 {
     _objectFactory = objectFactory;
       _serviceEntryResolver = serviceEntryResolver;
       _serviceDependencyInspector = serviceDependencyInspector;
       _entry = entry;
 }

 public virtual void Initialize([NotNull] Type interfaceType, IObjectFactory objectFactory)
 {
     Assert.ArgumentNotNull(interfaceType, "interfaceType");
       Assert.ArgumentNotNull(objectFactory, "objectFactory");
       this.InterfaceType = interfaceType;
       this.ObjectFactory = objectFactory;
 }

 public SecurityApplicationProcessingRule(ISecurityAuthorizationProvider securityAuthorizationProvider, IGenericRepository genericRepository, ISecurityContext securityContext, IObjectFactory objectFactory)
 {
     _securityAuthorizationProvider = securityAuthorizationProvider;
     _genericRepository = genericRepository;
     _securityContext = securityContext;
     _objectFactory = objectFactory;
 }

        public DomainModel(
            IEnumerable<Assembly> assemblies,
            IObjectFactory objectFactory)
        {
            Contract.Requires(assemblies != null);
            Contract.Requires(objectFactory != null);

            DomainAssemblies = assemblies.ToList();

            try
            {
                foreach (var asm in assemblies)
                    foreach (var type in asm.GetTypes())
                        if (typeof(ISystemAspect).IsAssignableFrom(type))
                        {
                            var aspect = (ISystemAspect)Activator.CreateInstance(type);
                            aspect.Initialize(objectFactory);
                        }
            }
            catch (ReflectionTypeLoadException ex)
            {
                var first = (ex.LoaderExceptions ?? new Exception[0]).Take(5).ToList();
                throw new ApplicationException(string.Format(@"Can't load types:
            {0}
            ", string.Join(Environment.NewLine, first.Select(it => it.Message))), ex);
            }
        }

 public static IDomainModel Start(IObjectFactory factory)
 {
     var init = factory.Resolve<SystemInitialization>();
     init.Initialize(false);
     //TODO change domain model boot. export to ISystemAspect to avoid explicit initialization
     return factory.Resolve<IDomainModel>();
 }

        public PatientDetailViewController(IObjectFactory objectFactory)
		{
		    this.ObjectFactory = objectFactory;
		    this.PatientManager = this.ObjectFactory.Create<IPatientManager>();
			
			this.navBar = new UINavigationBar(new RectangleF(0,0,768, 44));
            this.navBar.AutoresizingMask = UIViewAutoresizing.FlexibleWidth;
			this.navBar.SetItems(
                new[]
                {
                    new UINavigationItem("Patient Information")
                },false);
			
            this.navBar.TopItem.SetRightBarButtonItem(this.EditButtonItem, false);
			this.View.BackgroundColor = UIColor.LightGray;
			this.View.Frame = new RectangleF(0,0,768,768);

            this.patientDetailView = this.ObjectFactory.Create<PatientDetailView>();
			this.patientDetailView.Frame = new RectangleF(0,44,this.colWidth1 + this.colWidth2, 728);
			this.patientDetailView.AutoresizingMask = UIViewAutoresizing.FlexibleHeight;

		
			this.View.AddSubview (this.patientDetailView);
			this.View.AddSubview (this.navBar);
		}

        public ISession CreateSession(IDictionary<string, string> parameters, IObjectFactory objectFactory, AbstractAuthenticationProvider authenticationProvider, ICache cache)
        {
            Session session = new Session(parameters, objectFactory, authenticationProvider, cache);
            session.Connect();

            return session;
        }

 public ScopePool(
     IObjectFactory factory,
     IDatabaseQueryManager queries,
     IExtensibilityProvider extensibilityProvider)
 {
     this.Factory = factory;
     this.Queries = queries;
     if (!int.TryParse(ConfigurationManager.AppSettings["Processing.PoolSize"], out Size))
         Size = 20;
     if (!Enum.TryParse<PoolMode>(ConfigurationManager.AppSettings["Processing.PoolMode"], out Mode))
     {
         //TODO: Mono has issues with BlockingCollection. use None as default
         int p = (int)Environment.OSVersion.Platform;
         if (p == 4 || p == 6 || p == 128)
             Mode = PoolMode.None;
         else
             Mode = PoolMode.IfAvailable;
     }
     var commandTypes = extensibilityProvider.FindPlugins<IServerCommand>();
     Factory.RegisterTypes(commandTypes, InstanceScope.Context);
     if (Mode != PoolMode.None)
     {
         if (Size < 1) Size = 1;
         for (int i = 0; i < Size; i++)
             Scopes.Add(SetupReadonlyScope());
     }
 }

        public DeployDependenciesTask(
      string projectName,
      string targetEnvironment,
      Guid deploymentId,
      IProjectInfoRepository projectInfoRepository,
      IObjectFactory objectFactory,
      ITeamCityRestClient temCityRestClient,
      IDependentProjectsToDeployWebSelector dependentProjectsToDeploySelector)
        {
            Guard.NotNullNorEmpty(projectName, "projectName");
              Guard.NotNullNorEmpty(targetEnvironment, "targetEnvironment");
              Guard.NotEmpty(deploymentId, "deploymentId");
              Guard.NotNull(projectInfoRepository, "projectInfoRepository");
              Guard.NotNull(objectFactory, "objectFactory");
              Guard.NotNull(temCityRestClient, "temCityRestClient");
              Guard.NotNull(dependentProjectsToDeploySelector, "dependentProjectsToDeploySelector");

              _projectName = projectName;
              _targetEnvironment = targetEnvironment;
              _deploymentId = deploymentId;
              _projectInfoRepository = projectInfoRepository;
              _objectFactory = objectFactory;
              _temCityRestClient = temCityRestClient;
              _dependentProjectsToDeploySelector = dependentProjectsToDeploySelector;

              _subTasks = new List<DeploymentTaskBase>();
        }

        private static void RunGlobalManagers(IObjectFactory objectFactory)
        {
            // run market manager.
            objectFactory.GetMarketManager();

            // start pool manager.
            objectFactory.GetPoolManager();

            // run algorithm manager.
            objectFactory.GetAlgorithmManager();

            // run payment manager
            objectFactory.GetPaymentDaemonManager();

            // run statistics manager.
            objectFactory.GetStatisticsManager();

            // run software repository.
            objectFactory.GetSoftwareRepository();

#if DEBUG
            // only initialize metrics support in debug mode
            objectFactory.GetMetricsManager();
#endif

            // start web server.
            objectFactory.GetWebServer();
        }

		public PollResultsPageViewModel(
			INavigation navigation,
			IObjectFactory<IPollResults> objectFactory,
			IObjectFactory<IPoll> pollFactory,
			IObjectFactory<IPollComment> pollCommentFactory,
			IMessageBox messageBox
#if NETFX_CORE
			, IShareManager shareManager,
			ISecondaryPinner secondaryPinner
#endif // NETFX_CORE
			)
			: base(navigation)
		{
			this.objectFactory = objectFactory;
			this.pollFactory = pollFactory;
			this.pollCommentFactory = pollCommentFactory;
			this.messageBox = messageBox;

			this.PollComments = new ObservableCollection<PollCommentViewModel>();

#if NETFX_CORE
			this.shareManager = shareManager;
			this.secondaryPinner = secondaryPinner;
#endif // NETFX_CORE
		}

		public AGSUIFactory(IContainer resolver, IGameState gameState, IGraphicsFactory graphics, IObjectFactory obj)
		{
			_resolver = resolver;
			_gameState = gameState;
			_graphics = graphics;
			_object = obj;
		}

        public AlgorithmManager(IPoolManager poolManager, IObjectFactory objectFactory)
        {
            _storage = new List<IHashAlgorithmStatistics>();

            // add algorithms
            foreach (var pool in poolManager.GetAll())
            {
                var query = _storage.FirstOrDefault(x => x.Name == pool.Config.Coin.Algorithm);

                if (query != null)
                    continue;

                var statistics = objectFactory.GetHashAlgorithmStatistics(pool.Config.Coin.Algorithm);

                _storage.Add(statistics);
            }

            // assign pools to hash algorithms
            foreach (var item in _storage)
            {
                var algorithm = item;
                var pools = poolManager.GetAll().Where(p => p.Config.Coin.Algorithm == algorithm.Name);
                algorithm.AssignPools(pools);
            }
        }

		public AGSDialogFactory(IContainer resolver, IGameState gameState, IUIFactory ui, IObjectFactory obj)
		{
			_resolver = resolver;
			_gameState = gameState;
			_ui = ui;
			_object = obj;
		}

        public virtual Type BuildProxyType(IObjectFactory objectFactory)
        {
            Type proxyType = null;
            if (useServiceProxyTypeCache)
            {
                lock (s_serviceTypeCache)
                {
                    proxyType = (Type)s_serviceTypeCache[this.Name];
                    if (proxyType == null)
                    {
                        proxyType = BuildProxyType();
                        s_serviceTypeCache[this.Name] = proxyType;
                    }
                }
            }
            else
            {
                proxyType = BuildProxyType();
            }

            FieldInfo field = proxyType.GetField("__objectFactory", BindingFlags.NonPublic | BindingFlags.Static);
            field.SetValue(proxyType, objectFactory);

            return proxyType;
        }

 public DefaultBuddyBuilder(IImManagerInternal imManager, IObjectFactory objectFactory)
 {
     Helper.GuardNotNull(imManager);
     Helper.GuardNotNull(objectFactory);
     _imManager = imManager;
     _objectFactory = objectFactory;
 }

		public PollsPageViewModel(
			INavigation navigation,
			IObjectFactory<IPollSearchResults> objectFactory)
			: base(navigation)
		{
			this.objectFactory = objectFactory;
			this.SearchOptions = new ObservableCollection<PollSearchOptionViewModel>();
		}