ApplicationActivator Classe

Definição

public ref class ApplicationActivator

[System.Runtime.InteropServices.ComVisible(true)]
public class ApplicationActivator

[<System.Runtime.InteropServices.ComVisible(true)>]
type ApplicationActivator = class

Public Class ApplicationActivator

Herança

Object

ApplicationActivator

Atributos

ComVisibleAttribute

Exemplos

O exemplo de código seguinte mostra como obter um ApplicationActivator objeto a partir da corrente DomainManager para uma aplicação baseada em manifestos.

using System;
using System.Collections;
using System.Text;
using System.Security.Policy;
using System.Reflection;
using System.Security;
using System.Runtime.Hosting;

namespace ActivationContextSample
{
    public class Program : MarshalByRefObject
    {
        public static void Main(string[] args)
        {
            // Get the AppDomainManager from the current domain.
            AppDomainManager domainMgr = AppDomain.CurrentDomain.DomainManager;
            // Get the ApplicationActivator from the AppDomainManager.
            ApplicationActivator appActivator = domainMgr.ApplicationActivator;
            Console.WriteLine("Assembly qualified name from the application activator.");
            Console.WriteLine(appActivator.GetType().AssemblyQualifiedName);
            // Get the ActivationArguments from the SetupInformation property of the domain.
            ActivationArguments activationArgs = AppDomain.CurrentDomain.SetupInformation.ActivationArguments;
            // Get the ActivationContext from the ActivationArguments.
            ActivationContext actContext = activationArgs.ActivationContext;
            Console.WriteLine("The ActivationContext.Form property value is: " +
                activationArgs.ActivationContext.Form);
            Console.Read();
        }
    
        public void Run()
        {
            Main(new string[] { });
            Console.ReadLine();
        }
    }
}

Imports System.Collections
Imports System.Text
Imports System.Security.Policy
Imports System.Reflection
Imports System.Security
Imports System.Security.Permissions
Imports System.Runtime.Hosting



Public Class Program
    Inherits MarshalByRefObject

    <SecurityPermission(SecurityAction.LinkDemand, ControlDomainPolicy:=True)> _
    Public Shared Sub Main(ByVal args() As String)
        ' Get the AppDomainManager from the current domain.
        Dim domainMgr As AppDomainManager = AppDomain.CurrentDomain.DomainManager
        ' Get the ApplicationActivator from the AppDomainManager.
        Dim appActivator As ApplicationActivator = domainMgr.ApplicationActivator
        Console.WriteLine("Assembly qualified name from the application activator.")
        Console.WriteLine(appActivator.GetType().AssemblyQualifiedName)
        Dim ac As ActivationContext = AppDomain.CurrentDomain.ActivationContext
        ' Get the ActivationArguments from the SetupInformation property of the domain.
        Dim activationArgs As ActivationArguments = AppDomain.CurrentDomain.SetupInformation.ActivationArguments
        ' Get the ActivationContext from the ActivationArguments.
        Dim actContext As ActivationContext = activationArgs.ActivationContext
        Console.WriteLine("The ActivationContext.Form property value is: " + _
         activationArgs.ActivationContext.Form.ToString())
        Console.Read()

    End Sub

    <SecurityPermission(SecurityAction.LinkDemand, ControlDomainPolicy:=True)> _
    Public Sub Run()
        Main(New String() {})
        Console.ReadLine()

    End Sub
End Class

Observações

Existe uma única instância designada da ApplicationActivator classe em cada AppDomain uma para a qual todas as chamadas de ativação são encaminhadas. O AppDomainManager atual AppDomain pode fornecer a sua própria personalização ApplicationActivator para este fim. Se não for fornecida uma customização ApplicationActivator , é criada uma instância do default ApplicationActivator .

Os passos seguintes descrevem o comportamento da CreateInstance implementação padrão do método:

1. Verifica se o ActivationContext do complemento a ativar corresponde ao ActivationContext do domínio atual; caso contrário, avança para o passo 2. Caso contrário, executa a montagem e devolve o resultado envolto num handle de objeto.

2. Ativa o complemento num novo AppDomainarquivo . São dados os passos seguintes para inicializar um novo AppDomain usando o ActivationArguments for the add-in.

   1. Cria um novo AppDomainSetup objeto usando um ActivationArguments objeto contendo o contexto de ativação do complemento.

   2. Chama o CreateInstanceHelper método para criar um novo domínio usando o AppDomainSetup objeto.

   3. O CreateInstanceHelper método chama o HostSecurityManager.DetermineApplicationTrust método para adquirir um ApplicationTrust objeto para o complemento. Se a IsApplicationTrustedToRun propriedade devolver true, o add-in é executado. Se não, CreateInstanceHelper lança um PolicyException indicativo de que não foi possível obter permissão de execução.

   4. Se o add-in for confiável para correr, então um novo AppDomain é criado e configurado para ActivationContext o do add-in, e o add-in é carregado e executado.

   5. O resultado da ativação do add-in é devolvido, envolto num handle de objeto.

Um ativador personalizado pode adaptar a ativação de um add-in a um conjunto particular de circunstâncias. Por exemplo, um ativador personalizado poderia encontrar um ativo existente AppDomain para ativar este complemento em vez de criar um novo domínio cada vez.

Os passos seguintes descrevem o comportamento de um personalizado ApplicationActivator que ativa um add-in numa versão existente AppDomain:

1. O ativador personalizado encontra um domínio que tem o mesmo ActivationContext que o add-in que está a ser ativado.

2. Se o ActivationContext nunca tiver sido visto antes no processo, o ativador personalizado cria um novo AppDomain para isto ActivationContext chamando diretamente o CreateDomain método, ou delegando esta atividade ao CreateInstanceHelper na classe base.

3. Se existir um domínio existente com o mesmo ActivationContext, então o ativador pode delegar a CreateInstance chamada ao ApplicationActivator método no domínio de destino. Note que isto seria uma chamada cruz-domínio para um ApplicationActivator que reside no alvo AppDomain.