C# HttpApplication.Dispose方法代碼示例

        /// <summary>
        /// Initializes a new instance of the <see cref="T:HttpApplicationProxy"/> class.
        /// </summary>
        /// <param name="context">The HTTP context for the application.</param>
        /// <param name="namedHttpModules">The optional array of named HTTP modules to add to the application.</param>
        /// <exception cref="System.ArgumentNullException"><paramref name="context"/> is a null reference.</exception>
        public HttpApplicationProxy(HttpContext context, params Pair<String, IHttpModule>[] namedHttpModules)
            : base()
        {
            if (context == null) {
                throw new ArgumentNullException("context");
            }

            HttpApplication application = new HttpApplication();
            try {
                // Add the HTTP modules.
                if (namedHttpModules != null && namedHttpModules.Length > 0) {
                    HttpModuleCollection httpModuleCollection = (HttpModuleCollection)typeof(HttpModuleCollection).CreateInstance();
                    foreach (Pair<String, IHttpModule> namedHttpModule in namedHttpModules) {
                        if (namedHttpModule != null && namedHttpModule.First != null && namedHttpModule.Second != null) {
                            httpModuleCollection.InvokeMethod("AddModule", namedHttpModule.First, namedHttpModule.Second);
                        }
                    }
                    application.SetFieldValue("_moduleCollection", httpModuleCollection);
                }

                // Tie the HTTP context to the HTTP application.
                application.SetFieldValue("_context", context);
                application.SetFieldValue("_stepManager", typeof(HttpApplication).FindNestedType("ApplicationStepManager").CreateInstance(application));
                context.ApplicationInstance = application;
            }
            catch {
                application.Dispose();
                throw;
            }

            // Save the state.
            this._application = application;
        }

        /// <summary>
        /// Sets up and invokes an entry point on an <see cref="HttpApplication"/> implementer found
        /// by probing the given bin path.
        /// </summary>
        /// <param name="logger">The logger to use when probing.</param>
        /// <param name="binPath">The bin path to probe.</param>
        private void SetupandInvokeEntryPoint(ILogger logger, string binPath)
        {
            if (Directory.Exists(binPath))
            {
                HttpApplicationProbe probe = new HttpApplicationProbe(logger, binPath);
                Type type = HttpApplicationProbe.FindApplicationTypes(probe.FindApplicationAssemblies()).FirstOrDefault();

                if (type != null)
                {
                    logger.Info("Found an HTTP application requiring startup: {0}.", type.FullName);
                    HttpApplication httpApplication = null;

                    try
                    {
                        httpApplication = (HttpApplication)Activator.CreateInstance(type);
                    }
                    catch (Exception ex)
                    {
                        logger.Error(ex, "Failed to create an instance of the HTTP application {0}.", type.FullName);
                    }

                    if (httpApplication != null)
                    {
                        try
                        {
                            MethodInfo entryPoint = HttpApplicationProbe.FindEntryPoint(type);

                            if (entryPoint != null)
                            {
                                logger.Info("Invoking entry point for HTTP application {0}.", type.FullName);
                                this.InvokeEventHandler(httpApplication, entryPoint);
                            }
                            else
                            {
                                logger.Info("No entry point found for HTTP application {0}.", type.FullName);
                            }

                            this.httpApplication = httpApplication;
                            httpApplication = null;
                        }
                        catch (Exception ex)
                        {
                            logger.Error(ex, "Failed to invoke the entry point for HTTP application {0}.", type.FullName);

                            if (ex.InnerException != null)
                            {
                                logger.Error(ex.InnerException);
                            }
                        }
                        finally
                        {
                            if (httpApplication != null)
                            {
                                httpApplication.Dispose();
                            }
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Disposes of the HTTP applications that was created as an entry point.
        /// </summary>
        private void DisposeHttpApplication()
        {
            HttpApplication httpApplication = this.httpApplication;
            this.httpApplication = null;

            if (httpApplication != null)
            {
                try
                {
                    MethodInfo method = HttpApplicationProbe.FindExitPoint(httpApplication.GetType());

                    if (method != null)
                    {
                        this.logger.Info("Invoking exit point for HTTP application {0}.", httpApplication.GetType().FullName);
                        this.InvokeEventHandler(httpApplication, method);
                    }
                    else
                    {
                        this.logger.Info("No exit point found for HTTP application {0}.", httpApplication.GetType().FullName);
                    }
                }
                finally
                {
                    httpApplication.Dispose();
                }
            }
        }

		internal static void Recycle (HttpApplication app)
		{
			bool dispose = false;
			HttpApplicationFactory factory = theFactory;
			if (Interlocked.CompareExchange (ref factory.next_free, app, null) == null)
				return;

			lock (factory.available) {
				if (factory.available.Count < 64)
					factory.available.Push (app);
				else
					dispose = true;
			}
			if (dispose)
				app.Dispose ();
		}

		internal static void RecycleForSessionEnd (HttpApplication app)
		{
			bool dispose = false;
			HttpApplicationFactory factory = theFactory;
			lock (factory.available_for_end) {
				if (factory.available_for_end.Count < 64)
					factory.available_for_end.Push (app);
				else
					dispose = true;
			}
			if (dispose)
				app.Dispose ();
		}

		public void Methods_Deny_Unrestricted ()
		{
			HttpApplication app = new HttpApplication ();
			app.CompleteRequest ();
			app.GetVaryByCustomString (null, String.Empty);
			app.Dispose ();
		}