protected internal virtual IAsyncResult BeginProcessRequest(HttpContextBase httpContext, AsyncCallback callback, object state)
{
  IController controller;
  IControllerFactory factory;
  ProcessRequestInit(httpContext, out controller, out factory);
 
  //其它操作
  //调用 controller.Execute方法
}
 
private void ProcessRequestInit(HttpContextBase httpContext, out IController controller, out IControllerFactory factory)
{
  HttpContext currentContext = HttpContext.Current;
 
  //从路由获取controller名称
  string controllerName = RequestContext.RouteData.GetRequiredString("controller");
 
  //通过ControllerBuilder获取ControllerFactory，默认就是DefaultControllerFactory
  factory = ControllerBuilder.GetControllerFactory();
 
  //通过ControllerFactory获取Controller对象
  controller = factory.CreateController(RequestContext, controllerName);
}

public virtual IController CreateController(RequestContext requestContext, string controllerName)
{
  //获取Controller类型
  Type controllerType = GetControllerType(requestContext, controllerName);
 
  IController controller = GetControllerInstance(requestContext, controllerType);
  return controller;
}
 
protected internal virtual IController GetControllerInstance(RequestContext requestContext, Type controllerType)
{
  return ControllerActivator.Create(requestContext, controllerType);
}

private class DefaultControllerActivator : IControllerActivator
{
  private Func<IDependencyResolver> _resolverThunk;
 
  public DefaultControllerActivator()
    : this(null)
  {
  }
 
  public DefaultControllerActivator(IDependencyResolver resolver)
  {
    if (resolver == null)
    {
      _resolverThunk = () => DependencyResolver.Current;
    }
    else
    {
      _resolverThunk = () => resolver;
    }
  }
 
  public IController Create(RequestContext requestContext, Type controllerType)
  {
    try
    {
      return (IController)(_resolverThunk().GetService(controllerType) ?? Activator.CreateInstance(controllerType));
    }
    catch (Exception ex)
    {
    }
  }
}

public interface IDependencyResolver
{
  object GetService(Type serviceType);
  IEnumerable<object> GetServices(Type serviceType);
}

private class DefaultDependencyResolver : IDependencyResolver
{
  public object GetService(Type serviceType)
  {
    if (serviceType.IsInterface || serviceType.IsAbstract)
    {
      return null;
    }
 
    try
    {
      //如果Controller Type创建Controller实例对象
      return Activator.CreateInstance(serviceType);
    }
    catch
    {
      return null;
    }
  }
 
  public IEnumerable<object> GetServices(Type serviceType)
  {
    return Enumerable.Empty<object>();
  }
}

public class HomeController : Controller
{      
  private IUserService _service;
  public HomeController(IUserService service)
  {
    _service = service;
  }
 
  public ActionResult Index()
  {
    return Content(_service.GetUserName());
  }
}

public class UnityDependencyResolver : IDependencyResolver
{
  public object GetService(Type serviceType)
  {
    if(serviceType == null)
    {
      throw new ArgumentNullException("serviceType");
    }      
    return (serviceType.IsClass && !serviceType.IsAbstract)
      || Ioc.IsRegistered(serviceType) ? Ioc.GetService(serviceType) : null;
  }
 
  public IEnumerable<object> GetServices(Type serviceType)
  {
    if (serviceType == null)
    {
      throw new ArgumentNullException("serviceType");
    }
    return (serviceType.IsClass && !serviceType.IsAbstract)
      || Ioc.IsRegistered(serviceType) ? Ioc.GetServices(serviceType) : null;
  }
}

public class Ioc
{
  private static IUnityContainer _container = new UnityContainer();
 
  public static void RegisterType<TFrom,TTo>()
    where TTo : TFrom
  {      
    _container.RegisterType<TFrom, TTo>();
  }
 
  public static object GetService(Type type)
  {            
    return _container.Resolve(type);
  }
 
  public static IEnumerable<object> GetServices(Type type)
  {
    return _container.ResolveAll(type);
  }
 
  public static bool IsRegistered(Type type)
  {
    return _container.IsRegistered(type);
  }
}