public static void Init(IControllerFactory controllerFactory)
 {
     if (instance == null)
     {
         instance = new Localization(controllerFactory);
     }
 }

        public ControllerActionInvoker(
            [NotNull] ActionContext actionContext,
            [NotNull] IReadOnlyList<IFilterProvider> filterProviders,
            [NotNull] IControllerFactory controllerFactory,
            [NotNull] ControllerActionDescriptor descriptor,
            [NotNull] IInputFormattersProvider inputFormatterProvider,
            [NotNull] IControllerActionArgumentBinder controllerActionArgumentBinder,
            [NotNull] IModelBinderProvider modelBinderProvider,
            [NotNull] IModelValidatorProviderProvider modelValidatorProviderProvider,
            [NotNull] IValueProviderFactoryProvider valueProviderFactoryProvider,
            [NotNull] IScopedInstance<ActionBindingContext> actionBindingContextAccessor,
            [NotNull] ITempDataDictionary tempData)
            : base(
                  actionContext, 
                  filterProviders,
                  inputFormatterProvider, 
                  modelBinderProvider, 
                  modelValidatorProviderProvider, 
                  valueProviderFactoryProvider,
                  actionBindingContextAccessor)
        {
            _descriptor = descriptor;
            _controllerFactory = controllerFactory;
            _argumentBinder = controllerActionArgumentBinder;
            _tempData = tempData;

            if (descriptor.MethodInfo == null)
            {
                throw new ArgumentException(
                    Resources.FormatPropertyOfTypeCannotBeNull("MethodInfo",
                                                               typeof(ControllerActionDescriptor)),
                    "descriptor");
            }
        }

		/// <summary>
		/// Contructor generally used for unit testing
		/// </summary>
		/// <param name="controllerFactory"></param>
		/// <param name="umbracoContext"></param>
		internal RenderRouteHandler(IControllerFactory controllerFactory, UmbracoContext umbracoContext)
		{
			if (controllerFactory == null) throw new ArgumentNullException("controllerFactory");
			if (umbracoContext == null) throw new ArgumentNullException("umbracoContext");
			_controllerFactory = controllerFactory;
			_umbracoContext = umbracoContext;
		}

        public Func<IRequest, IArguments, Context, object> BuildExecuteFunc(MethodInfo methodInfo, IControllerFactory controllerFactory, IBinderFactory binderFactory)
        {
            var parameters = methodInfo.GetParameters();
            var localVars = new List<ParameterExpression>();
            var typedVars = new Dictionary<int, ParameterExpression>();
            var paramVars = new List< ParameterExpression>();
            var codeExprs = new List<Expression>();
            foreach (ParameterInfo paramInfo in parameters) {
               // BuildAssign
            }

            var getControllerInstance = Expression.Call(Expression.Constant(controllerFactory), GetOrCreateFactoryMethodInfo);
            var callAction = Expression.Call(getControllerInstance, methodInfo, paramVars);

            var labelTarget = Expression.Label(typeof(object));
            var returnValueExpr = Expression.Convert(callAction, typeof(object));
            var retExpr = Expression.Return(labelTarget, returnValueExpr);
            var labelExpr = Expression.Label(labelTarget, Expression.Constant(null,typeof(object)));
            codeExprs.Add(retExpr);
            codeExprs.Add(labelExpr);

            Expression block = Expression.Block(localVars,codeExprs);
            if (block.CanReduce)
            {
                block = block.ReduceAndCheck();
            }
            var lamda = Expression.Lambda<Func<IRequest, IArguments, Context,object>>(block);

            var result = lamda.Compile();
            return result;
        }

        public MvcDynamicSessionControllerFactory(IControllerFactory originalFactory) {
            if (originalFactory == null) {
                throw new ArgumentNullException("originalFactory");
            }

            _originalFactory = originalFactory;
        }

        public void SetControllerFactory(IControllerFactory controllerFactory) {
            if (controllerFactory == null) {
                throw new ArgumentNullException("controllerFactory");
            }

            _factoryThunk = () => controllerFactory;
        }

 public void SetControllerFactory(IControllerFactory controllerFactory)
 {
     FactoryThunk += delegate()
     {
         return controllerFactory;
     };
 }

        void ConfigureRegistrar(IControllerFactory factory, IControllerFactoryProcessor processor)
        {
            var r = new ControllerRegistrar(processor, factory);
            r.Add(new ReflectionControllerRegistrar());

            _registrar = r;
        }

        public DefaultMvcHandler(IControllerFactory controllerFactory, IViewEngine viewEngine)
        {
            Requires.NotNull(controllerFactory, "controllerFactory");
            Requires.NotNull(viewEngine, "viewEngine");

            _controllerFactory = controllerFactory;
            ViewEngineManager.Current.Add(viewEngine);
        }

 public ModoAdministrador(IControllerFactory pFactory)
 {
     this.iContFactory = pFactory;
     this.iFactory = new AdminModePagesFactory(this.iContFactory);
         
     InitializeComponent();
     this.Load += ModoAdministrador_Load;
 }

 public ReflectedActionInvokerProvider(IControllerFactory controllerFactory,
                                       IActionBindingContextProvider bindingProvider,
                                       INestedProviderManager<FilterProviderContext> filterProvider)
 {
     _controllerFactory = controllerFactory;
     _bindingProvider = bindingProvider;
     _filterProvider = filterProvider;
 }

 public RenderRouteHandler(IControllerFactory controllerFactory, 
     IRebelApplicationContext applicationContext, 
     IRenderModelFactory modelFactory)
 {
     _modelFactory = modelFactory;
     _applicationContext = applicationContext;
     _controllerFactory = controllerFactory;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="ControllerRouteCatalog"/> class.
 /// </summary>
 /// <param name="controllerFactory">The controller factory.</param>
 /// <param name="viewActivator">The view activator that is used to instantiate views.</param>
 public ControllerRouteCatalog(IControllerFactory controllerFactory, IViewActivator viewActivator)
 {
     Guard.ArgumentNotNull(controllerFactory, "controllerFactory");
     this.controllerFactory = controllerFactory;
     viewEngines = Framework.ViewEngines.CreateDefaults(viewActivator);
     modelBinders = Framework.ModelBinders.CreateDefaults();
     handler = new ControllerRouteHandler(this.controllerFactory, viewEngines, modelBinders);
 }

 public TypeLoader(
 IControllerFactory controllerFactory,
 ISubjectFactory subjectFactory,
 IIntrospectionPresenter introspectionPresenter)
     : base(introspectionPresenter)
 {
     _controllerFactory = controllerFactory;
       _subjectFactory = subjectFactory;
 }

 public SinkApplicationContext(
     IFileWatcherService fileWatcherService,
     IControllerFactory controllerFactory,
     ISinkApplicationSettings applicationSettings)
 {
     _controllerFactory = controllerFactory;
     _applicationSettings = applicationSettings;
     FileWatcherService = fileWatcherService;
 }

 public void ProcessInit(out IControllerFactory controllerFactory,out IController controller,ControllerContext controllerContext)
 {
     //Instanciate controllerFactory
     string controllerName = controllerContext.RequestContext.RouteData.GetRequiredString("Controller");
     controllerFactory = new DefaultControllerFactory(); //又他么写死了。
     controller = controllerFactory.CreateController(controllerName);
     controllerContext.Controller = controller as Controller;
     //关于这边的写法，我认为controllerContext不应该属于defaultcontrollerfactory，而应该只是作为外界传进去的一个参数，所以不应该把controllerContext作为工厂的一个属性或者变量存在。
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="ControllerFactoryWrapper"/> class that wraps the specified controller factory.
        /// </summary>
        /// <param name="controllerFactory">The controller factory to wrap.</param>
        /// <exception cref="ArgumentNullException"><paramref name="controllerFactory"/> is <c>null</c>.</exception>
        public ControllerFactoryWrapper(IControllerFactory controllerFactory)
        {
            if (controllerFactory == null)
            {
                throw new ArgumentNullException("controllerFactory");
            }

            this.mControllerFactory = controllerFactory;
        }

        Controller INavigationResult.GetController(IControllerFactory controllerFactory, Stack<Controller> controllerHistory)
        {
            if (controllerHistory.Count > 0)
            {
                return controllerHistory.Pop();
            }

            return null;
        }

        public ServerEventsProcessor(IControllerFactory controllerFactory)
        {
            if (controllerFactory == null)
                throw new ArgumentNullException("controllerFactory");

            this.controllerFactory = controllerFactory;

            this.OperatorProcessor = new OperatorProcessor(this.controllerFactory);
            this.ChatProcessor = new ChatProcessor(this.controllerFactory);
        }

        public void ProxyControllerFactory(ExecutionInspector sut, IInspectorContext context, IControllerFactory controllerFactory)
        {
            context.ProxyFactory.Setup(f => f.IsWrapInterfaceEligible<IControllerFactory>(It.IsAny<Type>())).Returns(true);
            context.ProxyFactory.Setup(f => f.WrapInterface(It.IsAny<IControllerFactory>(), It.IsAny<IEnumerable<IAlternateMethod>>(), Enumerable.Empty<object>())).Returns(controllerFactory);

            sut.Setup(context);

            Assert.Equal(ControllerBuilder.Current.GetControllerFactory(), controllerFactory);
            context.Logger.Verify(l => l.Debug(It.Is<string>(s => s.Contains("IControllerFactory")), It.IsAny<object[]>()));
        }