//------------------------------------------------------------------------------
// <copyright file="ApplicationManager.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//------------------------------------------------------------------------------


namespace System.Web.Hosting {
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Collections.Specialized;
    using System.Configuration;
    using System.Configuration.Provider;
    using System.Diagnostics.CodeAnalysis;
    using System.Globalization;
    using System.IO;
    using System.Linq;
    using System.Reflection;
    using System.Runtime.ExceptionServices;
    using System.Runtime.InteropServices;
    using System.Runtime.Remoting;
    using System.Runtime.Versioning;
    using System.Security;
    using System.Security.Permissions;
    using System.Security.Policy;
    using System.Text;
    using System.Threading;
    using System.Threading.Tasks;
    using System.Web;
    using System.Web.Compilation;
    using System.Web.Configuration;
    using System.Web.Util;

    public enum HostSecurityPolicyResults {
        DefaultPolicy = 0,
        FullTrust = 1,
        AppDomainTrust = 2,
        Nothing = 3
    };

    [PermissionSet(SecurityAction.InheritanceDemand, Unrestricted = true)]
    public class HostSecurityPolicyResolver {
        public virtual HostSecurityPolicyResults ResolvePolicy(Evidence evidence) {
            return HostSecurityPolicyResults.DefaultPolicy;
        }
    }



    internal class LockableAppDomainContext {
        internal HostingEnvironment HostEnv { get; set; }
        internal string PreloadContext { get; set; }
        internal bool RetryingPreload { get; set; }

        internal LockableAppDomainContext() {
        }
    }

    public sealed class ApplicationManager : MarshalByRefObject {

        private const string _clrQuirkAppSettingsAppContextPrefix = "AppContext.SetSwitch:";
        private const string _regexMatchTimeoutKey = "REGEX_DEFAULT_MATCH_TIMEOUT";
        private const string _configBuildersIgnoreLoadFailuresSwitch = "ConfigurationBuilders.IgnoreLoadFailure";   // Keep in sync with System.Configuration
        private static readonly StrongName _mwiV1StrongName = GetMicrosoftWebInfrastructureV1StrongName();

        private static Object _applicationManagerStaticLock = new Object();

        // open count (when last close goes to 0 it shuts down everything)
        int _openCount = 0;
        bool _shutdownInProgress = false;

        // table of app domains (LockableAppDomainContext objects) by app id
        // To simplify per-appdomain synchronization we will never remove LockableAppDomainContext objects from this table even when the AD is unloaded
        // We may need to fix it if profiling shows a noticeable impact on performance
        private Dictionary <string, LockableAppDomainContext> _appDomains = new Dictionary<string, LockableAppDomainContext>(StringComparer.OrdinalIgnoreCase);
        // count of HostingEnvironment instances that is referenced in _appDomains collection
        private int _accessibleHostingEnvCount;

        // could differ from _appDomains or _accessibleHostingEnvCount count (host env is active some time after it is removed)
        private int _activeHostingEnvCount;

        // pending callback to respond to ping (typed as Object to do Interlocked operations)
        private Object _pendingPingCallback;
        // delegate OnRespondToPing
        private WaitCallback _onRespondToPingWaitCallback;

        // flag indicates whether any fatal exception has been recorded
        private bool _fatalExceptionRecorded = false;

        // single instance of app manager
        private static ApplicationManager _theAppManager;

        // store fatal exception to assist debugging
        private static Exception _fatalException = null;

        internal ApplicationManager() {
            _onRespondToPingWaitCallback = new WaitCallback(this.OnRespondToPingWaitCallback);

            // VSWhidbey 555767: Need better logging for unhandled exceptions (http://support.microsoft.com/?id=911816)
            // We only add a handler in the default domain because it will be notified when an unhandled exception 
            // occurs in ANY domain.  
            // WOS 1983175: (weird) only the handler in the default domain is notified when there is an AV in a native module
            // while we're in a call to MgdIndicateCompletion.
            AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(OnUnhandledException);
        }

        internal bool ShutdownInProgress {
            get {
                return _shutdownInProgress;
            }
        }

        private bool FatalExceptionRecorded
        {
            get {
                return _fatalExceptionRecorded;
            }
            set {
                _fatalExceptionRecorded = value;
            }
        }

        internal static void RecordFatalException(Exception e) {
            RecordFatalException(AppDomain.CurrentDomain, e);
        }

        internal static void RecordFatalException(AppDomain appDomain, Exception e) {
            // store the exception from the first caller to assist debugging
            object originalValue = Interlocked.CompareExchange(ref _fatalException, e, null);

            if (originalValue == null) {
                // create event log entry
                Misc.WriteUnhandledExceptionToEventLog(appDomain, e);
            }
        }

        internal static void OnUnhandledException(Object sender, UnhandledExceptionEventArgs eventArgs) {
            // if the CLR is not terminating, ignore the notification
            if (!eventArgs.IsTerminating) {
                return;
            }

            Exception exception = eventArgs.ExceptionObject as Exception;
            if (exception == null) {
                return;
            }

            AppDomain appDomain = sender as AppDomain;
            if (appDomain == null) {
                return;
            }

            // If any fatal exception was recorded in applicaiton AppDomains,
            // we wouldn't record exceptions in the default AppDomain. 
            var appManager = GetApplicationManager();
            if (AppDomain.CurrentDomain.IsDefaultAppDomain() && appManager.FatalExceptionRecorded) {
                return;
            }

            appManager.FatalExceptionRecorded = true;

            RecordFatalException(appDomain, exception);
        }

        public override Object InitializeLifetimeService() {
            return null; // never expire lease
        }

        //
        // public ApplicationManager methods
        //


        public static ApplicationManager GetApplicationManager() {
            if (_theAppManager == null) {
                lock (_applicationManagerStaticLock) {
                    if (_theAppManager == null) {
                        if (HostingEnvironment.IsHosted)
                            _theAppManager = HostingEnvironment.GetApplicationManager();

                        if (_theAppManager == null)
                            _theAppManager = new ApplicationManager();
                    }
                }
            }

            return _theAppManager;
        }


        [SecurityPermission(SecurityAction.Demand, Unrestricted=true)]
        public void Open() {
            Interlocked.Increment(ref _openCount);
        }


        [SecurityPermission(SecurityAction.Demand, Unrestricted = true)]
        public void Close() {
            if (Interlocked.Decrement(ref _openCount) > 0)
                return;

            // need to shutdown everything
            ShutdownAll();
        }

        private string CreateSimpleAppID(VirtualPath virtualPath, string physicalPath, string siteName) {
            // Put together some unique app id
            string appId = String.Concat(virtualPath.VirtualPathString, physicalPath);

            if (!String.IsNullOrEmpty(siteName)) {
                appId = String.Concat(appId, siteName);
            }

            return appId.GetHashCode().ToString("x", CultureInfo.InvariantCulture);
        }

        [SecurityPermission(SecurityAction.Demand, Unrestricted = true)]
        public IRegisteredObject CreateObject(IApplicationHost appHost, Type type) {
            if (appHost == null) {
                throw new ArgumentNullException("appHost");
            }
            if (type == null) {
                throw new ArgumentNullException("type");
            }

            string appID = CreateSimpleAppID(appHost);
            return CreateObjectInternal(appID, type, appHost, false);            
        }

        [SecurityPermission(SecurityAction.Demand, UnmanagedCode=true)]
        public IRegisteredObject CreateObject(String appId, Type type, string virtualPath, string physicalPath, bool failIfExists) {
            return CreateObject(appId, type, virtualPath, physicalPath, failIfExists, false /*throwOnError*/);
        }

        [SecurityPermission(SecurityAction.Demand, Unrestricted = true)]
        public IRegisteredObject CreateObject(String appId, Type type, string virtualPath, string physicalPath,
                                              bool failIfExists, bool throwOnError) {
            // check args
            if (appId == null)
                throw new ArgumentNullException("appId");

            SimpleApplicationHost appHost = new SimpleApplicationHost(VirtualPath.CreateAbsolute(virtualPath), physicalPath);

            // if throw on error flag is set, create hosting parameters accordingly
            HostingEnvironmentParameters hostingParameters = null;

            if (throwOnError) {
                hostingParameters = new HostingEnvironmentParameters();
                hostingParameters.HostingFlags = HostingEnvironmentFlags.ThrowHostingInitErrors;

            }

            // call the internal method
            return CreateObjectInternal(appId, type, appHost, failIfExists, hostingParameters);
        }

        [SecurityPermission(SecurityAction.Demand, Unrestricted = true)]
        internal IRegisteredObject CreateObjectInternal(String appId, Type type, IApplicationHost appHost, bool failIfExists) {
            // check args
            if (appId == null)
                throw new ArgumentNullException("appId");

            if (type == null)
                throw new ArgumentNullException("type");

            if (appHost == null)
                throw new ArgumentNullException("appHost");

            // call the internal method
            return CreateObjectInternal(appId, type, appHost, failIfExists, null /*hostingParameters*/);
        }

        [PermissionSet(SecurityAction.Assert, Unrestricted = true)]
        internal IRegisteredObject CreateObjectInternal(
                                        String appId,
                                        Type type,
                                        IApplicationHost appHost,
                                        bool failIfExists,
                                        HostingEnvironmentParameters hostingParameters) {

            // check that type is as IRegisteredObject
            if (!typeof(IRegisteredObject).IsAssignableFrom(type))
                throw new ArgumentException(SR.GetString(SR.Not_IRegisteredObject, type.FullName), "type");

            // get hosting environment
            HostingEnvironment env = GetAppDomainWithHostingEnvironment(appId, appHost, hostingParameters);

            // create the managed object in the worker app domain
            // When marshaling Type, the AppDomain must have FileIoPermission to the assembly, which is not
            // always the case, so we marshal the assembly qualified name instead
            ObjectHandle h = env.CreateWellKnownObjectInstance(type.AssemblyQualifiedName, failIfExists);
            return (h != null) ? h.Unwrap() as IRegisteredObject : null;
        }

