ApplicationActivator.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 / ApplicationActivator.cs / 2 / ApplicationActivator.cs
                        

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

// 
// ApplicationActivator class is the base class that handles activation of Add-ins. 
// There is a single designated instance of the ApplicationActivator in each Appdomain
// to which all Add-in activation calls are routed to. The AppdomainManager for the 
// current Appdomain could provide its own custom ApplicationActivator, or an instance
// of the default ApplicationActivator is created.
//
 
namespace System.Runtime.Hosting {
    using System.Deployment.Internal.Isolation; 
    using System.Deployment.Internal.Isolation.Manifest; 
    using System.IO;
    using System.Reflection; 
    using System.Runtime.Remoting;
    using System.Security;
    using System.Security.Permissions;
    using System.Security.Policy; 
    using System.Threading;
 
    internal sealed class ManifestRunner { 
        private AppDomain m_domain;
        private string m_path; 
        private string[] m_args;
        private ApartmentState m_apt;
        private Assembly m_assembly;
        private int m_runResult; 

        // 
        // We need to assert unmanaged code security permission to be 
        // able to call ActivationContext.ApplicationDirectory.
        // 

        [SecurityPermissionAttribute(SecurityAction.Assert, Unrestricted=true)]
        internal ManifestRunner (AppDomain domain, ActivationContext activationContext) {
            m_domain = domain; 

            string file, parameters; 
            CmsUtils.GetEntryPoint(activationContext, out file, out parameters); 

            if (String.IsNullOrEmpty(file)) 
                throw new ArgumentException(Environment.GetResourceString("Argument_NoMain"));

            if (String.IsNullOrEmpty(parameters))
                m_args = new string[0]; 
            else
                m_args = parameters.Split(' '); 
 
            m_apt = ApartmentState.Unknown;
 
            // get the 'merged' application directory path.
            string directoryName = activationContext.ApplicationDirectory;
            m_path = Path.Combine(directoryName, file);
        } 

        internal Assembly EntryAssembly { 
            [FileIOPermissionAttribute(SecurityAction.Assert, Unrestricted=true)] 
            [SecurityPermissionAttribute(SecurityAction.Assert, Unrestricted=true)]
            get { 
                if (m_assembly == null)
                    m_assembly = Assembly.LoadFrom(m_path);
                return m_assembly;
            } 
        }
 
        private void NewThreadRunner () { 
            m_runResult = Run(false);
        } 

        private int RunInNewThread () {
            Thread th = new Thread(new ThreadStart(NewThreadRunner));
            th.SetApartmentState(m_apt); 
            th.Start();
            th.Join(); 
            return m_runResult; 
        }
 
        private int Run (bool checkAptModel) {
            if (checkAptModel && m_apt != ApartmentState.Unknown) {
                if (Thread.CurrentThread.GetApartmentState() != ApartmentState.Unknown && Thread.CurrentThread.GetApartmentState() != m_apt)
                    return RunInNewThread(); 
                Thread.CurrentThread.SetApartmentState(m_apt);
            } 
            return m_domain.nExecuteAssembly(EntryAssembly, m_args); 
        }
 
        internal int ExecuteAsAssembly () {
            Object[] attrs = EntryAssembly.EntryPoint.GetCustomAttributes(typeof(STAThreadAttribute), false);
            if (attrs.Length > 0)
                m_apt = ApartmentState.STA; 
            attrs = EntryAssembly.EntryPoint.GetCustomAttributes(typeof(MTAThreadAttribute), false);
            if (attrs.Length > 0) 
                if (m_apt == ApartmentState.Unknown) 
                    m_apt = ApartmentState.MTA;
                else 
                    m_apt = ApartmentState.Unknown;
            return Run(true);
        }
    } 

    [System.Runtime.InteropServices.ComVisible(true)] 
    public class ApplicationActivator { 
        public ApplicationActivator () {}
 
        public virtual ObjectHandle CreateInstance (ActivationContext activationContext) {
            return CreateInstance(activationContext, null);
        }
 
        public virtual ObjectHandle CreateInstance (ActivationContext activationContext, string[] activationCustomData) {
            if (activationContext == null) 
                throw new ArgumentNullException("activationContext"); 

            if (CmsUtils.CompareIdentities(AppDomain.CurrentDomain.ActivationContext, activationContext)) { 
                ManifestRunner runner = new ManifestRunner(AppDomain.CurrentDomain, activationContext);
                return new ObjectHandle(runner.ExecuteAsAssembly());
            }
 
            AppDomainSetup adSetup = new AppDomainSetup(new ActivationArguments(activationContext, activationCustomData));
            // we inherit the evidence from the calling domain 
            return CreateInstanceHelper(adSetup); 
        }
 
        protected static ObjectHandle CreateInstanceHelper (AppDomainSetup adSetup) {
            if (adSetup.ActivationArguments == null)
                throw new ArgumentException(Environment.GetResourceString("Arg_MissingActivationArguments"));
 
            adSetup.ActivationArguments.ActivateInstance = true;
            // inherit the caller's domain evidence for the activation. 
            Evidence activatorEvidence = AppDomain.CurrentDomain.Evidence; 
            // add the application identity as an evidence.
            Evidence appEvidence = CmsUtils.MergeApplicationEvidence(null, 
                                                                     adSetup.ActivationArguments.ApplicationIdentity,
                                                                     adSetup.ActivationArguments.ActivationContext,
                                                                     adSetup.ActivationArguments.ActivationData);
 
            HostSecurityManager securityManager = AppDomain.CurrentDomain.HostSecurityManager;
            ApplicationTrust appTrust = securityManager.DetermineApplicationTrust(appEvidence, activatorEvidence, new TrustManagerContext()); 
            if (appTrust == null || !appTrust.IsApplicationTrustedToRun) 
                throw new PolicyException(Environment.GetResourceString("Policy_NoExecutionPermission"),
                                          System.__HResults.CORSEC_E_NO_EXEC_PERM, 
                                          null);

            ObjRef or = AppDomain.nCreateInstance(adSetup.ActivationArguments.ApplicationIdentity.FullName,
                                                  adSetup, 
                                                  appEvidence,
                                                  appEvidence == null ? AppDomain.CurrentDomain.InternalEvidence : null, 
                                                  AppDomain.CurrentDomain.GetSecurityDescriptor()); 
            if (or == null)
                return null; 
            return RemotingServices.Unmarshal(or) as ObjectHandle;
        }
    }
}

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