Asp.net MVC中的Http管道事件为什么要以Application_开头(原因解析)

public class mvcapplication : system.web.httpapplication
{
.....
}

internal class httpapplicationfactory{
  internal const string applicationfilename = "global.asax"; //看到这里，就知道为什么入口文件是global.asax了，因为这里定义死了
  ...
  private void ensureinited() {
      if (!_inited) {
          lock (this) {
              if (!_inited) {
                  init();
                  _inited = true;
              }
          }
      }
  }
  private void init() {
      if (_customapplication != null)
          return;
      try {
          try {
              _appfilename = getapplicationfile();
              compileapplication();
          }
          finally {
              // always set up global.asax file change notification, even if compilation
              // failed.  this way, if the problem is fixed, the appdomain will be restarted.
              setupchangesmonitor();
          }
      }
      catch { // protect against exception filters
          throw;
      }
  }
  private void compileapplication() {
    // get the application type and appstate from the global file
    _theapplicationtype = buildmanager.getglobalasaxtype();
    buildresultcompiledglobalasaxtype result = buildmanager.getglobalasaxbuildresult();
    if (result != null) {
        // even if global.asax was already compiled, we need to get the collections
        // of application and session objects, since they are not persisted when
        // global.asax is compiled.  ideally, they would be, but since <object> tags
        // are only there for asp compat, it's not worth the trouble.
        // note that we only do this is the rare case where we know global.asax contains
        // <object> tags, to avoid always paying the price (vswhidbey 453101)
        if (result.hasapporsessionobjects) {
            getappstatebyparsingglobalasax();
        }
        // remember file dependencies
        _filedependencies = result.virtualpathdependencies;
    }
    if (_state == null) {
        _state = new httpapplicationstate();
    }
    // prepare to hookup event handlers via reflection
    reflectonapplicationtype();
  }   
  private void reflectonapplicationtype() {
    arraylist handlers = new arraylist();
    methodinfo[] methods;
    debug.trace("pipelineruntime", "reflectonapplicationtype");
    // get this class methods
    methods = _theapplicationtype.getmethods(bindingflags.nonpublic | bindingflags.public | bindingflags.instance | bindingflags.static);
    foreach (methodinfo m in methods) {
        if (reflectonmethodinfoifitlookslikeeventhandler(m))
            handlers.add(m);
    }
    // get base class private methods (getmethods would not return those)
    type basetype = _theapplicationtype.basetype;
    if (basetype != null && basetype != typeof(httpapplication)) {
        methods = basetype.getmethods(bindingflags.nonpublic | bindingflags.instance | bindingflags.static);
        foreach (methodinfo m in methods) {
            if (m.isprivate && reflectonmethodinfoifitlookslikeeventhandler(m))
                handlers.add(m);
        }
    }
    // remember as an array
    _eventhandlermethods = new methodinfo[handlers.count];
    for (int i = 0; i < _eventhandlermethods.length; i++)
        _eventhandlermethods[i] = (methodinfo)handlers[i];
  }
  private bool reflectonmethodinfoifitlookslikeeventhandler(methodinfo m) {
    if (m.returntype != typeof(void))
        return false;
    // has to have either no args or two args (object, eventargs)
    parameterinfo[] parameters = m.getparameters();
    switch (parameters.length) {
        case 0:
            // ok
            break;
        case 2:
            // param 0 must be object
            if (parameters[0].parametertype != typeof(system.object))
                return false;
            // param 1 must be eventargs
            if (parameters[1].parametertype != typeof(system.eventargs) &&
                !parameters[1].parametertype.issubclassof(typeof(system.eventargs)))
                return false;
            // ok
            break;
        default:
            return false;
    }
    // check the name (has to have _ not as first or last char)
    string name = m.name;
    int j = name.indexof('_');
    if (j <= 0 || j > name.length-1)
        return false;
    // special pseudo-events
    if (stringutil.equalsignorecase(name, "application_onstart") ||
        stringutil.equalsignorecase(name, "application_start")) {
        _onstartmethod = m;
        _onstartparamcount = parameters.length;
    }
    else if (stringutil.equalsignorecase(name, "application_onend") ||
             stringutil.equalsignorecase(name, "application_end")) {
        _onendmethod = m;
        _onendparamcount = parameters.length;
    }
    else if (stringutil.equalsignorecase(name, "session_onend") ||
             stringutil.equalsignorecase(name, "session_end")) {
        _sessiononendmethod = m;
        _sessiononendparamcount = parameters.length;
    }
    return true;
  }
}

internal class httpapplicationfactory{
......
  using (new applicationimpersonationcontext()) {
      app.initinternal(context, _state, _eventhandlermethods);
  }
......
......
  using (new applicationimpersonationcontext()) {
      app.initinternal(context, _state, _eventhandlermethods);
  }
......
}

// httpapplication.cs
public class httpapplication{
  internal void initspecial(httpapplicationstate state, methodinfo[] handlers, intptr appcontext, httpcontext context) {
    .....    
      if (handlers != null) {
          hookupeventhandlersforapplicationandmodules(handlers);
      }
    .....
  }
  internal void initinternal(httpcontext context, httpapplicationstate state, methodinfo[] handlers) {
    .....
      if (handlers != null)        
        hookupeventhandlersforapplicationandmodules(handlers);
    .....
  }
  private void hookupeventhandlersforapplicationandmodules(methodinfo[] handlers) {
      _currentmodulecollectionkey = httpapplicationfactory.applicationfilename;
      if(null == _pipelineeventmasks) {
          dictionary<string, requestnotification> dict = new dictionary<string, requestnotification>();
          buildeventmaskdictionary(dict);
          if(null == _pipelineeventmasks) {
              _pipelineeventmasks = dict;
          }
      }
      for (int i = 0; i < handlers.length; i++) {
          methodinfo appmethod = handlers[i];
          string appmethodname = appmethod.name;
          int nameposindex = appmethodname.indexof('_');
          string targetname = appmethodname.substring(0, nameposindex);
          // find target for method
          object target = null;
          if (stringutil.equalsignorecase(targetname, "application"))
              target = this;
          else if (_modulecollection != null)
              target = _modulecollection[targetname];
          if (target == null)
              continue;
          // find event on the module type
          type targettype = target.gettype();
          eventdescriptorcollection events = typedescriptor.getevents(targettype);
          string eventname = appmethodname.substring(nameposindex+1);
          eventdescriptor foundevent = events.find(eventname, true);
          if (foundevent == null
              && stringutil.equalsignorecase(eventname.substring(0, 2), "on")) {
              eventname = eventname.substring(2);
              foundevent = events.find(eventname, true);
          }
          methodinfo addmethod = null;
          if (foundevent != null) {
              eventinfo reflectionevent = targettype.getevent(foundevent.name);
              debug.assert(reflectionevent != null);
              if (reflectionevent != null) {
                  addmethod = reflectionevent.getaddmethod();
              }
          }
          if (addmethod == null)
              continue;
          parameterinfo[] addmethodparams = addmethod.getparameters();
          if (addmethodparams.length != 1)
              continue;
          // create the delegate from app method to pass to addxxx(handler) method
          delegate handlerdelegate = null;
          parameterinfo[] appmethodparams = appmethod.getparameters();
          if (appmethodparams.length == 0) {
              // if the app method doesn't have arguments --
              // -- hookup via intermidiate handler
              // only can do it for eventhandler, not strongly typed
              if (addmethodparams[0].parametertype != typeof(system.eventhandler))
                  continue;
              arglesseventhandlerproxy proxy = new arglesseventhandlerproxy(this, appmethod);
              handlerdelegate = proxy.handler;
          }
          else {
              // hookup directly to the app methods hoping all types match
              try {
                  handlerdelegate = delegate.createdelegate(addmethodparams[0].parametertype, this, appmethodname);
              }
              catch {
                  // some type mismatch
                  continue;
              }
          }
          // call the addxxx() to hook up the delegate
          try {
              addmethod.invoke(target, new object[1]{handlerdelegate});
          }
          catch {
              if (httpruntime.useintegratedpipeline) {
                  throw;
              }
          }
          if (eventname != null) {
              if (_pipelineeventmasks.containskey(eventname)) {
                  if (!stringutil.stringstartswith(eventname, "post")) {
                      _apprequestnotifications |= _pipelineeventmasks[eventname];
                  }
                  else {
                      _apppostnotifications |= _pipelineeventmasks[eventname];
                  }
              }
          }
      }
  }
}