C# System.ApplicationIdentity类代码示例

		public void ApplicationIdentity_WithCulture ()
		{
			ApplicationIdentity appid = new ApplicationIdentity ("Mono, Culture=fr-ca");
			Assert.IsNull (appid.CodeBase, "CodeBase");
			Assert.AreEqual ("Mono, Culture=fr-ca", appid.FullName);
			Assert.AreEqual ("Mono, Culture=fr-ca", appid.ToString ());
		}

 private void CreateFromName(ApplicationIdentity applicationIdentity)
 {
     if (applicationIdentity == null)
     {
         throw new ArgumentNullException("applicationIdentity");
     }
     this._applicationIdentity = applicationIdentity;
     IEnumDefinitionIdentity identity = this._applicationIdentity.Identity.EnumAppPath();
     this._definitionIdentities = new ArrayList(2);
     IDefinitionIdentity[] definitionIdentity = new IDefinitionIdentity[1];
     while (identity.Next(1, definitionIdentity) == 1)
     {
         this._definitionIdentities.Add(definitionIdentity[0]);
     }
     this._definitionIdentities.TrimToSize();
     if (this._definitionIdentities.Count <= 1)
     {
         throw new ArgumentException(Environment.GetResourceString("Argument_InvalidAppId"));
     }
     this._manifestPaths = null;
     this._manifests = null;
     this._actContext = IsolationInterop.CreateActContext(this._applicationIdentity.Identity);
     this._form = ContextForm.StoreBounded;
     this._appRunState = ApplicationStateDisposition.Undefined;
 }

    public static System.ActivationContext CreatePartialActivationContext (ApplicationIdentity identity, string[] manifestPaths)
    {
      Contract.Ensures (Contract.Result<System.ActivationContext>() != null);
      Contract.Ensures (manifestPaths.Length >= 0);

      return default(System.ActivationContext);
    }

		static public ActivationContext CreatePartialActivationContext (ApplicationIdentity identity)
		{
			if (identity == null)
				throw new ArgumentNullException ("identity");

			// TODO - throw new ArgumentException
			// - for invalid ApplicationIdentity

			return new ActivationContext (identity);
		}

 public HostContextInternal(TrustManagerContext trustManagerContext)
 {
     if (trustManagerContext == null)
     {
         this.persist = true;
     }
     else
     {
         this.ignorePersistedDecision = trustManagerContext.IgnorePersistedDecision;
         this.noPrompt = trustManagerContext.NoPrompt;
         this.persist = trustManagerContext.Persist;
         this.previousAppId = trustManagerContext.PreviousApplicationIdentity;
     }
 }

 internal static void CreateActivationContext(string fullName, string[] manifestPaths, bool useFusionActivationContext, out ApplicationIdentity applicationIdentity, out ActivationContext activationContext)
 {
     applicationIdentity = new ApplicationIdentity(fullName);
     activationContext = null;
     if (useFusionActivationContext)
     {
         if (manifestPaths != null)
         {
             activationContext = new ActivationContext(applicationIdentity, manifestPaths);
         }
         else
         {
             activationContext = new ActivationContext(applicationIdentity);
         }
     }
 }

 private void CreateFromNameAndManifests(ApplicationIdentity applicationIdentity, string[] manifestPaths)
 {
     if (applicationIdentity == null)
     {
         throw new ArgumentNullException("applicationIdentity");
     }
     if (manifestPaths == null)
     {
         throw new ArgumentNullException("manifestPaths");
     }
     this._applicationIdentity = applicationIdentity;
     IEnumDefinitionIdentity identity = this._applicationIdentity.Identity.EnumAppPath();
     this._manifests = new ArrayList(2);
     this._manifestPaths = new string[manifestPaths.Length];
     IDefinitionIdentity[] definitionIdentity = new IDefinitionIdentity[1];
     int index = 0;
     while (identity.Next(1, definitionIdentity) == 1)
     {
         ICMS icms = (ICMS) IsolationInterop.ParseManifest(manifestPaths[index], null, ref IsolationInterop.IID_ICMS);
         if (!IsolationInterop.IdentityAuthority.AreDefinitionsEqual(0, icms.Identity, definitionIdentity[0]))
         {
             throw new ArgumentException(Environment.GetResourceString("Argument_IllegalAppIdMismatch"));
         }
         this._manifests.Add(icms);
         this._manifestPaths[index] = manifestPaths[index];
         index++;
     }
     if (index != manifestPaths.Length)
     {
         throw new ArgumentException(Environment.GetResourceString("Argument_IllegalAppId"));
     }
     this._manifests.TrimToSize();
     if (this._manifests.Count <= 1)
     {
         throw new ArgumentException(Environment.GetResourceString("Argument_InvalidAppId"));
     }
     this._definitionIdentities = null;
     this._actContext = null;
     this._form = ContextForm.Loose;
     this._appRunState = ApplicationStateDisposition.Undefined;
 }

        internal static bool CompareIdentities(ApplicationIdentity applicationIdentity1, ApplicationIdentity applicationIdentity2, ApplicationVersionMatch versionMatch)
        {
            uint num;
            if ((applicationIdentity1 == null) || (applicationIdentity2 == null))
            {
                return (applicationIdentity1 == applicationIdentity2);
            }
            switch (versionMatch)
            {
                case ApplicationVersionMatch.MatchExactVersion:
                    num = 0;
                    break;

                case ApplicationVersionMatch.MatchAllVersions:
                    num = 1;
                    break;

                default:
                    throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", new object[] { (int) versionMatch }), "versionMatch");
            }
            return IsolationInterop.AppIdAuthority.AreDefinitionsEqual(num, applicationIdentity1.Identity, applicationIdentity2.Identity);
        }

        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
        } 

 internal ActivationContext(ApplicationIdentity applicationIdentity)
 {
     this.CreateFromName(applicationIdentity);
 }

 public static ActivationContext CreatePartialActivationContext(ApplicationIdentity identity, string[] manifestPaths)
 {
     return new ActivationContext(identity, manifestPaths);
 }

 [System.Security.SecurityCritical]  // auto-generated
 private void SetupDomainSecurityForApplication(ApplicationIdentity appIdentity,
                                                ApplicationTrust appTrust)
 {
     // Set the Application trust on the managed side.
     _applicationIdentity = appIdentity;
     SetupDomainSecurityForHomogeneousDomain(appTrust, false);
 }

 public ApplicationTrust(ApplicationIdentity applicationIdentity)
 {
 }

		public static object GetInternalAppId (ApplicationIdentity id)
		{
			throw new NotImplementedException ();
		}

        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
        }