        internal IRegisteredObject CreateObjectWithDefaultAppHostAndAppId(
                                        String physicalPath,
                                        string virtualPath,
                                        Type type,
                                        out String appId,
                                        out IApplicationHost appHost) {
            return CreateObjectWithDefaultAppHostAndAppId(physicalPath,
                VirtualPath.CreateNonRelative(virtualPath), type, out appId, out appHost);
        }

        internal IRegisteredObject CreateObjectWithDefaultAppHostAndAppId(
                                        String physicalPath,
                                        VirtualPath virtualPath,
                                        Type type,
                                        out String appId,
                                        out IApplicationHost appHost) {

            HostingEnvironmentParameters hostingParameters = new HostingEnvironmentParameters();
            hostingParameters.HostingFlags = HostingEnvironmentFlags.DontCallAppInitialize;

            return CreateObjectWithDefaultAppHostAndAppId(
                        physicalPath,
                        virtualPath,
                        type,
                        false,
                        hostingParameters,
                        out appId,
                        out appHost);
        }

        internal IRegisteredObject CreateObjectWithDefaultAppHostAndAppId(
                                        String physicalPath,
                                        VirtualPath virtualPath,
                                        Type type,
                                        bool failIfExists,
                                        HostingEnvironmentParameters hostingParameters,
                                        out String appId,
                                        out IApplicationHost appHost) {

#if !FEATURE_PAL // FEATURE_PAL does not enable IIS-based hosting features
            if (physicalPath == null) { 

                // If the physical path is null, we use an ISAPIApplicationHost based
                // on the virtual path (or metabase id).

                // Make sure the static HttpRuntime is created so isapi assembly can be loaded properly.
                HttpRuntime.ForceStaticInit();

                ISAPIApplicationHost isapiAppHost = new ISAPIApplicationHost(virtualPath.VirtualPathString, null, true, null, hostingParameters.IISExpressVersion);

                appHost = isapiAppHost;
                appId = isapiAppHost.AppId;
                virtualPath = VirtualPath.Create(appHost.GetVirtualPath());
                physicalPath = FileUtil.FixUpPhysicalDirectory(appHost.GetPhysicalPath());
            }
            else {
#endif // !FEATURE_PAL
                // If the physical path was passed in, don't use an Isapi host. Instead,
                // use a simple app host which does simple virtual to physical mappings

                // Put together some unique app id
                appId = CreateSimpleAppID(virtualPath, physicalPath, null);

                appHost = new SimpleApplicationHost(virtualPath, physicalPath);
            }

            string precompTargetPhysicalDir = hostingParameters.PrecompilationTargetPhysicalDirectory;
            if (precompTargetPhysicalDir != null) {
                // Change the appID so we use a different codegendir in precompile for deployment scenario,
                // this ensures we don't use or pollute the regular codegen files.  Also, use different
                // ID's depending on whether the precompilation is Updatable (VSWhidbey 383239)
                if ((hostingParameters.ClientBuildManagerParameter != null) && 
                    (hostingParameters.ClientBuildManagerParameter.PrecompilationFlags & PrecompilationFlags.Updatable) == 0)
                    appId = appId + "_precompile";
                else
                    appId = appId + "_precompile_u";
            }

            return CreateObjectInternal(appId, type, appHost, failIfExists, hostingParameters);
        }


        [SecurityPermission(SecurityAction.Demand, Unrestricted = true)]
        public IRegisteredObject GetObject(String appId, Type type) {
            // check args
            if (appId == null)
                throw new ArgumentNullException("appId");
            if (type == null)
                throw new ArgumentNullException("type");

            LockableAppDomainContext ac = GetLockableAppDomainContext(appId);
            lock (ac) {
                HostingEnvironment env = ac.HostEnv;
                if (env == null)
                    return null;

                // find the instance by type
                // When marshaling Type, the AppDomain must have FileIoPermission to the assembly, which is not
                // always the case, so we marshal the assembly qualified name instead
                ObjectHandle h = env.FindWellKnownObject(type.AssemblyQualifiedName);
                return (h != null) ? h.Unwrap() as IRegisteredObject : null;
            }
        }

        [SecurityPermission(SecurityAction.Demand, Unrestricted = true)]
        public AppDomain GetAppDomain(string appId) {
            if (appId == null) {
                throw new ArgumentNullException("appId");
            }

            LockableAppDomainContext ac = GetLockableAppDomainContext(appId);
            lock (ac) {
                HostingEnvironment env = ac.HostEnv;
                if (env == null) {
                    return null;
                }

                return env.HostedAppDomain;
            }
        }

        public AppDomain GetAppDomain(IApplicationHost appHost) {
            if (appHost == null) {
                throw new ArgumentNullException("appHost");
            }
            string appID = CreateSimpleAppID(appHost);
            return GetAppDomain(appID);
        }

        internal AppDomain GetDefaultAppDomain() {
            return AppDomain.CurrentDomain;
        }

