C# HttpException.SetFormatter方法代码示例

 public override void Load()
 {
     if (base.Page.RequestValueCollection != null)
     {
         try
         {
             string requestViewStateString = base.Page.RequestViewStateString;
             string second = null;
             bool flag = false;
             if (!string.IsNullOrEmpty(requestViewStateString))
             {
                 Pair pair = (Pair) Util.DeserializeWithAssert(base.StateFormatter, requestViewStateString);
                 if ((bool) pair.First)
                 {
                     second = (string) pair.Second;
                     flag = true;
                 }
                 else
                 {
                     Pair pair2 = (Pair) pair.Second;
                     second = (string) pair2.First;
                     base.ControlState = pair2.Second;
                 }
             }
             if (second != null)
             {
                 object obj2 = base.Page.Session["__SESSIONVIEWSTATE" + second];
                 if (flag)
                 {
                     Pair pair3 = obj2 as Pair;
                     if (pair3 != null)
                     {
                         base.ViewState = pair3.First;
                         base.ControlState = pair3.Second;
                     }
                 }
                 else
                 {
                     base.ViewState = obj2;
                 }
             }
         }
         catch (Exception exception)
         {
             HttpException e = new HttpException(System.Web.SR.GetString("Invalid_ControlState"), exception);
             e.SetFormatter(new UseLastUnhandledErrorFormatter(e));
             throw e;
         }
     }
 }

            void IExecutionStep.Execute() {
                HttpContext context = _application.Context;
                IHttpHandler handler = context.Handler;

                if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Information, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_HTTPHANDLER_ENTER, context.WorkerRequest);

                if (handler != null && HttpRuntime.UseIntegratedPipeline) {
                    IIS7WorkerRequest wr = context.WorkerRequest as IIS7WorkerRequest;
                    if (wr != null && wr.IsHandlerExecutionDenied()) {
                        _sync = true;
                        HttpException error = new HttpException(403, SR.GetString(SR.Handler_access_denied));
                        error.SetFormatter(new PageForbiddenErrorFormatter(context.Request.Path, SR.GetString(SR.Handler_access_denied)));
                        throw error;
                    }
                }

                if (handler == null) {
                    _sync = true;
                }
                else if (handler is IHttpAsyncHandler) {
                    // asynchronous handler
                    IHttpAsyncHandler asyncHandler = (IHttpAsyncHandler)handler;

                    _sync = false;
                    _handler = asyncHandler;

                    // Instrument the BeginProcessRequest method if AppVerifier is enabled.
                    // If AppVerifier not enabled, we just get back the original delegate to BeginProcessRequest uninstrumented.
                    var beginProcessRequestDelegate = AppVerifier.WrapBeginMethod<HttpContext>(_application, asyncHandler.BeginProcessRequest);

                    _asyncStepCompletionInfo.Reset();
                    context.SyncContext.AllowVoidAsyncOperations();
                    IAsyncResult ar;
                    try {
                        ar = beginProcessRequestDelegate(context, _completionCallback, null);
                    }
                    catch {
                        // The asynchronous step has completed, so we should disallow further
                        // async operations until the next step.
                        context.SyncContext.ProhibitVoidAsyncOperations();
                        throw;
                    }

                    bool operationCompleted;
                    bool mustCallEndHandler;
                    _asyncStepCompletionInfo.RegisterBeginUnwound(ar, out operationCompleted, out mustCallEndHandler);

                    if (operationCompleted) {
                        _sync = true;
                        _handler = null; // not to remember

                        // The asynchronous step has completed, so we should disallow further
                        // async operations until the next step.
                        context.SyncContext.ProhibitVoidAsyncOperations();

                        try {
                            if (mustCallEndHandler) {
                                asyncHandler.EndProcessRequest(ar);
                            }

                            _asyncStepCompletionInfo.ReportError();
                        }
                        finally {
                            SuppressPostEndRequestIfNecessary(context);

                            //  In Integrated mode, generate the necessary response headers
                            //  after the ASP.NET handler runs
                            context.Response.GenerateResponseHeadersForHandler();
                        }

                        if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Information, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_HTTPHANDLER_LEAVE, context.WorkerRequest);
                    }
                }
                else {
                    // synchronous handler
                    _sync = true;

                    // disable async operations
                    //_application.SyncContext.Disable();

                    // VSWhidbey 268772 - If a synchronous handler internally kicks off an asynchronous operation and waits (blocking) for that
                    // operation to complete, the handler will deadlock since the asynchronous operation can't come back to the appropriate
                    // thread to perform the completion. The solution below was only meant to be temporary but was accidentally left in the product
                    // for v2.0 RTM, so it's now legacy behavior and cannot be changed.
                    context.SyncContext.SetSyncCaller();

                    try {
                        handler.ProcessRequest(context);
                    }
                    finally {
                        context.SyncContext.ResetSyncCaller();
                        if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Information, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_HTTPHANDLER_LEAVE, context.WorkerRequest);

                        SuppressPostEndRequestIfNecessary(context);

                        // In Integrated mode, generate the necessary response headers
                        // after the ASP.NET handler runs
                        context.Response.GenerateResponseHeadersForHandler();
                    }
                }
