AppDomainManager.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / DotNET / DotNET / 8.0 / untmp / whidbey / REDBITS / ndp / clr / src / BCL / System / AppDomainManager.cs / 1 / AppDomainManager.cs
                        

                        
                            // ==++== 
//
//   Copyright (c) Microsoft Corporation.  All rights reserved.
//
// ==--== 

// 
// An AppDomainManager gives a hosting application the chance to 
// participate in the creation and control the settings of new AppDomains.
// 

namespace System {
    using System.Collections;
    using System.Globalization; 
    using System.IO;
    using System.Reflection; 
    using System.Runtime.CompilerServices; 
    using System.Security;
    using System.Security.Permissions; 
    using System.Security.Policy;
    using System.Threading;
    using System.Runtime.Hosting;
 
    [Flags]
    [System.Runtime.InteropServices.ComVisible(true)] 
    public enum AppDomainManagerInitializationOptions { 
        None             = 0x0000,
        RegisterWithHost = 0x0001 
    }

    [SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.Infrastructure)]
    [SecurityPermissionAttribute(SecurityAction.InheritanceDemand, Flags=SecurityPermissionFlag.Infrastructure)] 
    [System.Runtime.InteropServices.ComVisible(true)]
    public class AppDomainManager : MarshalByRefObject { 
        public AppDomainManager () {} 

        public virtual AppDomain CreateDomain (string friendlyName, 
                                               Evidence securityInfo,
                                               AppDomainSetup appDomainInfo) {
            return CreateDomainHelper(friendlyName, securityInfo, appDomainInfo);
        } 

        [SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.Infrastructure)] 
        [SecurityPermissionAttribute(SecurityAction.Demand, ControlAppDomain = true)] 
        protected static AppDomain CreateDomainHelper (string friendlyName,
                                                       Evidence securityInfo, 
                                                       AppDomainSetup appDomainInfo) {
            if (friendlyName == null)
                throw new ArgumentNullException(Environment.GetResourceString("ArgumentNull_String"));
 
            // If evidence is provided, we check to make sure that is allowed.
            if (securityInfo != null) 
                new SecurityPermission(SecurityPermissionFlag.ControlEvidence).Demand(); 

            return AppDomain.nCreateDomain(friendlyName, 
                                           appDomainInfo,
                                           securityInfo,
                                           securityInfo == null ? AppDomain.CurrentDomain.InternalEvidence : null,
                                           AppDomain.CurrentDomain.GetSecurityDescriptor()); 
        }
 
        public virtual void InitializeNewDomain (AppDomainSetup appDomainInfo) { 
            // By default, InitializeNewDomain does nothing.
        } 

        private AppDomainManagerInitializationOptions m_flags = AppDomainManagerInitializationOptions.None;
        public AppDomainManagerInitializationOptions InitializationFlags {
            get { 
                return m_flags;
            } 
            set { 
                m_flags = value;
            } 
        }

#if !FEATURE_PAL
        private ApplicationActivator m_appActivator = null; 
        public virtual ApplicationActivator ApplicationActivator {
            get { 
                if (m_appActivator == null) 
                    m_appActivator = new ApplicationActivator();
                return m_appActivator; 
            }
        }
#endif //!FEATURE_PAL
 
        public virtual HostSecurityManager HostSecurityManager {
            get { 
                return null; 
            }
        } 

        public virtual HostExecutionContextManager HostExecutionContextManager {
            get {
                // By default, the AppDomainManager returns the HostExecutionContextManager. 
                return HostExecutionContextManager.GetInternalHostExecutionContextManager();
            } 
        } 

        private Assembly m_entryAssembly = null; 
        public virtual Assembly EntryAssembly {
            get {
                // The default AppDomainManager sets the EntryAssembly depending on whether the
                // AppDomain is a manifest application domain or not. In the first case, we parse 
                // the application manifest to find out the entry point assembly and return that assembly.
                // In the second case, we maintain the old behavior by calling nGetEntryAssembly(). 
                if (m_entryAssembly == null) { 
                    AppDomain domain = AppDomain.CurrentDomain;
#if !FEATURE_PAL 
                    if (domain.IsDefaultAppDomain() && domain.ActivationContext != null) {
                        ManifestRunner runner = new ManifestRunner(domain, domain.ActivationContext);
                        m_entryAssembly = runner.EntryAssembly;
                    } else 
#endif //!FEATURE_PAL
                        m_entryAssembly = nGetEntryAssembly(); 
                } 
                return m_entryAssembly;
            } 
        }

        internal static AppDomainManager CurrentAppDomainManager {
            get { 
                return AppDomain.CurrentDomain.DomainManager;
            } 
        } 

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern void nRegisterWithHost();

        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private static extern Assembly nGetEntryAssembly(); 
    }
}

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK