activationcontext.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / clr / src / BCL / System / activationcontext.cs / 1305376 / activationcontext.cs

                            using System; 
using System.Collections;
using System.Deployment.Internal;
using System.Deployment.Internal.Isolation;
using System.Deployment.Internal.Isolation.Manifest; 
using System.IO;
using System.Runtime.InteropServices; 
using System.Runtime.Serialization; 
using System.Security.Permissions;
using System.Runtime.Versioning; 
using System.Diagnostics.Contracts;
using System.Security;

namespace System 
{
    // Public surface area for Whidbey: 
    //   AppDomain.ActivationContext 
    //   AppDomain.ActivationContext.Identity
    //   AppDomain.ActivationContext.Identity.FullName 
    //   AppDomain.ActivationContext.Identity.CodeBase

    //   static ActivationContext.CreatePartialActivationContext(identity)
    //   static ActivationContext.CreatePartialActivationContext(identity, manifestPaths[]) 

    //   ActivationContext class 
    //     ActivationContext.Identity 
    //   ApplicationIdentity class
    //     ApplicationIdentity.FullName 
    //     ApplicationIdentity.CodeBase

    //   + existing AppDomain.BaseDirectory: local app directory
 
    [Serializable]
    [System.Runtime.InteropServices.ComVisible(false)] 
    public sealed class ActivationContext : IDisposable, ISerializable 
    {
        private ApplicationIdentity _applicationIdentity; 
        // ISSUE - can use Generic lists.
        private ArrayList _definitionIdentities;
        private ArrayList _manifests;
        private string[] _manifestPaths; 
        private ContextForm _form;
        private ApplicationStateDisposition _appRunState; 
 
        private IActContext _actContext;
 
        private const int DefaultComponentCount = 2;

        private ActivationContext () {}
 
        [ResourceExposure(ResourceScope.Machine)]
        [ResourceConsumption(ResourceScope.Machine)] 
        [SecurityCritical] 
        private ActivationContext (SerializationInfo info, StreamingContext context)
        { 
            string fullName = (string) info.GetValue("FullName", typeof(string));
            string[] manifestPaths = (string[]) info.GetValue("ManifestPaths", typeof(string[]));
            if (manifestPaths == null)
                CreateFromName(new ApplicationIdentity(fullName)); 
            else
                CreateFromNameAndManifests(new ApplicationIdentity(fullName), manifestPaths); 
        } 

        internal ActivationContext(ApplicationIdentity applicationIdentity) 
        {
            CreateFromName(applicationIdentity);
        }
 
        [ResourceExposure(ResourceScope.Machine)]
        [ResourceConsumption(ResourceScope.Machine)] 
        internal ActivationContext(ApplicationIdentity applicationIdentity, string[] manifestPaths) 
        {
            CreateFromNameAndManifests(applicationIdentity, manifestPaths); 
        }

        [SecuritySafeCritical]
        private void CreateFromName (ApplicationIdentity applicationIdentity) 
        {
            if (applicationIdentity == null) 
                throw new ArgumentNullException("applicationIdentity"); 
            Contract.EndContractBlock();
 
            _applicationIdentity = applicationIdentity;

            IEnumDefinitionIdentity idenum = _applicationIdentity.Identity.EnumAppPath();
 
            _definitionIdentities = new ArrayList(DefaultComponentCount);
 
            IDefinitionIdentity[] asbId = new IDefinitionIdentity[1]; 
            while (idenum.Next(1, asbId) == 1)
            { 
                _definitionIdentities.Add(asbId[0]);
            }
            _definitionIdentities.TrimToSize();
            if (_definitionIdentities.Count <= 1) 
            {
#if ISOLATION_IN_MSCORLIB 
                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidAppId")); 
#else
                throw new ArgumentException("Invalid identity: no deployment/app identity specified"); 
#endif
            }

            _manifestPaths = null; 
            _manifests = null;
 
            // Construct real IActContext from store. 
            _actContext = IsolationInterop.CreateActContext(_applicationIdentity.Identity);
            _form = ContextForm.StoreBounded; 
            _appRunState = ApplicationStateDisposition.Undefined;

#if ISOLATION_IN_MSCORLIB
            Contract.Assert(_definitionIdentities.Count == 2, "An application must have exactly 1 deployment component and 1 application component in Whidbey"); 
#endif
        } 
 
