internal static void GetEntryPoint (ActivationContext activationContext, out string fileName, out string parameters) {
parameters = null;
fileName = null;
ICMS appManifest = activationContext.ApplicationComponentManifest;
if (appManifest == null || appManifest.EntryPointSection == null)
throw new ArgumentException(Environment.GetResourceString("Argument_NoMain"));
IEnumUnknown refEnum = (IEnumUnknown) appManifest.EntryPointSection._NewEnum;
uint count = 0;
Object[] entries = new Object[1];
// Look for the first entry point. ClickOnce semantic validation ensures exactly one entry point is present.
if (refEnum.Next(1, entries, ref count) == 0 && count == 1) {
IEntryPointEntry iref= (IEntryPointEntry) entries[0];
EntryPointEntry reference = iref.AllData;
if (reference.CommandLine_File != null && reference.CommandLine_File.Length > 0) {
fileName = reference.CommandLine_File;
} else {
// Locate the dependent assembly that is being refered to. Well-formed manifests should have an identity.
IAssemblyReferenceEntry refEntry = null;
object assemblyObj = null;
if (reference.Identity != null) {
((ISectionWithReferenceIdentityKey)appManifest.AssemblyReferenceSection).Lookup(reference.Identity, out assemblyObj);
refEntry = (IAssemblyReferenceEntry) assemblyObj;
fileName = refEntry.DependentAssembly.Codebase;
}
}
parameters = reference.CommandLine_Parameters;
}
}
public static bool DetermineApplicationTrust(ActivationContext activationContext, TrustManagerContext context)
{
if (activationContext == null)
{
throw new ArgumentNullException("activationContext");
}
ApplicationTrust trust = null;
AppDomainManager domainManager = AppDomain.CurrentDomain.DomainManager;
if (domainManager != null)
{
HostSecurityManager hostSecurityManager = domainManager.HostSecurityManager;
if ((hostSecurityManager != null) && ((hostSecurityManager.Flags & HostSecurityManagerOptions.HostDetermineApplicationTrust) == HostSecurityManagerOptions.HostDetermineApplicationTrust))
{
trust = hostSecurityManager.DetermineApplicationTrust(CmsUtils.MergeApplicationEvidence(null, activationContext.Identity, activationContext, null), null, context);
if (trust == null)
{
return false;
}
return trust.IsApplicationTrustedToRun;
}
}
trust = DetermineApplicationTrustInternal(activationContext, context);
if (trust == null)
{
return false;
}
return trust.IsApplicationTrustedToRun;
}
static StackObject *CreateInstance_21(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
{
CSHotFix.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
StackObject *ptr_of_this_method;
StackObject *__ret = ILIntepreter.Minus(__esp, 2);
ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
System.String[] @activationCustomData = (System.String[]) typeof(System.String[]).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
ptr_of_this_method = ILIntepreter.Minus(__esp, 2);
System.ActivationContext @activationContext = (System.ActivationContext) typeof(System.ActivationContext).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
var result_of_this_method = System.Activator.CreateInstance(@activationContext, @activationCustomData);
object obj_result_of_this_method = result_of_this_method;
if (obj_result_of_this_method is CrossBindingAdaptorType)
{
return(ILIntepreter.PushObject(__ret, __mStack, ((CrossBindingAdaptorType)obj_result_of_this_method).ILInstance));
}
return(ILIntepreter.PushObject(__ret, __mStack, result_of_this_method));
}
public static ManifestSignatureInformationCollection VerifySignature(ActivationContext application, ManifestKinds manifests, X509RevocationFlag revocationFlag, X509RevocationMode revocationMode)
{
if (application == null)
{
throw new ArgumentNullException("application");
}
if ((revocationFlag < X509RevocationFlag.EndCertificateOnly) || (X509RevocationFlag.ExcludeRoot < revocationFlag))
{
throw new ArgumentOutOfRangeException("revocationFlag");
}
if ((revocationMode < X509RevocationMode.NoCheck) || (X509RevocationMode.Offline < revocationMode))
{
throw new ArgumentOutOfRangeException("revocationMode");
}
List<ManifestSignatureInformation> signatureInformation = new List<ManifestSignatureInformation>();
if ((manifests & ManifestKinds.Deployment) == ManifestKinds.Deployment)
{
ManifestSignedXml xml = new ManifestSignedXml(GetManifestXml(application, ManifestKinds.Deployment), ManifestKinds.Deployment);
signatureInformation.Add(xml.VerifySignature(revocationFlag, revocationMode));
}
if ((manifests & ManifestKinds.Application) == ManifestKinds.Application)
{
ManifestSignedXml xml2 = new ManifestSignedXml(GetManifestXml(application, ManifestKinds.Application), ManifestKinds.Application);
signatureInformation.Add(xml2.VerifySignature(revocationFlag, revocationMode));
}
return new ManifestSignatureInformationCollection(signatureInformation);
}
private static unsafe XmlDocument GetManifestXml(ActivationContext application, ManifestKinds manifest)
{
IStream applicationComponentManifest = null;
if (manifest == ManifestKinds.Application)
{
applicationComponentManifest = InternalActivationContextHelper.GetApplicationComponentManifest(application) as IStream;
}
else if (manifest == ManifestKinds.Deployment)
{
applicationComponentManifest = InternalActivationContextHelper.GetDeploymentComponentManifest(application) as IStream;
}
using (MemoryStream stream2 = new MemoryStream())
{
byte[] pv = new byte[0x1000];
int count = 0;
do
{
applicationComponentManifest.Read(pv, pv.Length, new IntPtr((void*) &count));
stream2.Write(pv, 0, count);
}
while (count == pv.Length);
stream2.Position = 0L;
XmlDocument document = new XmlDocument {
PreserveWhitespace = true
};
document.Load(stream2);
return document;
}
}
public ApplicationSecurityInfo(ActivationContext activationContext)
{
if (activationContext == null)
{
throw new ArgumentNullException("activationContext");
}
this.m_context = activationContext;
}
internal static bool CompareIdentities(ActivationContext activationContext1, ActivationContext activationContext2)
{
if ((activationContext1 != null) && (activationContext2 != null))
{
return IsolationInterop.AppIdAuthority.AreDefinitionsEqual(0, activationContext1.Identity.Identity, activationContext2.Identity.Identity);
}
return (activationContext1 == activationContext2);
}
public static byte[] GetDeploymentManifestBytes(ActivationContext appInfo)
{
if (appInfo == null)
{
throw new ArgumentNullException("appInfo");
}
return appInfo.GetDeploymentManifestBytes();
}
public static System.Security.Policy.ApplicationTrust RequestTrust(SubscriptionState subState, bool isShellVisible, bool isUpdate, ActivationContext actCtx)
{
TrustManagerContext tmc = new TrustManagerContext {
IgnorePersistedDecision = false,
NoPrompt = false,
Persist = true
};
return RequestTrust(subState, isShellVisible, isUpdate, actCtx, tmc);
}
// Constructor.
internal BindCompletedEventArgs
(Exception error, bool cancelled, Object userState,
ActivationContext activationContext, String friendlyName,
bool isCached)
: base(error, cancelled, userState)
{
this.activationContext = activationContext;
this.friendlyName = friendlyName;
this.isCached = isCached;
}
public ActivationArguments(System.ActivationContext activationContext, string[] activationData)
{
if (activationContext == null)
{
throw new ArgumentNullException("activationContext");
}
this.m_appFullName = activationContext.Identity.FullName;
this.m_appManifestPaths = activationContext.ManifestPaths;
this.m_activationData = activationData;
this.m_useFusionActivationContext = true;
}
private static async Task Proceed(Func<Task<object>> proceed, ActivationContext ctx)
{
if (!ctx.SkipAwait)
{
await proceed();
}
else
{
proceed();
}
}
public static System.Security.Policy.ApplicationTrust PersistTrustWithoutEvaluation(ActivationContext actCtx)
{
ApplicationSecurityInfo info = new ApplicationSecurityInfo(actCtx);
System.Security.Policy.ApplicationTrust trust = new System.Security.Policy.ApplicationTrust(actCtx.Identity) {
IsApplicationTrustedToRun = true,
DefaultGrantSet = new PolicyStatement(info.DefaultRequestSet, PolicyStatementAttribute.Nothing),
Persist = true,
ApplicationIdentity = actCtx.Identity
};
ApplicationSecurityManager.UserApplicationTrusts.Add(trust);
return trust;
}
private async Task<ActivationContext> DoAfter(MethodAdviceContext context, ActivationContext ctx)
{
if (context.IsAwaitable())
{
ctx = await AfterProcesssingAsync(ctx);
}
else
{
ctx = AfterProcesssing(ctx);
}
return ctx;
}
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));
return CreateInstanceHelper(adSetup);
}
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);
}
}
}
public static System.Security.Policy.ApplicationTrust RequestTrust(SubscriptionState subState, bool isShellVisible, bool isUpdate, ActivationContext actCtx, TrustManagerContext tmc)
{
Logger.AddMethodCall("ApplicationTrust.RequestTrust(isShellVisible=" + isShellVisible.ToString() + ", isUpdate=" + isUpdate.ToString() + ", subState.IsInstalled=" + subState.IsInstalled.ToString() + ") called.");
if (!subState.IsInstalled || (subState.IsShellVisible != isShellVisible))
{
tmc.IgnorePersistedDecision = true;
}
if (isUpdate)
{
tmc.PreviousApplicationIdentity = subState.CurrentBind.ToApplicationIdentity();
}
bool flag = false;
try
{
Logger.AddInternalState("Calling ApplicationSecurityManager.DetermineApplicationTrust().");
Logger.AddInternalState("Trust Manager Context=" + Logger.Serialize(tmc));
flag = ApplicationSecurityManager.DetermineApplicationTrust(actCtx, tmc);
}
catch (TypeLoadException exception)
{
throw new InvalidDeploymentException(Resources.GetString("Ex_InvalidTrustInfo"), exception);
}
if (!flag)
{
throw new TrustNotGrantedException(Resources.GetString("Ex_NoTrust"));
}
Logger.AddInternalState("Trust granted.");
System.Security.Policy.ApplicationTrust trust = null;
for (int i = 0; i < 5; i++)
{
trust = ApplicationSecurityManager.UserApplicationTrusts[actCtx.Identity.FullName];
if (trust != null)
{
break;
}
Thread.Sleep(10);
}
if (trust == null)
{
throw new InvalidDeploymentException(Resources.GetString("Ex_InvalidMatchTrust"));
}
return trust;
}
internal static string GetEntryPointFullPath (ActivationContext activationContext) {
string file, parameters;
GetEntryPoint(activationContext, out file, out parameters);
if (!String.IsNullOrEmpty(file)) {
string directoryName = activationContext.ApplicationDirectory;
if (directoryName == null || directoryName.Length == 0) {
// If we were passed a relative path, assume the app base is the current working directory
StringBuilder sb = new StringBuilder(Path.MAX_PATH + 1);
if (Win32Native.GetCurrentDirectory(sb.Capacity, sb) == 0)
System.IO.__Error.WinIOError();
directoryName = sb.ToString();
}
file = Path.Combine(directoryName, file);
}
return file;
}
internal static string GetEntryPointFullPath (ActivationContext activationContext)
{
string file, parameters;
GetEntryPoint(activationContext, out file, out parameters);
if (!string.IsNullOrEmpty(file))
{
string directoryName = activationContext.ApplicationDirectory;
if (directoryName == null || directoryName.Length == 0)
{
// If we were passed a relative path, assume the app base is the current working directory
directoryName = Directory.UnsafeGetCurrentDirectory();
}
file = Path.Combine(directoryName, file);
}
return file;
}
internal static IAssemblyReferenceEntry[] GetDependentAssemblies(ActivationContext activationContext)
{
IAssemblyReferenceEntry[] entries = null;
ICMS appManifest = activationContext.ApplicationComponentManifest;
if (appManifest == null)
return null;
ISection dependencySection = appManifest.AssemblyReferenceSection;
uint count = (dependencySection != null) ? dependencySection.Count : 0;
if (count > 0)
{
uint fetched = 0;
entries = new IAssemblyReferenceEntry[count];
IEnumUnknown dependencyEnum = (IEnumUnknown)dependencySection._NewEnum;
int hr = dependencyEnum.Next(count, entries, ref fetched);
if (fetched != count || hr < 0)
return null; //
}
return entries;
}
internal static IAssemblyReferenceEntry[] GetDependentAssemblies(ActivationContext activationContext)
{
IAssemblyReferenceEntry[] rgelt = null;
ICMS applicationComponentManifest = activationContext.ApplicationComponentManifest;
if (applicationComponentManifest != null)
{
ISection assemblyReferenceSection = applicationComponentManifest.AssemblyReferenceSection;
uint celt = (assemblyReferenceSection != null) ? assemblyReferenceSection.Count : 0;
if (celt <= 0)
{
return rgelt;
}
uint celtFetched = 0;
rgelt = new IAssemblyReferenceEntry[celt];
int num3 = ((IEnumUnknown) assemblyReferenceSection._NewEnum).Next(celt, rgelt, ref celtFetched);
if ((celtFetched == celt) && (num3 >= 0))
{
return rgelt;
}
}
return null;
}
internal ManifestRunner(AppDomain domain, ActivationContext activationContext)
{
string str;
string str2;
this.m_domain = domain;
CmsUtils.GetEntryPoint(activationContext, out str, out str2);
if (string.IsNullOrEmpty(str))
{
throw new ArgumentException(Environment.GetResourceString("Argument_NoMain"));
}
if (string.IsNullOrEmpty(str2))
{
this.m_args = new string[0];
}
else
{
this.m_args = str2.Split(new char[] { ' ' });
}
this.m_apt = ApartmentState.Unknown;
string applicationDirectory = activationContext.ApplicationDirectory;
this.m_path = Path.Combine(applicationDirectory, str);
}
internal GetManifestCompletedEventArgs(BindCompletedEventArgs e, ActivationDescription activationDescription, string logFilePath, Logger.LogIdentity log) : base(e.Error, e.Cancelled, e.UserState)
{
this._applicationIdentity = (e.ActivationContext != null) ? e.ActivationContext.Identity : null;
Logger.AddInternalState(log, "Creating GetManifestCompletedEventArgs.");
string text = this._applicationIdentity.ToString();
DefinitionAppId id = new DefinitionAppId(text);
this._subId = id.DeploymentIdentity.ToSubscriptionId();
this._logFilePath = logFilePath;
this._isCached = e.IsCached;
this._name = e.FriendlyName;
this._actContext = e.ActivationContext;
Logger.AddInternalState(log, "Application identity=" + text);
Logger.AddInternalState(log, "Subscription identity=" + ((this._subId != null) ? this._subId.ToString() : "null"));
Logger.AddInternalState(log, "IsCached=" + this._isCached.ToString());
if (this._isCached)
{
this._rawDeploymentManifest = e.ActivationContext.DeploymentManifestBytes;
this._rawApplicationManifest = e.ActivationContext.ApplicationManifestBytes;
}
this._activationDescription = activationDescription;
this._version = this._activationDescription.AppId.DeploymentIdentity.Version;
this._support = this._activationDescription.DeployManifest.Description.SupportUri;
}
internal GetManifestCompletedEventArgs(BindCompletedEventArgs e, ActivationDescription activationDescription, string logFilePath, Logger.LogIdentity log) : base(e.Error, e.Cancelled, e.UserState)
{
this._applicationIdentity = (e.ActivationContext != null) ? e.ActivationContext.Identity : null;
Logger.AddInternalState(log, "Creating GetManifestCompletedEventArgs.");
string text = this._applicationIdentity.ToString();
DefinitionAppId id = new DefinitionAppId(text);
this._subId = id.DeploymentIdentity.ToSubscriptionId();
this._logFilePath = logFilePath;
this._isCached = e.IsCached;
this._name = e.FriendlyName;
this._actContext = e.ActivationContext;
Logger.AddInternalState(log, "Application identity=" + text);
Logger.AddInternalState(log, "Subscription identity=" + ((this._subId != null) ? this._subId.ToString() : "null"));
Logger.AddInternalState(log, "IsCached=" + this._isCached.ToString());
if (this._isCached)
{
this._rawDeploymentManifest = e.ActivationContext.DeploymentManifestBytes;
this._rawApplicationManifest = e.ActivationContext.ApplicationManifestBytes;
}
this._activationDescription = activationDescription;
this._version = this._activationDescription.AppId.DeploymentIdentity.Version;
this._support = this._activationDescription.DeployManifest.Description.SupportUri;
}
[System.Security.SecurityCritical] // auto-generated
private void SetupApplicationHelper (Evidence providedSecurityInfo, Evidence creatorsSecurityInfo, ApplicationIdentity appIdentity, ActivationContext activationContext, string[] activationData) {
Contract.Requires(providedSecurityInfo != null);
HostSecurityManager securityManager = AppDomain.CurrentDomain.HostSecurityManager;
ApplicationTrust appTrust = securityManager.DetermineApplicationTrust(providedSecurityInfo, creatorsSecurityInfo, new TrustManagerContext());
if (appTrust == null || !appTrust.IsApplicationTrustedToRun)
throw new PolicyException(Environment.GetResourceString("Policy_NoExecutionPermission"),
System.__HResults.CORSEC_E_NO_EXEC_PERM,
null);
// The application is trusted to run. Set up the AppDomain according to the manifests.
if (activationContext != null)
SetupDomainForApplication(activationContext, activationData);
SetupDomainSecurityForApplication(appIdentity, appTrust);
}
public static ManifestSignatureInformationCollection VerifySignature(ActivationContext application, System.Security.ManifestKinds manifests, System.Security.Cryptography.X509Certificates.X509RevocationFlag revocationFlag, System.Security.Cryptography.X509Certificates.X509RevocationMode revocationMode)
{
Contract.Ensures(Contract.Result<System.Security.Cryptography.ManifestSignatureInformationCollection>() != null);
return default(ManifestSignatureInformationCollection);
}
public static ManifestSignatureInformationCollection VerifySignature(ActivationContext application, System.Security.ManifestKinds manifests)
{
Contract.Ensures(Contract.Result<System.Security.Cryptography.ManifestSignatureInformationCollection>() != null);
return default(ManifestSignatureInformationCollection);
}
private static bool SearchPreviousTrustedVersion(ActivationContext activationContext,
out ArrayList matchingTrusts)
{
// No match found by default
matchingTrusts = null;
ApplicationTrustCollection appTrusts = ApplicationSecurityManager.UserApplicationTrusts;
foreach (ApplicationTrust appTrust in appTrusts) {
IDefinitionAppId appTrustAppId = IsolationInterop.AppIdAuthority.TextToDefinition(0, appTrust.ApplicationIdentity.FullName);
IDefinitionAppId actCtxAppId = IsolationInterop.AppIdAuthority.TextToDefinition(0, activationContext.Identity.FullName);
if (IsolationInterop.AppIdAuthority.AreDefinitionsEqual((uint) IAPPIDAUTHORITY_ARE_DEFINITIONS_EQUAL_FLAGS.IAPPIDAUTHORITY_ARE_DEFINITIONS_EQUAL_FLAG_IGNORE_VERSION, appTrustAppId, actCtxAppId))
{
// Found an older matching app (or same version app which should never occur in theory)
if (matchingTrusts == null)
{
matchingTrusts = new ArrayList();
}
matchingTrusts.Add(appTrust);
}
}
// (matchingTrusts != null) <==> Found a prior version that was allowed to run.
return (matchingTrusts != null);
}
private static ApplicationTrust BlockingPrompt(ActivationContext activationContext,
ParsedData parsedData,
String deploymentUrl,
ApplicationSecurityInfo info,
ApplicationTrustExtraInfo appTrustExtraInfo,
string zoneName,
bool permissionElevationRequired)
{
TrustManagerPromptOptions options = CompletePromptOptions(permissionElevationRequired ? (TrustManagerPromptOptions.StopApp | TrustManagerPromptOptions.RequiresPermissions) : TrustManagerPromptOptions.StopApp,
appTrustExtraInfo, zoneName, info);
try
{
TrustManagerPromptUIThread errorDialog = new TrustManagerPromptUIThread(string.IsNullOrEmpty(parsedData.AppName) ? info.ApplicationId.Name : parsedData.AppName,
DefaultBrowserExePath,
parsedData.SupportUrl,
GetHostFromDeploymentUrl(deploymentUrl),
parsedData.AuthenticodedPublisher /*publisherName*/,
parsedData.Certificate,
options);
errorDialog.ShowDialog();
}
catch (Exception ex)
{
Debug.Fail("Error occurred while showing error dialog: " + ex.Message);
}
// Trust Manager should prompt, but is not allowed to. Return Don't Trust and Don't Persist.
return CreateApplicationTrust(activationContext, info, appTrustExtraInfo, false /*trust*/, false /*persist*/);
}
public ActivationArguments(System.ActivationContext activationData) : this(activationData, null)
{
}
/// <summary>Initializes a new instance of the <see cref="T:System.AppDomainSetup" /> class with the specified activation context to use for manifest-based activation of an application domain.</summary><param name="activationContext">The activation context to be used for an application domain.</param><exception cref="T:System.ArgumentNullException"><paramref name="activationContext" /> is null.</exception>
public AppDomainSetup(ActivationContext activationContext)
{
throw new NotImplementedException();
}
public AppDomainSetup(ActivationContext activationContext) : this(new System.Runtime.Hosting.ActivationArguments(activationContext))
{
}
public static ObjectHandle CreateInstance(ActivationContext activationContext)
{
throw new NotImplementedException();
}
public static ObjectHandle CreateInstance(ActivationContext activationContext, string [] activationCustomData)
{
throw new NotImplementedException();
}
public AppDomainSetup(ActivationContext activationContext)
{
_activationArguments = new ActivationArguments(activationContext);
}
[System.Security.SecurityCritical] // auto-generated
private void SetupDomainForApplication(ActivationContext activationContext, string[] activationData) {
Contract.Requires(activationContext != null);
if (IsDefaultAppDomain()) {
// make the ActivationArguments available off the AppDomain object.
AppDomainSetup adSetup = this.FusionStore;
adSetup.ActivationArguments = new ActivationArguments(activationContext, activationData);
// set the application base to point at where the application resides
string entryPointPath = CmsUtils.GetEntryPointFullPath(activationContext);
if (!String.IsNullOrEmpty(entryPointPath))
adSetup.SetupDefaults(entryPointPath);
else
adSetup.ApplicationBase = activationContext.ApplicationDirectory;
// update fusion context
SetupFusionStore(adSetup, null);
}
// perform app data directory migration.
activationContext.PrepareForExecution();
activationContext.SetApplicationState(ActivationContext.ApplicationState.Starting);
// set current app data directory.
activationContext.SetApplicationState(ActivationContext.ApplicationState.Running);
// make data directory path available.
IPermission permission = null;
string dataDirectory = activationContext.DataDirectory;
if (dataDirectory != null && dataDirectory.Length > 0)
permission = new FileIOPermission(FileIOPermissionAccess.PathDiscovery, dataDirectory);
this.SetData("DataDirectory", dataDirectory, permission);
_activationContext = activationContext;
}
internal static ApplicationTrust DetermineApplicationTrustInternal(ActivationContext activationContext, TrustManagerContext context)
{
ApplicationTrust trust = null;
ApplicationTrustCollection trusts = new ApplicationTrustCollection(true);
if ((context == null) || !context.IgnorePersistedDecision)
{
trust = trusts[activationContext.Identity.FullName];
if (trust != null)
{
return trust;
}
}
trust = ApplicationTrustManager.DetermineApplicationTrust(activationContext, context);
if (trust == null)
{
trust = new ApplicationTrust(activationContext.Identity);
}
trust.ApplicationIdentity = activationContext.Identity;
if (trust.Persist)
{
trusts.Add(trust);
}
return trust;
}
public virtual ObjectHandle CreateInstance(ActivationContext activationContext)
{
return this.CreateInstance(activationContext, null);
}
public static System.Runtime.Remoting.ObjectHandle CreateInstance(ActivationContext activationContext)
{
return(default(System.Runtime.Remoting.ObjectHandle));
}
public static object GetActivationContextData (ActivationContext appInfo)
{
throw new NotImplementedException ();
}
public static ObjectHandle CreateInstance(ActivationContext activationContext, string[] activationCustomData)
{
throw new PlatformNotSupportedException("Activator.CreateInstance (ActivationContext) is not supported on this platform.");
}
internal BindCompletedEventArgs(Exception error, bool cancelled, object userState, System.ActivationContext actCtx, string name, bool cached) : base(error, cancelled, userState)
{
this._actCtx = actCtx;
this._name = name;
this._cached = cached;
}
public AppDomainSetup(ActivationContext activationContext)
{
Contract.Requires(activationContext.Identity != null);
}