//.........这里部分代码省略.........

        internal IPartitionInfo CreatePartitionInfo(string sqlConnectionString) {
            /*
             * Parse the connection string for errors. We want to ensure
             * that the user's connection string doesn't contain an
             * Initial Catalog entry, so we must first create a dummy connection.
             */
            SqlConnection   dummyConnection;
            string          attachDBFilename = null;

            try {
                dummyConnection = new SqlConnection(sqlConnectionString);
            }
            catch (Exception e) {
                if (s_usePartition) {
                    HttpException outerException = new HttpException(
                           SR.GetString(SR.Error_parsing_sql_partition_resolver_string, s_configPartitionResolverType, e.Message), e);

                    outerException.SetFormatter(new UseLastUnhandledErrorFormatter(outerException));

                    throw outerException;
                }
                else {
                    throw new ConfigurationErrorsException(
                        SR.GetString(SR.Error_parsing_session_sqlConnectionString, e.Message), e,
                        s_configSqlConnectionFileName, s_configSqlConnectionLineNumber);
                }
            }

            // Search for both Database and AttachDbFileName.  Don't append our
            // database name if either of them exists.
            string database = dummyConnection.Database;
            SqlConnectionStringBuilder  scsb = new SqlConnectionStringBuilder(sqlConnectionString);

            if (String.IsNullOrEmpty(database)) {
                database = scsb.AttachDBFilename;
                attachDBFilename = database;
            }

            if (!String.IsNullOrEmpty(database)) {
                if (!s_configAllowCustomSqlDatabase) {
                    if (s_usePartition) {
                        throw new HttpException(
                                SR.GetString(SR.No_database_allowed_in_sql_partition_resolver_string,
                                            s_configPartitionResolverType, dummyConnection.DataSource, database));
                    }
                    else {
                        throw new ConfigurationErrorsException(
                                SR.GetString(SR.No_database_allowed_in_sqlConnectionString),
                                s_configSqlConnectionFileName, s_configSqlConnectionLineNumber);
                    }
                }

                if (attachDBFilename != null) {
                    HttpRuntime.CheckFilePermission(attachDBFilename, true);
                }
            }
            else {
                sqlConnectionString += ";Initial Catalog=ASPState";
            }

            return new SqlPartitionInfo(new ResourcePool(new TimeSpan(0, 0, 5), int.MaxValue),
                                            scsb.IntegratedSecurity,
                                            sqlConnectionString);

        }

            internal SqlStateConnection(SqlPartitionInfo sqlPartitionInfo, TimeSpan retryInterval) {
                Debug.Trace("SessionStateConnectionIdentity", "Connecting under " + WindowsIdentity.GetCurrent().Name);

                _partitionInfo = sqlPartitionInfo;
                _sqlConnection = new SqlConnection(sqlPartitionInfo.SqlConnectionString);

                bool isFirstAttempt = true;
                DateTime endRetryTime = DateTime.UtcNow;

                while(true) {
                    try {
                        _sqlConnection.Open();
                        // the operation succeeded, exit the loop
                        if(!isFirstAttempt) {
                            ClearFlagForClearPoolInProgress();
                        }
                        break;
                    }
                    catch (SqlException e) {
                        if (e != null &&
                            (e.Number == SQL_LOGIN_FAILED ||
                             e.Number == SQL_LOGIN_FAILED_2 ||
                             e.Number == SQL_LOGIN_FAILED_3))
                        {
                            string  user;

                            SqlConnectionStringBuilder  scsb = new SqlConnectionStringBuilder(sqlPartitionInfo.SqlConnectionString);
                            if (scsb.IntegratedSecurity) {
                                user = WindowsIdentity.GetCurrent().Name;
                            }
                            else {
                                user = scsb.UserID;
                            }

                            HttpException outerException = new HttpException(
                                    SR.GetString(SR.Login_failed_sql_session_database, user ), e);

                            outerException.SetFormatter(new UseLastUnhandledErrorFormatter(outerException));
                            ClearConnectionAndThrow(outerException);
                        }
                        if (!CanRetry(e, _sqlConnection, ref isFirstAttempt, ref endRetryTime))
                        {
                            // just throw, the retry conditions are not satisfied
                            ClearConnectionAndThrow(e);
                        }
                    }
                    catch (Exception e) {
                        // just throw, we have a different Exception
                        ClearConnectionAndThrow(e);
                    }
                }

                try {
                    _partitionInfo.InitSqlInfo(_sqlConnection);
                    Debug.Assert(sqlPartitionInfo.SupportFlags != SupportFlags.Uninitialized);

                    PerfCounters.IncrementCounter(AppPerfCounter.SESSION_SQL_SERVER_CONNECTIONS);
                }
                catch {
                    Dispose();
                    throw;
                }
            }

 private static void ThrowError(Exception inner, string persistedState, string errorPageMessage, bool macValidationError)
 {
     ViewStateException innerException = new ViewStateException(inner, persistedState) {
         _macValidationError = macValidationError
     };
     HttpException e = new HttpException(GetCorrectErrorPageMessage(innerException, errorPageMessage), innerException);
     e.SetFormatter(new UseLastUnhandledErrorFormatter(e));
     throw e;
 }

 void IHttpHandler.ProcessRequest(HttpContext context)
 {
     if (DeploymentSection.RetailInternal || (!context.Request.IsLocal && HttpRuntime.Profile.LocalOnly))
     {
         HttpException exception = new HttpException(0x193, null);
         exception.SetFormatter(new TraceHandlerErrorFormatter(!DeploymentSection.RetailInternal));
         throw exception;
     }
     this._context = context;
     this._response = this._context.Response;
     this._request = this._context.Request;
     this._writer = Page.CreateHtmlTextWriterInternal(this._response.Output, this._request);
     if (context.WorkerRequest is IIS7WorkerRequest)
     {
         this._response.ContentType = this._request.Browser.PreferredRenderingMime;
     }
     if (this._writer != null)
     {
         this._context.Trace.IsEnabled = false;
         this._request.ValidateInput();
         this._writer.Write("<html>\r\n");
         this._writer.Write("<head>\r\n");
         this._writer.Write(StyleSheet);
         this._writer.Write("</head>\r\n");
         this._writer.Write("<body>\r\n");
         this._writer.Write("<span class=\"tracecontent\">\r\n");
         if (!HttpRuntime.Profile.IsConfigEnabled)
         {
             HttpException exception2 = new HttpException();
             exception2.SetFormatter(new TraceHandlerErrorFormatter(false));
             throw exception2;
         }
         IList data = HttpRuntime.Profile.GetData();
         if (this._request.QueryString["clear"] != null)
         {
             HttpRuntime.Profile.Reset();
             string rawUrl = this._request.RawUrl;
             this._response.Redirect(rawUrl.Substring(0, rawUrl.IndexOf("?", StringComparison.Ordinal)));
         }
         string s = this._request.QueryString["id"];
         if (s != null)
         {
             int num = int.Parse(s, CultureInfo.InvariantCulture);
             if ((num >= 0) && (num < data.Count))
             {
                 this.ShowDetails((DataSet) data[num]);
                 this.ShowVersionDetails();
                 this._writer.Write("</span>\r\n</body>\r\n</html>\r\n");
                 return;
             }
         }
         this.ShowRequests(data);
         this.ShowVersionDetails();
         this._writer.Write("</span>\r\n</body>\r\n</html>\r\n");
     }
 }

        private static void ThrowError(Exception inner, string persistedState, string errorPageMessage,
                                        bool macValidationError) {
            ViewStateException middle;
            HttpException outer;

            middle = new ViewStateException(inner, persistedState);  
            middle._macValidationError = macValidationError;

            // Setup the formatter for this exception, to make sure this message shows up
            // in an error page as opposed to the inner-most exception's message.
            outer = new HttpException(GetCorrectErrorPageMessage(middle, errorPageMessage), middle);
            outer.SetFormatter(new UseLastUnhandledErrorFormatter(outer));

            throw outer;
        }

        internal void ReportRuntimeError(Exception e, bool canThrow, bool localExecute) {
            CustomErrorsSection customErrorsSetting = null;
            bool useCustomErrors = false;
            int code = -1;

            if (_completed)
                return;

            // always try to disable IIS custom errors when we send an error
            if (_wr != null) {
                _wr.TrySkipIisCustomErrors = true;
            }

            if (!localExecute) {
                code = HttpException.GetHttpCodeForException(e);

                // Don't raise event for 404.  See VSWhidbey 124147.
                if (code != 404) {
                    WebBaseEvent.RaiseRuntimeError(e, this);
                }

                // This cannot use the HttpContext.IsCustomErrorEnabled property, since it must call
                // GetSettings() with the canThrow parameter.
                customErrorsSetting = CustomErrorsSection.GetSettings(_context, canThrow);
                if (customErrorsSetting != null)
                    useCustomErrors = customErrorsSetting.CustomErrorsEnabled(Request);
                else
                    useCustomErrors = true;
            }

            if (!_headersWritten) {
                // nothing sent yet - entire response

                if (code == -1) {
                    code = HttpException.GetHttpCodeForException(e);
                }

                // change 401 to 500 in case the config is not to impersonate
                if (code == 401 && !_context.IsClientImpersonationConfigured)
                    code = 500;

                if (_context.TraceIsEnabled)
                    _context.Trace.StatusCode = code;

                if (!localExecute && useCustomErrors) {
                    String redirect = (customErrorsSetting != null) ? customErrorsSetting.GetRedirectString(code) : null;

                    RedirectToErrorPageStatus redirectStatus = RedirectToErrorPage(redirect, customErrorsSetting.RedirectMode);
                    switch (redirectStatus) {
                        case RedirectToErrorPageStatus.Success:
                            // success - nothing to do
                            break;

                        case RedirectToErrorPageStatus.NotAttempted:
                            // if no redirect display generic error
                            ClearAll();
                            StatusCode = code;
                            WriteErrorMessage(e, dontShowSensitiveErrors: true);
                            break;

                        default:
                            // DevDiv #70492 - If we tried to display the custom error page but failed in doing so, we should display
                            // a generic error message instead of trying to display the original error. We have a compat switch on
                            // the <customErrors> element to control this behavior.

                            if (customErrorsSetting.AllowNestedErrors) {
                                // The user has set the compat switch to use the original (pre-bug fix) behavior.
                                goto case RedirectToErrorPageStatus.NotAttempted;
                            }

                            ClearAll();
                            StatusCode = 500;
                            HttpException dummyException = new HttpException();
                            dummyException.SetFormatter(new CustomErrorFailedErrorFormatter());
                            WriteErrorMessage(dummyException, dontShowSensitiveErrors: true);
                            break;
                    }
                }
                else {
                    ClearAll();
                    StatusCode = code;
                    WriteErrorMessage(e, dontShowSensitiveErrors: false);
                }
            }
            else {
                Clear();

                if (_contentType != null && _contentType.Equals("text/html")) {
                    // in the middle of Html - break Html
                    Write("\r\n\r\n</pre></table></table></table></table></table>");
                    Write("</font></font></font></font></font>");
                    Write("</i></i></i></i></i></b></b></b></b></b></u></u></u></u></u>");
                    Write("<p>&nbsp;</p><hr>\r\n\r\n");
                }

                WriteErrorMessage(e, useCustomErrors);
            }
        }

 private static void CreateMdfFile(string fullFileName, string dataDir, string connectionString)
 {
     bool flag = false;
     string database = null;
     HttpContext current = HttpContext.Current;
     string dbFileName = null;
     try
     {
         if (!Directory.Exists(dataDir))
         {
             flag = true;
             Directory.CreateDirectory(dataDir);
             flag = false;
             try
             {
                 if (current != null)
                 {
                     HttpRuntime.RestrictIISFolders(current);
                 }
             }
             catch
             {
             }
         }
         fullFileName = fullFileName.ToUpper(CultureInfo.InvariantCulture);
         char[] chArray = Path.GetFileNameWithoutExtension(fullFileName).ToCharArray();
         for (int i = 0; i < chArray.Length; i++)
         {
             if (!char.IsLetterOrDigit(chArray[i]))
             {
                 chArray[i] = '_';
             }
         }
         string str3 = new string(chArray);
         if (str3.Length > 30)
         {
             database = str3.Substring(0, 30) + "_" + Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture);
         }
         else
         {
             database = str3 + "_" + Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture);
         }
         dbFileName = Path.Combine(Path.GetDirectoryName(fullFileName), str3 + "_TMP.MDF");
         SqlServices.Install(database, dbFileName, connectionString);
         DetachDB(database, connectionString);
         try
         {
             File.Move(dbFileName, fullFileName);
         }
         catch
         {
             if (!File.Exists(fullFileName))
             {
                 File.Copy(dbFileName, fullFileName);
                 try
                 {
                     File.Delete(dbFileName);
                 }
                 catch
                 {
                 }
             }
         }
         try
         {
             File.Delete(dbFileName.Replace("_TMP.MDF", "_TMP_log.LDF"));
         }
         catch
         {
         }
     }
     catch (Exception exception)
     {
         if ((current == null) || current.IsCustomErrorEnabled)
         {
             throw;
         }
         HttpException exception2 = new HttpException(exception.Message, exception);
         if (exception is UnauthorizedAccessException)
         {
             exception2.SetFormatter(new SqlExpressConnectionErrorFormatter(flag ? DataConnectionErrorEnum.CanNotCreateDataDir : DataConnectionErrorEnum.CanNotWriteToDataDir));
         }
         else
         {
             exception2.SetFormatter(new SqlExpressDBFileAutoCreationErrorFormatter(exception));
         }
         throw exception2;
     }
 }

 internal SqlStateConnection(SqlSessionStateStore.SqlPartitionInfo sqlPartitionInfo, TimeSpan retryInterval)
 {
     this._partitionInfo = sqlPartitionInfo;
     this._sqlConnection = new SqlConnection(sqlPartitionInfo.SqlConnectionString);
     bool isFirstAttempt = true;
     DateTime utcNow = DateTime.UtcNow;
 Label_0026:
     try
     {
         this._sqlConnection.Open();
         if (!isFirstAttempt)
         {
             SqlSessionStateStore.ClearFlagForClearPoolInProgress();
         }
     }
     catch (SqlException exception)
     {
         if ((exception != null) && (((exception.Number == 0x4818) || (exception.Number == 0x4814)) || (exception.Number == 0x4812)))
         {
             string name;
             SqlConnectionStringBuilder builder = new SqlConnectionStringBuilder(sqlPartitionInfo.SqlConnectionString);
             if (builder.IntegratedSecurity)
             {
                 name = WindowsIdentity.GetCurrent().Name;
             }
             else
             {
                 name = builder.UserID;
             }
             HttpException e = new HttpException(System.Web.SR.GetString("Login_failed_sql_session_database", new object[] { name }), exception);
             e.SetFormatter(new UseLastUnhandledErrorFormatter(e));
             this.ClearConnectionAndThrow(e);
         }
         if (!SqlSessionStateStore.CanRetry(exception, this._sqlConnection, ref isFirstAttempt, ref utcNow))
         {
             this.ClearConnectionAndThrow(exception);
         }
         goto Label_0026;
     }
     catch (Exception exception3)
     {
         this.ClearConnectionAndThrow(exception3);
         goto Label_0026;
     }
     try
     {
         this._partitionInfo.InitSqlInfo(this._sqlConnection);
         PerfCounters.IncrementCounter(AppPerfCounter.SESSION_SQL_SERVER_CONNECTIONS);
     }
     catch
     {
         this.Dispose();
         throw;
     }
 }

        internal static void EnsureTableIsRegisteredAndPolled(string database, string table)
        {
            DateTime time2;
            bool flag2;
            Exception exception;
            int num2;
            bool flag = false;
            if (HttpRuntime.CacheInternal[GetMoniterKey(database, table)] != null)
            {
                return;
            }
            InitPolling(database);
            DatabaseNotifState state = (DatabaseNotifState) s_DatabaseNotifStates[database];
            if (!state._init)
            {
                int num;
                HttpContext current = HttpContext.Current;
                if (current == null)
                {
                    num = 30;
                }
                else
                {
                    num = Math.Max(current.Timeout.Seconds / 3, 30);
                }
                DateTime time = DateTime.UtcNow.Add(new TimeSpan(0, 0, num));
                do
                {
                    if (state._init)
                    {
                        goto Label_00BD;
                    }
                    Thread.Sleep(250);
                }
                while (Debugger.IsAttached || (DateTime.UtcNow <= time));
                throw new HttpException(System.Web.SR.GetString("Cant_connect_sql_cache_dep_database_polling", new object[] { database }));
            }
        Label_00BD:
            num2 = 0;
            lock (state)
            {
                exception = state._pollExpt;
                if (exception != null)
                {
                    num2 = state._pollSqlError;
                }
                time2 = state._utcTablesUpdated;
                flag2 = state._notifEnabled;
            }
            if (((exception == null) && flag2) && state._tables.ContainsKey(table))
            {
                return;
            }
            if (flag || ((DateTime.UtcNow - time2) < OneSec))
            {
                string str;
                if (num2 == 0xafc)
                {
                    exception = null;
                }
                if (exception == null)
                {
                    if (!flag2)
                    {
                        throw new DatabaseNotEnabledForNotificationException(System.Web.SR.GetString("Database_not_enabled_for_notification", new object[] { database }));
                    }
                    throw new TableNotEnabledForNotificationException(System.Web.SR.GetString("Table_not_enabled_for_notification", new object[] { table, database }));
                }
                switch (num2)
                {
                    case 0xe5:
                    case 0x106:
                        str = "Permission_denied_database_polling";
                        break;

                    default:
                        str = "Cant_connect_sql_cache_dep_database_polling";
                        break;
                }
                HttpException e = new HttpException(System.Web.SR.GetString(str, new object[] { database }), exception);
                e.SetFormatter(new UseLastUnhandledErrorFormatter(e));
                throw e;
            }
            UpdateDatabaseNotifState(database);
            flag = true;
            goto Label_00BD;
        }

 internal IPartitionInfo CreatePartitionInfo(string sqlConnectionString)
 {
     SqlConnection connection;
     string path = null;
     try
     {
         connection = new SqlConnection(sqlConnectionString);
     }
     catch (Exception exception)
     {
         if (s_usePartition)
         {
             HttpException e = new HttpException(System.Web.SR.GetString("Error_parsing_sql_partition_resolver_string", new object[] { s_configPartitionResolverType, exception.Message }), exception);
             e.SetFormatter(new UseLastUnhandledErrorFormatter(e));
             throw e;
         }
         throw new ConfigurationErrorsException(System.Web.SR.GetString("Error_parsing_session_sqlConnectionString", new object[] { exception.Message }), exception, s_configSqlConnectionFileName, s_configSqlConnectionLineNumber);
     }
     string database = connection.Database;
     SqlConnectionStringBuilder builder = new SqlConnectionStringBuilder(sqlConnectionString);
     if (string.IsNullOrEmpty(database))
     {
         database = builder.AttachDBFilename;
         path = database;
     }
     if (!string.IsNullOrEmpty(database))
     {
         if (!s_configAllowCustomSqlDatabase)
         {
             if (s_usePartition)
             {
                 throw new HttpException(System.Web.SR.GetString("No_database_allowed_in_sql_partition_resolver_string", new object[] { s_configPartitionResolverType, connection.DataSource, database }));
             }
             throw new ConfigurationErrorsException(System.Web.SR.GetString("No_database_allowed_in_sqlConnectionString"), s_configSqlConnectionFileName, s_configSqlConnectionLineNumber);
         }
         if (path != null)
         {
             HttpRuntime.CheckFilePermission(path, true);
         }
     }
     else
     {
         sqlConnectionString = sqlConnectionString + ";Initial Catalog=ASPState";
     }
     return new SqlPartitionInfo(new ResourcePool(new TimeSpan(0, 0, 5), 0x7fffffff), builder.IntegratedSecurity, sqlConnectionString);
 }

        void IHttpHandler.ProcessRequest(HttpContext context) {
            // VSWhidbey 448844: Disable handler if retail is set to true
            if (DeploymentSection.RetailInternal ||
                (!context.Request.IsLocal && HttpRuntime.Profile.LocalOnly)) {
                HttpException e = new HttpException(403, null);
                e.SetFormatter(new TraceHandlerErrorFormatter(!DeploymentSection.RetailInternal));
                throw e;
            }

            _context = context;
            _response = _context.Response;
            _request = _context.Request;
            _writer = Page.CreateHtmlTextWriterInternal(_response.Output, _request);

            // if we're in integrated mode, we need to set the content type explicitly
            if (context.WorkerRequest is IIS7WorkerRequest) {
                _response.ContentType = _request.Browser.PreferredRenderingMime;
            }

            if (_writer == null) {
                // Can't create a writer, horked at this point, just return
                return;
            }

            _context.Trace.IsEnabled = false;

            // Validate the input to prevent XSS attacks.
            _request.ValidateInput();

            _writer.Write("<html>\r\n");
            _writer.Write("<head>\r\n");
            _writer.Write(StyleSheet);
            _writer.Write("</head>\r\n");

            _writer.Write("<body>\r\n");
            _writer.Write("<span class=\"tracecontent\">\r\n");

            if (!HttpRuntime.Profile.IsConfigEnabled) {
                HttpException e = new HttpException();
                e.SetFormatter(new TraceHandlerErrorFormatter(false));
                throw e;
            }

            IList datasets = HttpRuntime.Profile.GetData();

            // first check if we should clear data
            if (_request.QueryString["clear"] != null) {
                HttpRuntime.Profile.Reset();
                string url = _request.RawUrl;
                _response.Redirect(url.Substring(0, url.IndexOf("?", StringComparison.Ordinal)));
            }

            // then check if we are drilling down
            string strid = _request.QueryString["id"];
            if (strid != null) {
                int index = Int32.Parse(strid, CultureInfo.InvariantCulture);
                if (index >=0 && index < datasets.Count) {
                    ShowDetails((DataSet) datasets[index]);
                    ShowVersionDetails();
                    _writer.Write("</span>\r\n</body>\r\n</html>\r\n");
                    return;
                }
            }

            // if we get here, its just generic request
            ShowRequests(datasets);
            ShowVersionDetails();
            _writer.Write("</span>\r\n</body>\r\n</html>\r\n");
        }

 private static SqlCacheDependency CreateSql7SqlCacheDependencyForOutputCache(string database, string table, string depString)
 {
     SqlCacheDependency dependency;
     try
     {
         dependency = new SqlCacheDependency(database, table);
     }
     catch (HttpException exception)
     {
         HttpException e = new HttpException(System.Web.SR.GetString("Invalid_sqlDependency_argument2", new object[] { depString, exception.Message }), exception);
         e.SetFormatter(new UseLastUnhandledErrorFormatter(e));
         throw e;
     }
     return dependency;
 }

 void HttpApplication.IExecutionStep.Execute()
 {
     HttpContext context = this._application.Context;
     IHttpHandler handler = context.Handler;
     if (EtwTrace.IsTraceEnabled(4, 4))
     {
         EtwTrace.Trace(EtwTraceType.ETW_TYPE_HTTPHANDLER_ENTER, context.WorkerRequest);
     }
     if ((handler != null) && HttpRuntime.UseIntegratedPipeline)
     {
         IIS7WorkerRequest workerRequest = context.WorkerRequest as IIS7WorkerRequest;
         if ((workerRequest != null) && workerRequest.IsHandlerExecutionDenied())
         {
             this._sync = true;
             HttpException exception = new HttpException(0x193, System.Web.SR.GetString("Handler_access_denied"));
             exception.SetFormatter(new PageForbiddenErrorFormatter(context.Request.Path, System.Web.SR.GetString("Handler_access_denied")));
             throw exception;
         }
     }
     if (handler == null)
     {
         this._sync = true;
     }
     else if (handler is IHttpAsyncHandler)
     {
         IHttpAsyncHandler handler2 = (IHttpAsyncHandler) handler;
         this._sync = false;
         this._handler = handler2;
         IAsyncResult result = handler2.BeginProcessRequest(context, this._completionCallback, null);
         if (result.CompletedSynchronously)
         {
             this._sync = true;
             this._handler = null;
             try
             {
                 handler2.EndProcessRequest(result);
             }
             finally
             {
                 context.Response.GenerateResponseHeadersForHandler();
             }
             if (EtwTrace.IsTraceEnabled(4, 4))
             {
                 EtwTrace.Trace(EtwTraceType.ETW_TYPE_HTTPHANDLER_LEAVE, context.WorkerRequest);
             }
         }
     }
     else
     {
         this._sync = true;
         context.SyncContext.SetSyncCaller();
         try
         {
             handler.ProcessRequest(context);
         }
         finally
         {
             context.SyncContext.ResetSyncCaller();
             if (EtwTrace.IsTraceEnabled(4, 4))
             {
                 EtwTrace.Trace(EtwTraceType.ETW_TYPE_HTTPHANDLER_LEAVE, context.WorkerRequest);
             }
             context.Response.GenerateResponseHeadersForHandler();
         }
     }
 }