        [ResourceExposure(ResourceScope.Machine)]
        [ResourceConsumption(ResourceScope.Machine)] 
        [SecuritySafeCritical]
        private void CreateFromNameAndManifests (ApplicationIdentity applicationIdentity, string[] manifestPaths)
        {
            if (applicationIdentity == null) 
                throw new ArgumentNullException("applicationIdentity");
            if (manifestPaths == null) 
                throw new ArgumentNullException("manifestPaths"); 
            Contract.EndContractBlock();
 
            _applicationIdentity = applicationIdentity;

            // ISSUE - need validation on manifestPaths
 
            IEnumDefinitionIdentity idenum = _applicationIdentity.Identity.EnumAppPath();
 
            _manifests = new ArrayList(DefaultComponentCount); 
            _manifestPaths = new String[manifestPaths.Length];
 
            IDefinitionIdentity[] asbId = new IDefinitionIdentity[1];
            int i=0;
            while (idenum.Next(1, asbId) == 1)
            { 
                ICMS cms = (ICMS) IsolationInterop.ParseManifest(manifestPaths[i], null, ref IsolationInterop.IID_ICMS);
 
                if (IsolationInterop.IdentityAuthority.AreDefinitionsEqual(0, cms.Identity, asbId[0])) 
                {
                    _manifests.Add(cms); 
                    _manifestPaths[i]=manifestPaths[i];
                }
                else
                { 
#if ISOLATION_IN_MSCORLIB
                    throw new ArgumentException(Environment.GetResourceString("Argument_IllegalAppIdMismatch")); 
#else 
                    throw new ArgumentException("Application Identity does not match identity in manifests");
#endif 
                }
                i++;
            }
            if (i!=manifestPaths.Length) 
            {
#if ISOLATION_IN_MSCORLIB 
                throw new ArgumentException(Environment.GetResourceString("Argument_IllegalAppId")); 
#else
                throw new ArgumentException("Application Identity does not have same number of components as manifest paths"); 
#endif
            }
            _manifests.TrimToSize();
            if (_manifests.Count <= 1) 
            {
#if ISOLATION_IN_MSCORLIB 
                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidAppId")); 
#else
                throw new ArgumentException("Invalid identity: no deployment/app identity specified"); 
#endif
            }

            _definitionIdentities = null; 
            _actContext = null;
            _form = ContextForm.Loose; 
            _appRunState = ApplicationStateDisposition.Undefined; 

#if ISOLATION_IN_MSCORLIB 
            Contract.Assert(_manifests.Count == 2, "An application must have exactly 1 deployment component and 1 application component in Whidbey");
#endif
        }
 
        ~ActivationContext()
        { 
            Dispose(false); 
        }
 
        public static ActivationContext CreatePartialActivationContext(ApplicationIdentity identity)
        {
            return new ActivationContext(identity);
        } 

        [ResourceExposure(ResourceScope.Machine)] 
        [ResourceConsumption(ResourceScope.Machine)] 
        public static ActivationContext CreatePartialActivationContext(ApplicationIdentity identity, string[] manifestPaths)
        { 
            return new ActivationContext(identity, manifestPaths);
        }

        public ApplicationIdentity Identity 
        {
            get 
            { 
                return _applicationIdentity;
            } 
        }

        public ContextForm Form
        { 
            get
            { 
                return _form; 
            }
        } 

       public byte[] ApplicationManifestBytes
        {
            [SecuritySafeCritical]  // auto-generated 
            get
            { 
                return GetApplicationManifestBytes(); 
            }
        } 

        public byte[] DeploymentManifestBytes
        {
            [SecuritySafeCritical]  // auto-generated 
            get
            { 
                return GetDeploymentManifestBytes(); 
            }
        } 

        internal string[] ManifestPaths
        {
            [ResourceExposure(ResourceScope.Machine)] 
            get
            { 
                return _manifestPaths; 
            }
        } 

        public void Dispose()
        {
            Dispose(true); 
            GC.SuppressFinalize(this);
        } 
 
        // Nested Enum.
        public enum ContextForm 
        {
            Loose = 0,
            StoreBounded = 1
        } 

        // Internals. 
 
        internal string ApplicationDirectory
        { 
            [ResourceExposure(ResourceScope.Machine)]
            [SecurityCritical]
            get
            { 
                if (_form == ContextForm.Loose)
                    return Path.GetDirectoryName(_manifestPaths[_manifestPaths.Length-1]); 
 
                string s;
                _actContext.ApplicationBasePath(0, out s); 
                return s;
            }
        }
 
        internal string DataDirectory
        { 
            [ResourceExposure(ResourceScope.Machine)] 
            [SecurityCritical]
            get 
            {
                // ISSUE - what is the data directory for 'loose'?
                if (_form == ContextForm.Loose)
                    return null; 

                string s; 
                // Note: passing in flag == 1. 
                _actContext.GetApplicationStateFilesystemLocation(1, UIntPtr.Zero, IntPtr.Zero, out s);
                return s; 
            }
        }

        // These internal methods to become public in Longhorn, when manifest APIs become public 

        // in LH M7 this will be come IACS instead of ICMS. 
        internal ICMS ActivationContextData 
        {
            [SecurityCritical] 
            get
            {
                // this will be a true merge of deployment and application manifest contents (ACS, not CMS)
                // for now return only the contents of the application manifest, as most consumers only care about app manifest anyway 
                return this.ApplicationComponentManifest;
            } 
        } 

        // Return the manifest of the first deployment component. 
        internal ICMS DeploymentComponentManifest
        {
            [SecurityCritical]
            get 
            {
                if (_form == ContextForm.Loose) 
                    return (ICMS) _manifests[0]; 

                return GetComponentManifest((IDefinitionIdentity)_definitionIdentities[0]); 
            }
        }

        internal ICMS ApplicationComponentManifest 
        {
            [SecurityCritical] 
            get 
            {
                if (_form == ContextForm.Loose) 
                    return (ICMS) _manifests[_manifests.Count-1];

                return GetComponentManifest((IDefinitionIdentity)_definitionIdentities[_definitionIdentities.Count-1]);
            } 
        }
 
        internal ApplicationStateDisposition LastApplicationStateResult 
        {
            get 
            {
                // Return cached result.
                return _appRunState;
            } 
        }
 
        [SecurityCritical] 
        internal ICMS GetComponentManifest(IDefinitionIdentity component)
        { 
            object o;
            _actContext.GetComponentManifest(0, component, ref IsolationInterop.IID_ICMS, out o);
            return o as ICMS;
        } 

        [SecuritySafeCritical] 
        internal byte[] GetDeploymentManifestBytes() 
        {
            object o; 
            string manifestPath;

            if (_form == ContextForm.Loose)
                manifestPath = _manifestPaths[0]; 
            else
            { 
                _actContext.GetComponentManifest(0, (IDefinitionIdentity)_definitionIdentities[0], ref IsolationInterop.IID_IManifestInformation, out o); 
                ((IManifestInformation)o).get_FullPath(out manifestPath);
                Marshal.ReleaseComObject(o); 
            }

            return ReadBytesFromFile(manifestPath);
        } 

        [SecuritySafeCritical] 
        internal byte[] GetApplicationManifestBytes() 
        {
            object o; 
            string manifestPath;

            if (_form == ContextForm.Loose)
                manifestPath = _manifestPaths[_manifests.Count-1]; 
            else
            { 
                _actContext.GetComponentManifest(0, (IDefinitionIdentity)_definitionIdentities[1], ref IsolationInterop.IID_IManifestInformation, out o); 
                ((IManifestInformation)o).get_FullPath(out manifestPath);
                Marshal.ReleaseComObject(o); 
            }

            return ReadBytesFromFile(manifestPath);
        } 

        // Internal methods used exclusively by application hosting code. 
 
        [SecuritySafeCritical]
        internal void PrepareForExecution() 
        {
            if (_form == ContextForm.Loose)
                return; // Do nothing.
 
            _actContext.PrepareForExecution(IntPtr.Zero, IntPtr.Zero);
        } 
 
        [SecuritySafeCritical]
        internal ApplicationStateDisposition SetApplicationState(ApplicationState s) 
        {
            if (_form == ContextForm.Loose)
                return ApplicationStateDisposition.Undefined; // Do nothing.
 
            UInt32 disposition;
            _actContext.SetApplicationRunningState(0, (UInt32)s, out disposition); 
 
            // Save the result.
            _appRunState = (ApplicationStateDisposition)disposition; 

            return _appRunState;
        }
 
        // Nested Enum.
        internal enum ApplicationState 
        { 
            Undefined = 0,
            Starting = 1, 
            Running = 2
        }

        internal enum ApplicationStateDisposition 
        {
            Undefined = 0, 
            Starting = 1, 
            StartingMigrated = (1 | (1 << 16)),
            Running = 2, 
            RunningFirstTime = (2 | (1 << 17))
        }

        // Privates. 

        [System.Security.SecuritySafeCritical]  // auto-generated 
        private void Dispose(bool fDisposing) 
        {
            // ISSUE- should release unmanaged objects in array lists. 
            _applicationIdentity = null;
            _definitionIdentities = null;
            _manifests = null;
            _manifestPaths = null; 

            if (_actContext != null) 
                Marshal.ReleaseComObject(_actContext); 
        }
 
        private static byte[] ReadBytesFromFile(string manifestPath)
        {
            byte[] rawBytes = null;
 
            using (FileStream fs = new FileStream(manifestPath, FileMode.Open, FileAccess.Read))
            { 
                    int bufferSize = (int)fs.Length; 

                    // zero length file will except ultimately. 
                    rawBytes = new byte[bufferSize];

                    if (fs.CanSeek)
                    { 
                       fs.Seek(0, SeekOrigin.Begin);
                    } 
 
                    // Read the file into buffer.
                    fs.Read(rawBytes, 0, bufferSize); 
            }

            return rawBytes;
 
        }
 
        ///  
        [System.Security.SecurityCritical]  // auto-generated_required
        void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context) 
        {
            if (_applicationIdentity != null)
                info.AddValue("FullName", _applicationIdentity.FullName, typeof(String));
            if (_manifestPaths != null) 
                info.AddValue("ManifestPaths", _manifestPaths, typeof(String[]));
        } 
    } 

    [Serializable] 
    [System.Runtime.InteropServices.ComVisible(false)]
    public sealed class ApplicationIdentity : ISerializable {
        private IDefinitionAppId _appId;
 
        private ApplicationIdentity () {}
        [SecurityCritical] 
        private ApplicationIdentity (SerializationInfo info, StreamingContext context) 
        {
            string fullName = (string) info.GetValue("FullName", typeof(string)); 
            if (fullName == null)
                throw new ArgumentNullException("fullName");
            _appId = IsolationInterop.AppIdAuthority.TextToDefinition(0, fullName);
        } 

        [SecuritySafeCritical] 
        public ApplicationIdentity(String applicationIdentityFullName) 
        {
            if (applicationIdentityFullName == null) 
                throw new ArgumentNullException("applicationIdentityFullName");
            Contract.EndContractBlock();
            _appId = IsolationInterop.AppIdAuthority.TextToDefinition(0, applicationIdentityFullName);
        } 

        [SecurityCritical] 
        internal ApplicationIdentity(IDefinitionAppId applicationIdentity) 
        {
            // ISSUE- this should clone the IDefintionAppId. 
            _appId = applicationIdentity;
        }

        public String FullName 
        {
            [SecuritySafeCritical] 
            get 
            {
                return IsolationInterop.AppIdAuthority.DefinitionToText(0, _appId); 
            }
        }

        public String CodeBase 
        {
            [ResourceExposure(ResourceScope.Machine)] 
            [ResourceConsumption(ResourceScope.Machine)] 
            [SecuritySafeCritical]
            get 
            {
                return _appId.get_Codebase();
            }
        } 

        public override string ToString() 
        { 
            return this.FullName;
        } 

        internal IDefinitionAppId Identity
        {
            [SecurityCritical] 
            get
            { 
                return _appId; 
            }
        } 

        /// 
        [System.Security.SecurityCritical]  // auto-generated_required
        void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context) 
        {
            info.AddValue("FullName", FullName, typeof(String)); 
        } 
    }
} 

namespace System.Deployment.Internal
{
    // All classes in this namespace are only usable within CLR (enforced with Link demand/friend etc.) 
    // This class will go away in LH, when the ApplicationDefinitionIdentity class exposes the functionality directly
    [System.Runtime.InteropServices.ComVisible(false)] 
    public static class InternalApplicationIdentityHelper 
    {
        [SecurityCritical] 
        public static object /* really IDefinitionAppId */ GetInternalAppId(ApplicationIdentity id)
        {
            return id.Identity;
        } 
    }
 
    // This helper class will go away in LH, when the ActivationContext class exposes the functionality directly 

    [System.Runtime.InteropServices.ComVisible(false)] 
    public static class InternalActivationContextHelper
    {
        [SecuritySafeCritical]
        public static object /* really ICMS */ GetActivationContextData(ActivationContext appInfo) 
        {
            return appInfo.ActivationContextData; 
        } 

        [SecuritySafeCritical] 
        public static object GetApplicationComponentManifest(ActivationContext appInfo)
        {
            return appInfo.ApplicationComponentManifest;
        } 

        [SecuritySafeCritical] 
        public static object GetDeploymentComponentManifest(ActivationContext appInfo) 
        {
            return appInfo.DeploymentComponentManifest; 
        }

        public static void PrepareForExecution(ActivationContext appInfo)
        { 
            appInfo.PrepareForExecution();
        } 
 
        public static bool IsFirstRun(ActivationContext appInfo)
        { 
            return (appInfo.LastApplicationStateResult == ActivationContext.ApplicationStateDisposition.RunningFirstTime);
        }

        [System.Security.SecuritySafeCritical]  // auto-generated 
        public static byte[] GetApplicationManifestBytes(ActivationContext appInfo)
        { 
            if (appInfo == null) 
                throw new ArgumentNullException("appInfo");
 
            return appInfo.GetApplicationManifestBytes();
        }

        [System.Security.SecuritySafeCritical]  // auto-generated 
        public static byte[] GetDeploymentManifestBytes(ActivationContext appInfo)
        { 
            if (appInfo == null) 
                throw new ArgumentNullException("appInfo");
 
            return appInfo.GetDeploymentManifestBytes();
        }
  }
} 


// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
                        

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