        [SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands", Justification = "This isn't a dangerous method.")]
        private string CreateSimpleAppID(IApplicationHost appHost) {
            if (appHost == null) {
                throw new ArgumentNullException("appHost");
            }
            return CreateSimpleAppID(VirtualPath.Create(appHost.GetVirtualPath()),
                                     appHost.GetPhysicalPath(), appHost.GetSiteName());
        }
        

        // if a "well-known" object of the specified type already exists in the application,
        // remove the app from the managed application table.  This is
        // used in IIS7 integrated mode when IIS7 determines that it is necessary to create
        // a new application and shutdown the old one.
        internal void RemoveFromTableIfRuntimeExists(String appId, Type runtimeType) {
            // check args
            if (appId == null)
                throw new ArgumentNullException("appId");
            if (runtimeType == null)
                throw new ArgumentNullException("runtimeType");

            LockableAppDomainContext ac = GetLockableAppDomainContext(appId);
            lock (ac) {
                // get hosting environment
                HostingEnvironment env = ac.HostEnv;
                if (env == null)
                    return;

                // find the instance by type
                // When marshaling Type, the AppDomain must have FileIoPermission to the assembly, which is not
                // always the case, so we marshal the assembly qualified name instead
                ObjectHandle h = env.FindWellKnownObject(runtimeType.AssemblyQualifiedName);
                if (h != null)
                {
                    // ensure that it is removed from _appDomains by calling
                    // HostingEnvironmentShutdownInitiated directly.
                    HostingEnvironmentShutdownInitiated(appId, env);
                }
            }
        }

        [SecurityPermission(SecurityAction.Demand, Unrestricted = true)]
        public void StopObject(String appId, Type type) {
            // check args
            if (appId == null)
                throw new ArgumentNullException("appId");
            if (type == null)
                throw new ArgumentNullException("type");

            LockableAppDomainContext ac = GetLockableAppDomainContext(appId);
            lock (ac) {
                HostingEnvironment env = ac.HostEnv;
                if (env != null) {
                    // When marshaling Type, the AppDomain must have FileIoPermission to the assembly, which is not
                    // always the case, so we marshal the assembly qualified name instead
                    env.StopWellKnownObject(type.AssemblyQualifiedName);
                }
            }
        }


        public bool IsIdle() {
            Dictionary<string, LockableAppDomainContext> apps = CloneAppDomainsCollection();

            foreach (LockableAppDomainContext ac in apps.Values) {
                lock (ac) {
                    HostingEnvironment env = ac.HostEnv;
                    bool idle = (null == env) ? true : env.IsIdle();

                    if (!idle)
                        return false;
                }
            }

            return true;
        }


        [SecurityPermission(SecurityAction.Demand, Unrestricted = true)]
        public void ShutdownApplication(String appId) {
            if (appId == null)
                throw new ArgumentNullException("appId");

            LockableAppDomainContext ac = GetLockableAppDomainContext(appId);
            lock (ac) {
                if (ac.HostEnv != null) {
                    ac.HostEnv.InitiateShutdownInternal();
                }
            }
        }


        [SecurityPermission(SecurityAction.Demand, Unrestricted = true)]
        public void ShutdownAll() {
            _shutdownInProgress = true;
            Dictionary <string, LockableAppDomainContext> oldTable = null;

            lock (this) {
                oldTable = _appDomains;
                // don't keep references to hosting environments anymore
                _appDomains = new Dictionary<string, LockableAppDomainContext>(StringComparer.OrdinalIgnoreCase);
            }


            foreach (KeyValuePair <string, LockableAppDomainContext> p in oldTable) {
                LockableAppDomainContext ac = p.Value;
                lock (ac) {
                    HostingEnvironment env = ac.HostEnv;
                    if (null != env) {
                        env.InitiateShutdownInternal();
                    }
                }
            }
        
            for (int iter=0; _activeHostingEnvCount > 0 && iter < 3000; iter++) // Wait at most 5 minutes
                Thread.Sleep(100);
        }


        [SecurityPermission(SecurityAction.Demand, Unrestricted = true)]
        public ApplicationInfo[] GetRunningApplications() {
            ArrayList appList = new ArrayList();

            Dictionary<string, LockableAppDomainContext> apps = CloneAppDomainsCollection();

            foreach (LockableAppDomainContext ac in apps.Values) {
                lock (ac) {
                    HostingEnvironment env = ac.HostEnv;
                    if (env != null) {
                        appList.Add(env.GetApplicationInfo());
                    }
                }
            }

            int n = appList.Count;
            ApplicationInfo[] result = new ApplicationInfo[n];

            if (n > 0) {
                appList.CopyTo(result);
            }

            return result;
        }

        [SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands", Justification = "This method fails due to serialization issues if not called by ASP.NET.")]
        internal AppDomainInfo [] GetAppDomainInfos()
        {
            ArrayList appList = new ArrayList();
            Dictionary<string, LockableAppDomainContext> apps = CloneAppDomainsCollection();

            foreach (LockableAppDomainContext ac in apps.Values) {
                lock (ac) {
                    HostingEnvironment hostEnv = ac.HostEnv;
                    if (hostEnv == null) {
                        continue;
                    }

                    IApplicationHost appHost = hostEnv.InternalApplicationHost;
                    ApplicationInfo appInfo = hostEnv.GetApplicationInfo();
                    int siteId = 0;

                    if (appHost != null) {
                        try {
                            siteId = Int32.Parse(appHost.GetSiteID(), CultureInfo.InvariantCulture);
                        }
                        catch {
                        }
                    }

                    AppDomainInfo appDomainInfo = new AppDomainInfo(appInfo.ID,
                                                      appInfo.VirtualPath,
                                                      appInfo.PhysicalPath,
                                                      siteId,
                                                      hostEnv.GetIdleValue());

                    appList.Add(appDomainInfo);
                }
            }

            return (AppDomainInfo[]) appList.ToArray(typeof(AppDomainInfo));
        }

        //
        // APIs for the process host to suspend / resume all running applications
        //

        [SuppressMessage("Microsoft.Reliability", "CA2002:DoNotLockOnObjectsWithWeakIdentity", Justification = "'this' is never a MBRO proxy object.")]
        internal object SuspendAllApplications() {
            LockableAppDomainContext[] allAppDomainContexts;

            lock (this) {
                allAppDomainContexts = _appDomains.Values.ToArray();
            }

            ApplicationResumeStateContainer[] resumeContainers = Task.WhenAll(allAppDomainContexts.Select(CreateSuspendTask)).Result;
            return resumeContainers;
        }

        private static Task<ApplicationResumeStateContainer> _dummyCompletedSuspendTask = Task.FromResult<ApplicationResumeStateContainer>(null);
        private static Task<ApplicationResumeStateContainer> CreateSuspendTask(LockableAppDomainContext appDomainContext) {
            // dictionary contained a null entry?
            if (appDomainContext == null) {
                return _dummyCompletedSuspendTask;
            }

            HostingEnvironment hostEnv;
            lock (appDomainContext) {
                hostEnv = appDomainContext.HostEnv;
            }

            // Quick check: is this a dummy context that had no associated application?
            if (hostEnv == null) {
                return _dummyCompletedSuspendTask;
            }

            // QUWI since we want to run each application's suspend method in parallel.
            // Unsafe since we don't care about impersonation, identity, etc.
            // Don't use Task.Run since it captures the EC and could execute inline.
            TaskCompletionSource<ApplicationResumeStateContainer> tcs = new TaskCompletionSource<ApplicationResumeStateContainer>();
            ThreadPool.UnsafeQueueUserWorkItem(_ => {

                // We're not locking on the appDomainContext here. The reason for this is two-fold:
                // a) We don't want to cause a potential deadlock issue whereby Suspend could kick
                //    off user code that tries calling InitiateShutdown and thus taking a lock on
                //    appDomainContext.
                // b) It's easier to try calling into the captured HostingEnvironment and just
                //    ---- the "no AD" exception than it is to try to synchronize the Suspend,
                //    Resume, and Stop methods. The CLR protects us from ourselves here.
                //
                // We need to use the captured 'hostEnv' to prevent null refs.

                IntPtr state;
                try {
                    state = hostEnv.SuspendApplication();
                }
                catch (AppDomainUnloadedException) {
                    // AD unloads aren't considered a failure
                    tcs.TrySetResult(null);
                    return;
                }

                tcs.TrySetResult(new ApplicationResumeStateContainer(hostEnv, state));
            }, null);
            return tcs.Task;
        }

        internal void ResumeAllApplications(object state) {
            foreach (var resumeContainer in (ApplicationResumeStateContainer[])state) {
                if (resumeContainer != null) { // could be null if the application went away
                    resumeContainer.Resume();
                }
            }
        }

        //
        // ping implementation
        //

        // called from process host
        internal void Ping(IProcessPingCallback callback) {
            if (callback == null || _pendingPingCallback != null)
                return;

            // remember active callback but only if none is remembered already
            if (Interlocked.CompareExchange(ref _pendingPingCallback, callback, null) == null) {
                // queue a work item to respond to ping
                ThreadPool.QueueUserWorkItem(_onRespondToPingWaitCallback);
            }
        }

        // threadpool callback (also called on some activity from hosting environment)
        internal void OnRespondToPingWaitCallback(Object state) {
            RespondToPingIfNeeded();
        }

        // respond to ping on callback
        internal void RespondToPingIfNeeded() {
            IProcessPingCallback callback = _pendingPingCallback as IProcessPingCallback;

            // make sure we call the callback once
            if (callback != null) {
                if (Interlocked.CompareExchange(ref _pendingPingCallback, null, callback) == callback) {
                    callback.Respond();
                }
            }
        }

        // ApplicationManager is loaded into the default AppDomain
        // ASP.NET doesn't set string hash randomization for the defaul AppDomain, so we can assume the existing CLR implementation here is unchanged
        // Note, it won't work if <runtime/UseRandomizedStringHashAlgorithm enabled="1"> is used, because the entire process is subject to string hash randomization
        internal int GetNonRandomizedStringComparerHashCode(string s, bool ignoreCase) { 
            StringComparer comparer = ignoreCase ? StringComparer.InvariantCultureIgnoreCase : StringComparer.InvariantCulture;
            return comparer.GetHashCode(s);
        }

        //
        // communication with hosting environments
        //

        internal void HostingEnvironmentActivated() {
            int count = Interlocked.Increment(ref _activeHostingEnvCount);
        }

        internal void HostingEnvironmentShutdownComplete(String appId, IApplicationHost appHost) {
            try {
                if (appHost != null) {
                    // make sure application host can be GC'd
                    MarshalByRefObject realApplicationHost = appHost as MarshalByRefObject;
                    if (realApplicationHost != null) {
                        RemotingServices.Disconnect(realApplicationHost);
                    }
                }
            }
            finally {
                Interlocked.Decrement(ref _activeHostingEnvCount);
            }
        }

        internal void HostingEnvironmentShutdownInitiated(String appId, HostingEnvironment env) {
            if (!_shutdownInProgress) { // don't bother during shutdown (while enumerating)
                LockableAppDomainContext ac = GetLockableAppDomainContext (appId);

                lock (ac){
                    if (!env.HasBeenRemovedFromAppManagerTable) {
                        env.HasBeenRemovedFromAppManagerTable = true;

                        ac.HostEnv = null;
                        Interlocked.Decrement(ref _accessibleHostingEnvCount);

                        // Autorestart the application right away
                        if (ac.PreloadContext != null && !ac.RetryingPreload) {
                            ProcessHost.PreloadApplicationIfNotShuttingdown(appId, ac);
                        }
                    }
                }
            }
        }

        internal int AppDomainsCount {
            get { return _accessibleHostingEnvCount; }
        }


        internal void ReduceAppDomainsCount(int limit) {
            // 




            Dictionary<string, LockableAppDomainContext> apps = CloneAppDomainsCollection();
            while (_accessibleHostingEnvCount >= limit && !_shutdownInProgress)
            {
                LockableAppDomainContext bestCandidateForShutdown = null;
                int bestCandidateLruScore = 0;
                
                foreach (LockableAppDomainContext ac in apps.Values) {
                    // Don't lock on LockableAppDomainContext before we check that ac.HostEnv != null.
                    // Otherwise we may end up with a deadlock between 2 app domains trying to unload each other
                    HostingEnvironment h = ac.HostEnv;
                    if (h == null) {
                        continue;
                    }
                    lock (ac) {
                        h = ac.HostEnv;

                        // Avoid ---- by checking again under lock
                        if (h == null) {
                            continue;
                        }
                        int newLruScore = h.LruScore;

                        if (bestCandidateForShutdown == null || bestCandidateForShutdown.HostEnv == null || 
                                newLruScore < bestCandidateLruScore) {

                            bestCandidateLruScore = newLruScore;
                            bestCandidateForShutdown = ac;
                        }
                    }
                }

                if (bestCandidateForShutdown == null)
                    break;

                lock (bestCandidateForShutdown) {
                    if (bestCandidateForShutdown.HostEnv != null) {
                        bestCandidateForShutdown.HostEnv.InitiateShutdownInternal();
                    }
                }
            }
        }

        //
        // helper to support legacy APIs (AppHost.CreateAppHost)
        //

        internal ObjectHandle CreateInstanceInNewWorkerAppDomain(
                                Type type,
                                String appId,
                                VirtualPath virtualPath,
                                String physicalPath) {

            Debug.Trace("AppManager", "CreateObjectInNewWorkerAppDomain, type=" + type.FullName);

            IApplicationHost appHost = new SimpleApplicationHost(virtualPath, physicalPath);

            HostingEnvironmentParameters hostingParameters = new HostingEnvironmentParameters();
            hostingParameters.HostingFlags = HostingEnvironmentFlags.HideFromAppManager;

            HostingEnvironment env = CreateAppDomainWithHostingEnvironmentAndReportErrors(appId, appHost, hostingParameters);
            // When marshaling Type, the AppDomain must have FileIoPermission to the assembly, which is not
            // always the case, so we marshal the assembly qualified name instead
            return env.CreateInstance(type.AssemblyQualifiedName);
        }

        //
        // helpers to facilitate app domain creation
        //
        private HostingEnvironment GetAppDomainWithHostingEnvironment(String appId, IApplicationHost appHost, HostingEnvironmentParameters hostingParameters) {
            LockableAppDomainContext ac = GetLockableAppDomainContext (appId);

            lock (ac) {
                HostingEnvironment env = ac.HostEnv;

                if (env != null) {
                    try {
                        env.IsUnloaded();
                    } catch(AppDomainUnloadedException) {
                        env = null;
                    }
                }
                if (env == null) {
                    env = CreateAppDomainWithHostingEnvironmentAndReportErrors(appId, appHost, hostingParameters);
                    ac.HostEnv = env;
                    Interlocked.Increment(ref _accessibleHostingEnvCount);
                }

                return env;
            }
           
        }

        private HostingEnvironment CreateAppDomainWithHostingEnvironmentAndReportErrors(
                                        String appId,
                                        IApplicationHost appHost,
                                        HostingEnvironmentParameters hostingParameters) {
            try {
                return CreateAppDomainWithHostingEnvironment(appId, appHost, hostingParameters);
            }
            catch (Exception e) {
                Misc.ReportUnhandledException(e, new string[] {SR.GetString(SR.Failed_to_initialize_AppDomain), appId});
                throw;
            }
        }

        [SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands", Justification = "We carefully control the callers.")]
        [SuppressMessage("Microsoft.Usage", "CA1806:DoNotIgnoreMethodResults", MessageId = "System.Boolean.TryParse(System.String,System.Boolean@)", Justification = "Sets parameter to default(bool) on conversion failure, which is semantic we need.")]
        private HostingEnvironment CreateAppDomainWithHostingEnvironment(
                                                String appId,
                                                IApplicationHost appHost,
                                                HostingEnvironmentParameters hostingParameters) {

            String physicalPath = appHost.GetPhysicalPath();
            if (!StringUtil.StringEndsWith(physicalPath, Path.DirectorySeparatorChar))
                physicalPath = physicalPath + Path.DirectorySeparatorChar;

            String domainId = ConstructAppDomainId(appId);
            String appName = (StringUtil.GetStringHashCode(String.Concat(appId.ToLower(CultureInfo.InvariantCulture),
                physicalPath.ToLower(CultureInfo.InvariantCulture)))).ToString("x", CultureInfo.InvariantCulture);
            VirtualPath virtualPath = VirtualPath.Create(appHost.GetVirtualPath());

            Debug.Trace("AppManager", "CreateAppDomainWithHostingEnvironment, path=" + physicalPath + "; appId=" + appId + "; domainId=" + domainId);

            IDictionary bindings = new Hashtable(20);
            AppDomainSetup setup = new AppDomainSetup();
            AppDomainSwitches switches = new AppDomainSwitches();
            PopulateDomainBindings(domainId, appId, appName, physicalPath, virtualPath, setup, bindings);

            //  Create the app domain

            AppDomain appDomain = null;
            Dictionary<string, object> appDomainAdditionalData = new Dictionary<string, object>();
            Exception appDomainCreationException = null;

            string siteID = appHost.GetSiteID();
            string appSegment = virtualPath.VirtualPathStringNoTrailingSlash;
            bool inClientBuildManager = false;
            Configuration appConfig = null;
            PolicyLevel policyLevel = null;
            PermissionSet permissionSet = null;
            List<StrongName> fullTrustAssemblies = new List<StrongName>();
            string[] defaultPartialTrustVisibleAssemblies = new[] { "System.Web, PublicKey=002400000480000094000000060200000024000052534131000400000100010007d1fa57c4aed9f0a32e84aa0faefd0de9e8fd6aec8f87fb03766c834c99921eb23be79ad9d5dcc1dd9ad236132102900b723cf980957fc4e177108fc607774f29e8320e92ea05ece4e821c0a5efe8f1645c4c0c93c1ab99285d622caa652c1dfad63d745d6f2de5f17e5eaf0fc4963d261c8a12436518206dc093344d5ad293",
                                                                    "System.Web.Extensions, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9",
                                                                    "System.Web.Abstractions, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9",
                                                                    "System.Web.Routing, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9",
                                                                    "System.Web.DynamicData, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9",
                                                                    "System.Web.DataVisualization, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9",
                                                                    "System.Web.ApplicationServices, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9" };

            Exception appDomainStartupConfigurationException = null;
            ImpersonationContext ictxConfig = null;
            IntPtr uncTokenConfig = IntPtr.Zero;
            HostingEnvironmentFlags hostingFlags = HostingEnvironmentFlags.Default;
            if (hostingParameters != null) {
                hostingFlags = hostingParameters.HostingFlags;
                if ((hostingFlags & HostingEnvironmentFlags.ClientBuildManager) != 0) {
                    inClientBuildManager = true;
                    // The default hosting policy in VS has changed (from MultiDomainHost to MultiDomain), 
                    // so we need to specify explicitly to allow generated assemblies 
                    // to be unloaded subsequently. (Dev10 bug)
                    setup.LoaderOptimization = LoaderOptimization.MultiDomainHost;
                }
            }
            try {
                bool requireHostExecutionContextManager = false;
                bool requireHostSecurityManager = false;

                AppDomain.CurrentDomain.SetData(_configBuildersIgnoreLoadFailuresSwitch, true);

                uncTokenConfig = appHost.GetConfigToken();
                if (uncTokenConfig != IntPtr.Zero) {
                    ictxConfig = new ImpersonationContext(uncTokenConfig);
                }

                try {
                    // Did the custom loader fail to load?
                    ExceptionDispatchInfo customLoaderException = ProcessHost.GetExistingCustomLoaderFailureAndClear(appId);
                    if (customLoaderException != null) {
                        customLoaderException.Throw();
                    }

                    // We support randomized string hash code, but not for the default AppDomain
                    // Don't allow string hash randomization for the defaul AppDomain (i.e. <runtime/UseRandomizedStringHashAlgorithm enabled="1">)
                    // Application should use AppSettings instead to opt-in.
                    if (EnvironmentInfo.IsStringHashCodeRandomizationDetected) {
                        throw new ConfigurationErrorsException(SR.GetString(SR.Require_stable_string_hash_codes));
                    }

                    bool skipAdditionalConfigChecks = false;
                    if (inClientBuildManager && hostingParameters.IISExpressVersion != null) {
                        permissionSet = new PermissionSet(PermissionState.Unrestricted);
                        setup.PartialTrustVisibleAssemblies = defaultPartialTrustVisibleAssemblies;
                        appConfig = GetAppConfigIISExpress(siteID, appSegment, hostingParameters.IISExpressVersion);
                        skipAdditionalConfigChecks = true;
                    }
                    else {
                        //Hosted by IIS, we already have an IISMap.
                        if (appHost is ISAPIApplicationHost) {
                            string cacheKey = System.Web.Caching.CacheInternal.PrefixMapPath + siteID + virtualPath.VirtualPathString;
                            MapPathCacheInfo cacheInfo = (MapPathCacheInfo)HttpRuntime.Cache.InternalCache.Remove(cacheKey);
                            appConfig = WebConfigurationManager.OpenWebConfiguration(appSegment, siteID);
                        }
                        // For non-IIS hosting scenarios, we need to get config map from application host in a generic way.
                        else {
                            appConfig = GetAppConfigGeneric(appHost, siteID, appSegment, virtualPath, physicalPath);
                        }
                    }

                    HttpRuntimeSection httpRuntimeSection = (HttpRuntimeSection)appConfig.GetSection("system.web/httpRuntime");
                    if (httpRuntimeSection == null) {
                        throw new ConfigurationErrorsException(SR.GetString(SR.Config_section_not_present, "httpRuntime"));
                    }

                    // DevDiv #403846 - Change certain config defaults if <httpRuntime targetFramework="4.5" /> exists in config.
                    // We store this information in the AppDomain data because certain configuration sections (like <compilation>)
                    // are loaded before config is "baked" in the child AppDomain, and if we make <compilation> and other sections
                    // dependent on <httpRuntime> which may not have been loaded yet, we risk introducing ----s. Putting this value
                    // in the AppDomain data guarantees that it is available before the first call to the config system.
                    FrameworkName targetFrameworkName = httpRuntimeSection.GetTargetFrameworkName();
                    if (targetFrameworkName != null) {
                        appDomainAdditionalData[System.Web.Util.BinaryCompatibility.TargetFrameworkKey] = targetFrameworkName;
                    }

                    if (!skipAdditionalConfigChecks) {
                        // DevDiv #71268 - Add <httpRuntime defaultRegexMatchTimeout="HH:MM:SS" /> configuration attribute
                        if (httpRuntimeSection.DefaultRegexMatchTimeout != TimeSpan.Zero) {
                            appDomainAdditionalData[_regexMatchTimeoutKey] = httpRuntimeSection.DefaultRegexMatchTimeout;
                        }

                        // DevDiv #258274 - Add support for CLR quirks mode to ASP.NET
                        if (targetFrameworkName != null) {
                            setup.TargetFrameworkName = targetFrameworkName.ToString();
                        }

                        // DevDiv #286354 - Having a Task-friendly SynchronizationContext requires overriding the AppDomain's HostExecutionContextManager.
                        // DevDiv #403846 - If we can't parse the <appSettings> switch, use the <httpRuntime/targetFramework> setting to determine the default.
                        AppSettingsSection appSettingsSection = appConfig.AppSettings;
                        KeyValueConfigurationElement useTaskFriendlySynchronizationContextElement = appSettingsSection.Settings["aspnet:UseTaskFriendlySynchronizationContext"];
                        if (!(useTaskFriendlySynchronizationContextElement != null && Boolean.TryParse(useTaskFriendlySynchronizationContextElement.Value, out requireHostExecutionContextManager))) {
                            requireHostExecutionContextManager = new System.Web.Util.BinaryCompatibility(targetFrameworkName).TargetsAtLeastFramework45 ? true : false;
                        }

                        // DevDiv #390704 - Add support for randomized string hash algorithm
                        KeyValueConfigurationElement useRandomizedStringHashAlgorithmElement = appSettingsSection.Settings["aspnet:UseRandomizedStringHashAlgorithm"];
                        bool useRandomizedStringHashAlgorithm = false;
                        if (useRandomizedStringHashAlgorithmElement != null && Boolean.TryParse(useRandomizedStringHashAlgorithmElement.Value, out useRandomizedStringHashAlgorithm)) {
                            switches.UseRandomizedStringHashAlgorithm = useRandomizedStringHashAlgorithm;
                        }

                        // DevDiv #1041102 - Allow specifying quirks via <appSettings> switches
                        // The keys must begin with "AppContext.SetSwitch" and have a non-zero key name length,
                        // and the values must be parseable as Booleans.
                        Dictionary<string, bool> clrQuirks = null;
                        foreach (KeyValueConfigurationElement element in appSettingsSection.Settings) {
                            if (element.Key != null && element.Key.Length > _clrQuirkAppSettingsAppContextPrefix.Length && element.Key.StartsWith(_clrQuirkAppSettingsAppContextPrefix, StringComparison.OrdinalIgnoreCase)) {
                                bool value;
                                if (Boolean.TryParse(element.Value, out value)) {
                                    if (clrQuirks == null) {
                                        clrQuirks = new Dictionary<string, bool>();
                                    }
                                    
                                    clrQuirks[element.Key.Substring(_clrQuirkAppSettingsAppContextPrefix.Length)] = value;
                                }
                            }
                        }
                        
                        if (clrQuirks != null && clrQuirks.Count > 0) {
                            if (hostingParameters == null) {
                                hostingParameters = new HostingEnvironmentParameters();
                            }
                            
                            hostingParameters.ClrQuirksSwitches = clrQuirks.ToArray();
                        }

                        // DevDiv #248126 - Allow configuration of FileChangeMonitor behavior
                        if (httpRuntimeSection.FcnMode != FcnMode.NotSet) {
                            if (hostingParameters == null) {
                                hostingParameters = new HostingEnvironmentParameters();
                            }
                            hostingParameters.FcnMode = httpRuntimeSection.FcnMode;
                        }

                        // DevDiv #322858 - Allow FileChangesMonitor to skip reading DACLs as a perf improvement
                        KeyValueConfigurationElement disableFcnDaclReadElement = appSettingsSection.Settings["aspnet:DisableFcnDaclRead"];
                        if (disableFcnDaclReadElement != null) {
                            bool skipReadingAndCachingDacls;
                            Boolean.TryParse(disableFcnDaclReadElement.Value, out skipReadingAndCachingDacls);
                            if (skipReadingAndCachingDacls) {
                                if (hostingParameters == null) {
                                    hostingParameters = new HostingEnvironmentParameters();
                                }
                                hostingParameters.FcnSkipReadAndCacheDacls = true;
                            }
                        }

                        // Allow apps to use their own CacheStoreProvider implementations
                        CacheSection cacheConfig = (CacheSection)appConfig.GetSection("system.web/caching/cache");
                        if (cacheConfig != null && cacheConfig.DefaultProvider != null && !String.IsNullOrWhiteSpace(cacheConfig.DefaultProvider)) {
                            ProviderSettingsCollection cacheProviders = cacheConfig.Providers;
                            if (cacheProviders == null || cacheProviders.Count < 1) {
                                throw new ProviderException(SR.GetString(SR.Def_provider_not_found));
                            }

                            ProviderSettings cacheProviderSettings = cacheProviders[cacheConfig.DefaultProvider];
                            if (cacheProviderSettings == null) {
                                throw new ProviderException(SR.GetString(SR.Def_provider_not_found));
                            } else {
                                NameValueCollection settings = cacheProviderSettings.Parameters;
                                settings["name"] = cacheProviderSettings.Name;
                                settings["type"] = cacheProviderSettings.Type;
                                appDomainAdditionalData[".defaultObjectCacheProvider"] = settings;
                            }
                        }

                        // If we were launched from a development environment, we might want to enable the application to do things
                        // it otherwise wouldn't normally allow, such as enabling an administrative control panel. For security reasons,
                        // we only do this check if <deployment retail="false" /> [the default value] is specified, since the
                        // <deployment> element can only be set at machine-level in a hosted environment.
                        DeploymentSection deploymentSection = (DeploymentSection)appConfig.GetSection("system.web/deployment");
                        bool isDevEnvironment = false;
                        if (deploymentSection != null && !deploymentSection.Retail && EnvironmentInfo.WasLaunchedFromDevelopmentEnvironment) {
                            appDomainAdditionalData[".devEnvironment"] = true;
                            isDevEnvironment = true;

                            // DevDiv #275724 - Allow LocalDB support in partial trust scenarios
                            // Normally LocalDB requires full trust since it's the equivalent of unmanaged code execution. If this is
                            // a development environment and not a retail deployment, we can assume that the user developing the
                            // application is actually in charge of the host, so we can trust him with LocalDB execution.
                            // Technically this also means that the developer could have set <trust level="Full" /> in his application,
                            // but he might want to deploy his application on a Medium-trust server and thus test how the rest of his
                            // application works in a partial trust environment. (He would use SQL in production, whch is safe in
                            // partial trust.)
                            appDomainAdditionalData["ALLOW_LOCALDB_IN_PARTIAL_TRUST"] = true;
                        }

                        TrustSection trustSection = (TrustSection)appConfig.GetSection("system.web/trust");
                        if (trustSection == null || String.IsNullOrEmpty(trustSection.Level)) {
                            throw new ConfigurationErrorsException(SR.GetString(SR.Config_section_not_present, "trust"));
                        }

                        switches.UseLegacyCas = trustSection.LegacyCasModel;

                        if (inClientBuildManager) {
                            permissionSet = new PermissionSet(PermissionState.Unrestricted);
                            setup.PartialTrustVisibleAssemblies = defaultPartialTrustVisibleAssemblies;
                        }
                        else {
                            if (!switches.UseLegacyCas) {
                                if (trustSection.Level == "Full") {
                                    permissionSet = new PermissionSet(PermissionState.Unrestricted);
                                    setup.PartialTrustVisibleAssemblies = defaultPartialTrustVisibleAssemblies;
                                }
                                else {
                                    SecurityPolicySection securityPolicySection = (SecurityPolicySection)appConfig.GetSection("system.web/securityPolicy");
                                    CompilationSection compilationSection = (CompilationSection)appConfig.GetSection("system.web/compilation");
                                    FullTrustAssembliesSection fullTrustAssembliesSection = (FullTrustAssembliesSection)appConfig.GetSection("system.web/fullTrustAssemblies");
                                    policyLevel = GetPartialTrustPolicyLevel(trustSection, securityPolicySection, compilationSection, physicalPath, virtualPath, isDevEnvironment);
                                    permissionSet = policyLevel.GetNamedPermissionSet(trustSection.PermissionSetName);
                                    if (permissionSet == null) {
                                        throw new ConfigurationErrorsException(SR.GetString(SR.Permission_set_not_found, trustSection.PermissionSetName));
                                    }

                                    // read full trust assemblies and populate the strong name list
                                    if (fullTrustAssembliesSection != null) {
                                        FullTrustAssemblyCollection fullTrustAssembliesCollection = fullTrustAssembliesSection.FullTrustAssemblies;
                                        if (fullTrustAssembliesCollection != null) {
                                            fullTrustAssemblies.AddRange(from FullTrustAssembly fta in fullTrustAssembliesCollection
                                                                         select CreateStrongName(fta.AssemblyName, fta.Version, fta.PublicKey));
                                        }
                                    }

                                    // DevDiv #27645 - We need to add future versions of Microsoft.Web.Infrastructure to <fullTrustAssemblies> so that ASP.NET
                                    // can version out-of-band releases. We should only do this if V1 of M.W.I is listed.
                                    if (fullTrustAssemblies.Contains(_mwiV1StrongName)) {
                                        fullTrustAssemblies.AddRange(CreateFutureMicrosoftWebInfrastructureStrongNames());
                                    }

                                    // Partial-trust AppDomains using a non-legacy CAS model require our special HostSecurityManager
                                    requireHostSecurityManager = true;
                                }
                            }
                            if (trustSection.Level != "Full") {
                                PartialTrustVisibleAssembliesSection partialTrustVisibleAssembliesSection = (PartialTrustVisibleAssembliesSection)appConfig.GetSection("system.web/partialTrustVisibleAssemblies");
                                string[] partialTrustVisibleAssemblies = null;
                                if (partialTrustVisibleAssembliesSection != null) {
                                    PartialTrustVisibleAssemblyCollection partialTrustVisibleAssembliesCollection = partialTrustVisibleAssembliesSection.PartialTrustVisibleAssemblies;
                                    if (partialTrustVisibleAssembliesCollection != null && partialTrustVisibleAssembliesCollection.Count != 0) {
                                        partialTrustVisibleAssemblies = new string[partialTrustVisibleAssembliesCollection.Count + defaultPartialTrustVisibleAssemblies.Length];
                                        for (int i = 0; i < partialTrustVisibleAssembliesCollection.Count; i++) {
                                            partialTrustVisibleAssemblies[i] = partialTrustVisibleAssembliesCollection[i].AssemblyName +
                                                ", PublicKey=" +
                                                NormalizePublicKeyBlob(partialTrustVisibleAssembliesCollection[i].PublicKey);
                                        }
                                        defaultPartialTrustVisibleAssemblies.CopyTo(partialTrustVisibleAssemblies, partialTrustVisibleAssembliesCollection.Count);
                                    }
                                }
                                if (partialTrustVisibleAssemblies == null) {
                                    partialTrustVisibleAssemblies = defaultPartialTrustVisibleAssemblies;
                                }
                                setup.PartialTrustVisibleAssemblies = partialTrustVisibleAssemblies;
                            }
                        }
                    }
                }
                catch (Exception e) {
                    appDomainStartupConfigurationException = e;
                    permissionSet = new PermissionSet(PermissionState.Unrestricted);
                }

                // Set the AppDomainManager if needed
                Type appDomainManagerType = AspNetAppDomainManager.GetAspNetAppDomainManagerType(requireHostExecutionContextManager, requireHostSecurityManager);
                if (appDomainManagerType != null) {
                    setup.AppDomainManagerType = appDomainManagerType.FullName;
                    setup.AppDomainManagerAssembly = appDomainManagerType.Assembly.FullName;
                }

                // Apply compatibility switches
                switches.Apply(setup);

                try {
                    if (switches.UseLegacyCas) {
                        appDomain = AppDomain.CreateDomain(domainId,
#if FEATURE_PAL // FEATURE_PAL: hack to avoid non-supported hosting features
                                                           null,
#else // FEATURE_PAL
GetDefaultDomainIdentity(),
#endif // FEATURE_PAL
setup);
                    }
                    else {
                        appDomain = AppDomain.CreateDomain(domainId,
#if FEATURE_PAL // FEATURE_PAL: hack to avoid non-supported hosting features
                                                           null,
#else // FEATURE_PAL
GetDefaultDomainIdentity(),
#endif // FEATURE_PAL
setup,
                                                           permissionSet,
                                                           fullTrustAssemblies.ToArray() /* fully trusted assemblies list: empty list means only trust GAC assemblies */);
                    }
                    foreach (DictionaryEntry e in bindings)
                        appDomain.SetData((String)e.Key, (String)e.Value);
                    foreach (var entry in appDomainAdditionalData)
                        appDomain.SetData(entry.Key, entry.Value);
                }
                catch (Exception e) {
                    Debug.Trace("AppManager", "AppDomain.CreateDomain failed", e);
                    appDomainCreationException = e;
                }
            }
            finally {
                if (ictxConfig != null) {
                    ictxConfig.Undo();
                    ictxConfig = null;
                }
                if (uncTokenConfig != IntPtr.Zero) {
                    UnsafeNativeMethods.CloseHandle(uncTokenConfig);
                    uncTokenConfig = IntPtr.Zero;
                }
            }

            if (appDomain == null) {
                throw new SystemException(SR.GetString(SR.Cannot_create_AppDomain), appDomainCreationException);
            }

            // Create hosting environment in the new app domain

            Type hostType = typeof(HostingEnvironment);
            String module = hostType.Module.Assembly.FullName;
            String typeName = hostType.FullName;
            ObjectHandle h = null;

            // impersonate UNC identity, if any
            ImpersonationContext ictx = null;
            IntPtr uncToken = IntPtr.Zero;

            //
            // fetching config can fail due to a ---- with the 
            // native config reader
            // if that has happened, force a flush
            //
            int maxRetries = 10;
            int numRetries = 0;

            while (numRetries < maxRetries) {
                try {
                    uncToken = appHost.GetConfigToken();
                    // no throw, so break
                    break;
                }
                catch (InvalidOperationException) {
                    numRetries++;
                    System.Threading.Thread.Sleep(250);
                }
            }


            if (uncToken != IntPtr.Zero) {
                try {
                    ictx = new ImpersonationContext(uncToken);
                }
                catch {
                }
                finally {
                    UnsafeNativeMethods.CloseHandle(uncToken);
                }
            }

            try {

                // Create the hosting environment in the app domain
#if DBG
                try {
                    h = Activator.CreateInstance(appDomain, module, typeName);
                }
                catch (Exception e) {
                    Debug.Trace("AppManager", "appDomain.CreateInstance failed; identity=" + System.Security.Principal.WindowsIdentity.GetCurrent().Name, e);
                    throw;
                }
#else
                h = Activator.CreateInstance(appDomain, module, typeName);
#endif
            }
            finally {
                // revert impersonation
                if (ictx != null)
                    ictx.Undo();

                if (h == null) {
                    AppDomain.Unload(appDomain);
                }
            }

            HostingEnvironment env = (h != null) ? h.Unwrap() as HostingEnvironment : null;

            if (env == null)
                throw new SystemException(SR.GetString(SR.Cannot_create_HostEnv));

            // initialize the hosting environment
            IConfigMapPathFactory configMapPathFactory = appHost.GetConfigMapPathFactory();
            if (appDomainStartupConfigurationException == null) {
                env.Initialize(this, appHost, configMapPathFactory, hostingParameters, policyLevel);
            }
            else {
                env.Initialize(this, appHost, configMapPathFactory, hostingParameters, policyLevel, appDomainStartupConfigurationException);
            }
            return env;
        }

        private static string NormalizePublicKeyBlob(string publicKey) {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < publicKey.Length; i++) {
                if (!Char.IsWhiteSpace(publicKey[i])) {
                    sb.Append(publicKey[i]);
                }
            }
            publicKey = sb.ToString();
            return publicKey;
        }

        private static StrongName CreateStrongName(string assemblyName, string version, string publicKeyString) {
            byte[] publicKey = null;
            StrongName strongName = null;
            publicKeyString = NormalizePublicKeyBlob(publicKeyString);
            int publicKeySize = publicKeyString.Length / 2;
            publicKey = new byte[publicKeySize];
            for (int i = 0; i < publicKeySize; i++) {
                publicKey[i] = Byte.Parse(publicKeyString.Substring(i * 2, 2), System.Globalization.NumberStyles.HexNumber, CultureInfo.InvariantCulture);
            }
            StrongNamePublicKeyBlob keyBlob = new StrongNamePublicKeyBlob(publicKey);
            strongName = new StrongName(keyBlob, assemblyName, new Version(version));
            return strongName;
        }

        // For various reasons, we can't add any entries to the <fullTrustAssemblies> list until .NET 5, which at the time of this writing is a few
        // years out. But since ASP.NET releases projects out-of-band from the .NET Framework as a whole (using Microsoft.Web.Infrasturcture), we
        // need to be sure that future versions of M.W.I have the ability to assert full trust. This code works by seeing if M.W.I v1 is in the
        // <fullTrustAssemblies> list, and if it is then v2 - v10 are implicitly added. If v1 is not present in the <fTA> list, then we'll not
        // treat v2 - v10 as implicitly added. See DevDiv #27645 for more information.

        private static StrongName GetMicrosoftWebInfrastructureV1StrongName() {
            return CreateStrongName(
                    assemblyName: "Microsoft.Web.Infrastructure",
                    version: "1.0.0.0",
                    publicKeyString: "0024000004800000940000000602000000240000525341310004000001000100B5FC90E7027F67871E773A8FDE8938C81DD402BA65B9201D60593E96C492651E889CC13F1415EBB53FAC1131AE0BD333C5EE6021672D9718EA31A8AEBD0DA0072F25D87DBA6FC90FFD598ED4DA35E44C398C454307E8E33B8426143DAEC9F596836F97C8F74750E5975C64E2189F45DEF46B2A2B1247ADC3652BF5C308055DA9");
        }

        private static IEnumerable<StrongName> CreateFutureMicrosoftWebInfrastructureStrongNames() {
            string asmName = _mwiV1StrongName.Name;
            StrongNamePublicKeyBlob publicKey = _mwiV1StrongName.PublicKey;
            for (int i = 2; i <= 10; i++) {
                yield return new StrongName(publicKey, asmName, new Version(i, 0, 0, 0));
            }
        }


         // devdiv 1038337: execution permission cannot be acquired under partial trust with ctrl-f5.
         // We build the codegen path in default domain. In order to build the right path, 
         // caller must pass in a flag indicating whether it is under dev environment.
        [SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands", Justification = "We carefully control this method's caller.")]
        private static PolicyLevel GetPartialTrustPolicyLevel(
                TrustSection trustSection, SecurityPolicySection securityPolicySection,
                CompilationSection compilationSection, string physicalPath, VirtualPath virtualPath, bool isDevEnvironment) {
            if (securityPolicySection == null || securityPolicySection.TrustLevels[trustSection.Level] == null) {
                throw new ConfigurationErrorsException(SR.GetString(SR.Unable_to_get_policy_file, trustSection.Level), String.Empty, 0);
            }
            String configFile = (String)securityPolicySection.TrustLevels[trustSection.Level].PolicyFileExpanded;
            if (configFile == null || !FileUtil.FileExists(configFile)) {
                throw new HttpException(SR.GetString(SR.Unable_to_get_policy_file, trustSection.Level));
            }
            PolicyLevel policyLevel = null;
            String appDir = FileUtil.RemoveTrailingDirectoryBackSlash(physicalPath);
            String appDirUrl = HttpRuntime.MakeFileUrl(appDir);

            // setup $CodeGen$ replacement
            string tempDirectory = null;
            // These variables are used for error handling
            string tempDirAttribName = null;
            string configFileName = null;
            int configLineNumber = 0;
            if (compilationSection != null && !String.IsNullOrEmpty(compilationSection.TempDirectory)) {
                tempDirectory = compilationSection.TempDirectory;
                compilationSection.GetTempDirectoryErrorInfo(out tempDirAttribName,
                    out configFileName, out configLineNumber);
            }
            if (tempDirectory != null) {
                tempDirectory = tempDirectory.Trim();
                if (!Path.IsPathRooted(tempDirectory)) {
                    // Make sure the path is not relative (VSWhidbey 260075)
                    tempDirectory = null;
                }
                else {
                    try {
                        // Canonicalize it to avoid problems with spaces (VSWhidbey 229873)
                        tempDirectory = new DirectoryInfo(tempDirectory).FullName;
                    }
                    catch {
                        tempDirectory = null;
                    }
                }
                if (tempDirectory == null) {
                    throw new ConfigurationErrorsException(
                        SR.GetString(SR.Invalid_temp_directory, tempDirAttribName),
                        configFileName, configLineNumber);
                }
                // Create the config-specified directory if needed
                try {
                    Directory.CreateDirectory(tempDirectory);
                }
                catch (Exception e) {
                    throw new ConfigurationErrorsException(
                        SR.GetString(SR.Invalid_temp_directory, tempDirAttribName),
                        e,
                        configFileName, configLineNumber);
                }
            }
            else {
                tempDirectory = Path.Combine(RuntimeEnvironment.GetRuntimeDirectory(), HttpRuntime.codegenDirName);
            }
            // If we don't have write access to the codegen dir, use the TEMP dir instead.
            // This will allow non-admin users to work in hosting scenarios (e.g. Venus, aspnet_compiler)
            if (!System.Web.UI.Util.HasWriteAccessToDirectory(tempDirectory)) {
                // Don't do this if we're in a service (!UserInteractive), as TEMP
                // could point to unwanted places.
                if (!Environment.UserInteractive) {
                    throw new HttpException(SR.GetString(SR.No_codegen_access,
                        System.Web.UI.Util.GetCurrentAccountName(), tempDirectory));
                }
                tempDirectory = Path.GetTempPath();
                Debug.Assert(System.Web.UI.Util.HasWriteAccessToDirectory(tempDirectory));
                tempDirectory = Path.Combine(tempDirectory, HttpRuntime.codegenDirName);
            }
            String simpleAppName = System.Web.Hosting.AppManagerAppDomainFactory.ConstructSimpleAppName(
                VirtualPath.GetVirtualPathStringNoTrailingSlash(virtualPath), isDevEnvironment);
            String binDir = Path.Combine(tempDirectory, simpleAppName);
            binDir = FileUtil.RemoveTrailingDirectoryBackSlash(binDir);
            String binDirUrl = HttpRuntime.MakeFileUrl(binDir);

            String originUrl = trustSection.OriginUrl;
            FileStream file = new FileStream(configFile, FileMode.Open, FileAccess.Read);
            StreamReader reader = new StreamReader(file, Encoding.UTF8);
            String strFileData = reader.ReadToEnd();
            reader.Close();
            strFileData = strFileData.Replace("$AppDir$", appDir);
            strFileData = strFileData.Replace("$AppDirUrl$", appDirUrl);
            strFileData = strFileData.Replace("$CodeGen$", binDirUrl);
            if (originUrl == null)
                originUrl = String.Empty;
            strFileData = strFileData.Replace("$OriginHost$", originUrl);
            String gacLocation = null;
            if (strFileData.IndexOf("$Gac$", StringComparison.Ordinal) != -1) {
                gacLocation = HttpRuntime.GetGacLocation();
                if (gacLocation != null)
                    gacLocation = HttpRuntime.MakeFileUrl(gacLocation);
                if (gacLocation == null)
                    gacLocation = String.Empty;
                strFileData = strFileData.Replace("$Gac$", gacLocation);
            }
#pragma warning disable 618 // ASP is reading their grant set out of legacy policy level files
            policyLevel = SecurityManager.LoadPolicyLevelFromString(strFileData, PolicyLevelType.AppDomain);
            if (policyLevel == null) {
                throw new ConfigurationErrorsException(SR.GetString(SR.Unable_to_get_policy_file, trustSection.Level));
            }
            // Found GAC Token
            if (gacLocation != null) {
                // walk the code groups at the app domain level and look for one that grants
                // access to the GAC with an UrlMembershipCondition.
                CodeGroup rootGroup = policyLevel.RootCodeGroup;
                bool foundGacCondition = false;
                foreach (CodeGroup childGroup in rootGroup.Children) {
                    if (childGroup.MembershipCondition is GacMembershipCondition) {
                        foundGacCondition = true;
                        // if we found the GAC token and also have the GacMembershipCondition
                        // the policy file needs to be upgraded to just include the GacMembershipCondition
                        Debug.Assert(!foundGacCondition);
                        break;
                    }
                }
                // add one as a child of the toplevel group after
                // some sanity checking to make sure it's an ASP.NET policy file
                // which always begins with a FirstMatchCodeGroup granting nothing
                // this might not upgrade some custom policy files
                if (!foundGacCondition) {
                    if (rootGroup is FirstMatchCodeGroup) {
                        FirstMatchCodeGroup firstMatch = (FirstMatchCodeGroup)rootGroup;
                        if (firstMatch.MembershipCondition is AllMembershipCondition &&
                            firstMatch.PermissionSetName == "Nothing") {
                            PermissionSet fullTrust = new PermissionSet(PermissionState.Unrestricted);
                            CodeGroup gacGroup = new UnionCodeGroup(new GacMembershipCondition(),
                                                                    new PolicyStatement(fullTrust));
                            // now, walk the current groups and insert our new group immediately before the old Gac group
                            // we'll need to use heuristics for this: it will be an UrlMembershipCondition group with full trust
                            CodeGroup newRoot = new FirstMatchCodeGroup(rootGroup.MembershipCondition, rootGroup.PolicyStatement);
                            foreach (CodeGroup childGroup in rootGroup.Children) {
                                // is this the target old $Gac$ group?
                                // insert our new GacMembershipCondition group ahead of it
                                if ((childGroup is UnionCodeGroup) &&
                                    (childGroup.MembershipCondition is UrlMembershipCondition) &&
                                    childGroup.PolicyStatement.PermissionSet.IsUnrestricted()) {
                                    if (null != gacGroup) {
                                        newRoot.AddChild(gacGroup);
                                        gacGroup = null;
                                    }
                                }
                                // append this group to the root group
                                // AddChild itself does a deep Copy to get any
                                // child groups so we don't need one here
                                newRoot.AddChild(childGroup);
                            }
                            policyLevel.RootCodeGroup = newRoot;
                        }
                    }
                }
            }
            return policyLevel;
#pragma warning restore 618
        }

        private sealed class ApplicationResumeStateContainer {
            private static readonly WaitCallback _tpCallback = ResumeCallback;

            private readonly HostingEnvironment _hostEnv;
            private readonly IntPtr _resumeState;

            internal ApplicationResumeStateContainer(HostingEnvironment hostEnv, IntPtr resumeState) {
                _hostEnv = hostEnv;
                _resumeState = resumeState;
            }

            // schedules resume for execution on a new thread
            // unsafe since we don't care about impersonation, identity, etc.
            internal void Resume() {
                ThreadPool.UnsafeQueueUserWorkItem(_tpCallback, this);
            }

            private static void ResumeCallback(object state) {
                ApplicationResumeStateContainer container = (ApplicationResumeStateContainer)state;
                try {
                    container._hostEnv.ResumeApplication(container._resumeState);
                }
                catch (AppDomainUnloadedException) {
                    // AD unloads aren't considered a failure, ----
                }
            }
        }

        [SecurityPermission(SecurityAction.LinkDemand, Unrestricted = true)]
        private static class AspNetAppDomainManager {
            internal static Type GetAspNetAppDomainManagerType(bool overrideHostExecutionContextManager, bool overrideHostSecurityManager) {
                if (!overrideHostExecutionContextManager && !overrideHostSecurityManager) {
                    // A custom AppDomainManager isn't necessary for this AppDomain.
                    return null;
                }
                else {
                    // A custom AppDomainManager is necessary for this AppDomain.
                    // See comment on the generic type for further information.
                    Type openGenericType = typeof(AspNetAppDomainManagerImpl<,>);
                    Type closedGenericType = openGenericType.MakeGenericType(
                        (overrideHostExecutionContextManager) ? typeof(AspNetHostExecutionContextManager) : typeof(object),
                        (overrideHostSecurityManager) ? typeof(AspNetHostSecurityManager) : typeof(object)
                        );
                    return closedGenericType;
                }
            }

            // This AppDomainManager may have been set because we need it for Task support, because this is a partial-trust
            // AppDomain, or both. Normally we would store this data in the AppDomain's ambient data store (AppDomain.SetData),
            // but the AppDomainManager instance is initialized in the new AppDomain before the original AppDomain has a chance to
            // call SetData, so in this AppDomain the call to GetData is useless. However, we can use the AppDomainManager type
            // itself to carry the necessary information in the form of a generic type parameter. If a custom
            // HostExecutionContextManager or HostSecurityManager is necessary, the generic type parameters can tell us that.
            // A generic type parameter of "object" means that this particular sub-manager isn't necessary.
            private sealed class AspNetAppDomainManagerImpl<THostExecutionContextManager, THostSecurityManager> : AppDomainManager
                where THostExecutionContextManager : class, new()
                where THostSecurityManager : class, new() {

                private readonly HostExecutionContextManager _hostExecutionContextManager = CreateHostExecutionContextManager();
                private readonly HostSecurityManager _hostSecurityManager = CreateHostSecurityManager();

                public override HostExecutionContextManager HostExecutionContextManager {
                    get {
                        return _hostExecutionContextManager ?? base.HostExecutionContextManager;
                    }
                }

                public override HostSecurityManager HostSecurityManager {
                    get {
                        return _hostSecurityManager ?? base.HostSecurityManager;
                    }
                }

                private static HostExecutionContextManager CreateHostExecutionContextManager() {
                    object hostExecutionContextManager = new THostExecutionContextManager();
                    Debug.Assert(hostExecutionContextManager is HostExecutionContextManager || hostExecutionContextManager.GetType() == typeof(object), "THostExecutionContextManager was an unexpected type!");
                    return hostExecutionContextManager as HostExecutionContextManager;
                }

                private static HostSecurityManager CreateHostSecurityManager() {
                    object hostSecurityManager = new THostSecurityManager();
                    Debug.Assert(hostSecurityManager is HostSecurityManager || hostSecurityManager.GetType() == typeof(object), "THostSecurityManager was an unexpected type!");
                    return hostSecurityManager as HostSecurityManager;
                }
            }

            private sealed class AspNetHostSecurityManager : HostSecurityManager {
                private PermissionSet Nothing = new PermissionSet(PermissionState.None);
                private PermissionSet FullTrust = new PermissionSet(PermissionState.Unrestricted);
                private HostSecurityPolicyResolver hostSecurityPolicyResolver = null;

                public override HostSecurityManagerOptions Flags {
                    get {
                        return HostSecurityManagerOptions.HostResolvePolicy;
                    }
                }

                [SecurityPermission(SecurityAction.Assert, Flags = SecurityPermissionFlag.SerializationFormatter)]
                public override PermissionSet ResolvePolicy(Evidence evidence) {
                    if (base.ResolvePolicy(evidence).IsUnrestricted()) {
                        return FullTrust;
                    }

                    if (!String.IsNullOrEmpty(HttpRuntime.HostSecurityPolicyResolverType) && hostSecurityPolicyResolver == null) {
                        hostSecurityPolicyResolver = Activator.CreateInstance(
                            Type.GetType(HttpRuntime.HostSecurityPolicyResolverType)) as HostSecurityPolicyResolver;
                    }

                    if (hostSecurityPolicyResolver != null) {
                        switch (hostSecurityPolicyResolver.ResolvePolicy(evidence)) {
                            case HostSecurityPolicyResults.FullTrust:
                                return FullTrust;
                            case HostSecurityPolicyResults.AppDomainTrust:
                                return HttpRuntime.NamedPermissionSet;
                            case HostSecurityPolicyResults.Nothing:
                                return Nothing;
                            case HostSecurityPolicyResults.DefaultPolicy:
                                break;
                        }
                    }

                    if (HttpRuntime.PolicyLevel == null || HttpRuntime.PolicyLevel.Resolve(evidence).PermissionSet.IsUnrestricted())
                        return FullTrust;
                    else if (HttpRuntime.PolicyLevel.Resolve(evidence).PermissionSet.Equals(Nothing))
                        return Nothing;
                    else
                        return HttpRuntime.NamedPermissionSet;
                }
            }
        }

        private static void PopulateDomainBindings(String domainId, String appId, String appName,
                                                    String appPath, VirtualPath appVPath,
                                                    AppDomainSetup setup, IDictionary dict) {
            // assembly loading settings

            // We put both the old and new bin dir names on the private bin path
            setup.PrivateBinPathProbe   = "*";  // disable loading from app base
            setup.ShadowCopyFiles       = "true";
            setup.ApplicationBase       = appPath;
            setup.ApplicationName       = appName;
            setup.ConfigurationFile     = HttpConfigurationSystem.WebConfigFileName;

            // Disallow code download, since it's unreliable in services (ASURT 123836/127606)
            setup.DisallowCodeDownload  = true;

            // internal settings
            dict.Add(".appDomain",     "*");
            dict.Add(".appId",         appId);
            dict.Add(".appPath",       appPath);
            dict.Add(".appVPath",      appVPath.VirtualPathString);
            dict.Add(".domainId",      domainId);
        }

        private static Evidence GetDefaultDomainIdentity() {
            Evidence evidence = AppDomain.CurrentDomain.Evidence; // CurrentDomain.Evidence returns a clone so we can modify it if we need
            bool hasZone = evidence.GetHostEvidence<Zone>() != null;
            bool hasUrl = evidence.GetHostEvidence<Url>() != null;

            if (!hasZone)
                evidence.AddHostEvidence(new Zone(SecurityZone.MyComputer));

            if (!hasUrl)
                evidence.AddHostEvidence(new Url("ms-internal-microsoft-asp-net-webhost-20"));

            return evidence;
        }

        private static int s_domainCount = 0;
        private static Object s_domainCountLock = new Object();

        private static String ConstructAppDomainId(String id) {
            int domainCount = 0;
            lock (s_domainCountLock) {
                domainCount = ++s_domainCount;
            }
            return id + "-" + domainCount.ToString(NumberFormatInfo.InvariantInfo) + "-" + DateTime.UtcNow.ToFileTime().ToString();
        }

        internal LockableAppDomainContext GetLockableAppDomainContext (string appId) {
            lock (this) {
                LockableAppDomainContext ac;
                if (!_appDomains.TryGetValue(appId, out ac)) {
                    ac = new LockableAppDomainContext();
                    _appDomains.Add (appId, ac);
                }

                return ac;
            }
        }

        // take a copy of _appDomains collection so that it can be used without locking on ApplicationManager
        private Dictionary<string, LockableAppDomainContext> CloneAppDomainsCollection() {
            lock (this) {
                return new Dictionary<string, LockableAppDomainContext>(_appDomains, StringComparer.OrdinalIgnoreCase);
            }
        }

        private static Configuration GetAppConfigCommon(IConfigMapPath configMapPath, string siteID, string appSegment) {
            WebConfigurationFileMap fileMap = new WebConfigurationFileMap();
            string dir = null;
            string fileName = null;
            string subDir = "/";
            // add root mapping
            configMapPath.GetPathConfigFilename(siteID, subDir, out dir, out fileName);
            if (dir != null) {
                fileMap.VirtualDirectories.Add(subDir, new VirtualDirectoryMapping(Path.GetFullPath(dir), true));
            }
            // add subdir mappings
            string[] subDirs = appSegment.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
            foreach (string s in subDirs) {
                subDir = subDir + s;
                configMapPath.GetPathConfigFilename(siteID, subDir, out dir, out fileName);
                if (dir != null) {
                    fileMap.VirtualDirectories.Add(subDir, new VirtualDirectoryMapping(Path.GetFullPath(dir), true));
                }
                subDir = subDir + "/";
            }
            // open mapped web config for application
            return WebConfigurationManager.OpenMappedWebConfiguration(fileMap, appSegment, siteID);
        }

        [SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands", Justification = "Only ever called by the full-trust parent AppDomain.")]
        private static Configuration GetAppConfigGeneric(IApplicationHost appHost, string siteID, string appSegment, VirtualPath virtualPath, string physicalPath) {
            WebConfigurationFileMap fileMap = new WebConfigurationFileMap();
            IConfigMapPathFactory configMapPathFactory2 = appHost.GetConfigMapPathFactory();
            IConfigMapPath configMapPath = configMapPathFactory2.Create(virtualPath.VirtualPathString, physicalPath);
            return GetAppConfigCommon(configMapPath, siteID, appSegment);
        }

        private static Configuration GetAppConfigIISExpress(string siteID, string appSegment, string iisExpressVersion) {
            ExpressServerConfig serverConfig = (ExpressServerConfig)ServerConfig.GetDefaultDomainInstance(iisExpressVersion);
            return GetAppConfigCommon(serverConfig, siteID, appSegment);
        }

        private sealed class AppDomainSwitches {
            public bool UseLegacyCas;
            public bool UseRandomizedStringHashAlgorithm;

            public void Apply(AppDomainSetup setup) {
                List<string> switches = new List<string>();

                if (UseLegacyCas) {
                    // Enables the AppDomain to use the legacy CAS model for compatibility <trust/legacyCasModel>
                    switches.Add("NetFx40_LegacySecurityPolicy");
                }

                if (UseRandomizedStringHashAlgorithm) {
                    switches.Add("UseRandomizedStringHashAlgorithm");
                }

                if (switches.Count > 0) {
                    setup.SetCompatibilitySwitches(switches);
                }
            }
        }

        // This class holds information about the environment that is hosting ASP.NET. The particular design of this class
        // is that the information is computed once and stored, and the methods which compute the information are private.
        // This prevents accidental misuse of this type via querying the environment after user code has had a chance to
        // run, which could potentially affect the environment itself.
        private static class EnvironmentInfo {
            public static readonly bool IsStringHashCodeRandomizationDetected = GetIsStringHashCodeRandomizationDetected();
            public static readonly bool WasLaunchedFromDevelopmentEnvironment = GetWasLaunchedFromDevelopmentEnvironmentValue();

            private static bool GetIsStringHashCodeRandomizationDetected() {
                // known test vector
                return (StringComparer.InvariantCultureIgnoreCase.GetHashCode("The quick brown fox jumps over the lazy dog.") != 0x703e662e);
            }

            // Visual Studio / WebMatrix will set DEV_ENVIRONMENT=1 when launching an ASP.NET host in a development environment.
            private static bool GetWasLaunchedFromDevelopmentEnvironmentValue() {
                try {
                    string envVar = Environment.GetEnvironmentVariable("DEV_ENVIRONMENT", EnvironmentVariableTarget.Process);
                    return String.Equals(envVar, "1", StringComparison.Ordinal);
                }
                catch {
                    // We don't care if we can't read the environment variable; just treat it as not present.
                    return false;
                }
            }
        }

    }
}