AppDomain Classe

Definição

Representa um domínio de aplicativo, que é um ambiente isolado em que os aplicativos são executados.Represents an application domain, which is an isolated environment where applications execute. Essa classe não pode ser herdada.This class cannot be inherited.

public ref class AppDomain sealed : MarshalByRefObject, _AppDomain, System::Security::IEvidenceFactory
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class AppDomain : MarshalByRefObject, _AppDomain, System.Security.IEvidenceFactory
type AppDomain = class
    inherit MarshalByRefObject
    interface _AppDomain
    interface IEvidenceFactory
Public NotInheritable Class AppDomain
Inherits MarshalByRefObject
Implements _AppDomain, IEvidenceFactory
Herança
Atributos
Implementações

Exemplos

Este exemplo mostra como criar um novo AppDomain, criar uma instância de um tipo nesse novo AppDomaine se comunicar com o objeto desse tipo.This example shows how to create a new AppDomain, instantiate a type in that new AppDomain, and communicate with that type's object. Além disso, este exemplo mostra como descarregar o AppDomain fazendo com que o objeto seja coletado como lixo.In addition, this example shows how to unload the AppDomain causing the object to be garbage collected.

using namespace System;
using namespace System::Reflection;
using namespace System::Threading;
using namespace System::Security::Policy;

// Because this class is derived from MarshalByRefObject, a proxy 
// to a MarshalByRefType object can be returned across an AppDomain 
// boundary.
ref class MarshalByRefType : MarshalByRefObject
{
public:
    //  Call this method via a proxy.
    void SomeMethod(String^ callingDomainName)
    {
        // Get this AppDomain's settings and display some of them.
        AppDomainSetup^ ads = AppDomain::CurrentDomain->SetupInformation;
        Console::WriteLine("AppName={0}, AppBase={1}, ConfigFile={2}", 
            ads->ApplicationName, 
            ads->ApplicationBase, 
            ads->ConfigurationFile
        );

        // Display the name of the calling AppDomain and the name 
        // of the second domain.
        // NOTE: The application's thread has transitioned between 
        // AppDomains.
        Console::WriteLine("Calling from '{0}' to '{1}'.", 
            callingDomainName, 
            Thread::GetDomain()->FriendlyName
        );
    };
};

void main()
{
    // Get and display the friendly name of the default AppDomain.
    String^ callingDomainName = Thread::GetDomain()->FriendlyName;
    Console::WriteLine(callingDomainName);

    // Get and display the full name of the EXE assembly.
    String^ exeAssembly = Assembly::GetEntryAssembly()->FullName;
    Console::WriteLine(exeAssembly);

    // Construct and initialize settings for a second AppDomain.
    AppDomainSetup^ ads = gcnew AppDomainSetup();
    ads->ApplicationBase = AppDomain::CurrentDomain->BaseDirectory;

    ads->DisallowBindingRedirects = false;
    ads->DisallowCodeDownload = true;
    ads->ConfigurationFile = 
        AppDomain::CurrentDomain->SetupInformation->ConfigurationFile;

    // Create the second AppDomain.
    AppDomain^ ad2 = AppDomain::CreateDomain("AD #2", 
        AppDomain::CurrentDomain->Evidence, ads);

    // Create an instance of MarshalbyRefType in the second AppDomain. 
    // A proxy to the object is returned.
    MarshalByRefType^ mbrt = 
        (MarshalByRefType^) ad2->CreateInstanceAndUnwrap(
            exeAssembly, 
            MarshalByRefType::typeid->FullName
        );

    // Call a method on the object via the proxy, passing the 
    // default AppDomain's friendly name in as a parameter.
    mbrt->SomeMethod(callingDomainName);

    // Unload the second AppDomain. This deletes its object and 
    // invalidates the proxy object.
    AppDomain::Unload(ad2);
    try
    {
        // Call the method again. Note that this time it fails 
        // because the second AppDomain was unloaded.
        mbrt->SomeMethod(callingDomainName);
        Console::WriteLine("Sucessful call.");
    }
    catch(AppDomainUnloadedException^)
    {
        Console::WriteLine("Failed call; this is expected.");
    }
}

/* This code produces output similar to the following: 

AppDomainX.exe
AppDomainX, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
AppName=, AppBase=C:\AppDomain\bin, ConfigFile=C:\AppDomain\bin\AppDomainX.exe.config
Calling from 'AppDomainX.exe' to 'AD #2'.
Failed call; this is expected.
 */
using System;
using System.Reflection;
using System.Threading;

class Module1
{
    public static void Main()
    {
        // Get and display the friendly name of the default AppDomain.
        string callingDomainName = Thread.GetDomain().FriendlyName;
        Console.WriteLine(callingDomainName);

        // Get and display the full name of the EXE assembly.
        string exeAssembly = Assembly.GetEntryAssembly().FullName;
        Console.WriteLine(exeAssembly);

        // Construct and initialize settings for a second AppDomain.
        AppDomainSetup ads = new AppDomainSetup();
        ads.ApplicationBase = AppDomain.CurrentDomain.BaseDirectory;

        ads.DisallowBindingRedirects = false;
        ads.DisallowCodeDownload = true;
        ads.ConfigurationFile = 
            AppDomain.CurrentDomain.SetupInformation.ConfigurationFile;

        // Create the second AppDomain.
        AppDomain ad2 = AppDomain.CreateDomain("AD #2", null, ads);

        // Create an instance of MarshalbyRefType in the second AppDomain. 
        // A proxy to the object is returned.
        MarshalByRefType mbrt = 
            (MarshalByRefType) ad2.CreateInstanceAndUnwrap(
                exeAssembly, 
                typeof(MarshalByRefType).FullName
            );

        // Call a method on the object via the proxy, passing the 
        // default AppDomain's friendly name in as a parameter.
        mbrt.SomeMethod(callingDomainName);

        // Unload the second AppDomain. This deletes its object and 
        // invalidates the proxy object.
        AppDomain.Unload(ad2);
        try
        {
            // Call the method again. Note that this time it fails 
            // because the second AppDomain was unloaded.
            mbrt.SomeMethod(callingDomainName);
            Console.WriteLine("Sucessful call.");
        }
        catch(AppDomainUnloadedException)
        {
            Console.WriteLine("Failed call; this is expected.");
        }
    }
}

// Because this class is derived from MarshalByRefObject, a proxy 
// to a MarshalByRefType object can be returned across an AppDomain 
// boundary.
public class MarshalByRefType : MarshalByRefObject
{
    //  Call this method via a proxy.
    public void SomeMethod(string callingDomainName)
    {
        // Get this AppDomain's settings and display some of them.
        AppDomainSetup ads = AppDomain.CurrentDomain.SetupInformation;
        Console.WriteLine("AppName={0}, AppBase={1}, ConfigFile={2}", 
            ads.ApplicationName, 
            ads.ApplicationBase, 
            ads.ConfigurationFile
        );

        // Display the name of the calling AppDomain and the name 
        // of the second domain.
        // NOTE: The application's thread has transitioned between 
        // AppDomains.
        Console.WriteLine("Calling from '{0}' to '{1}'.", 
            callingDomainName, 
            Thread.GetDomain().FriendlyName
        );
    }
}

/* This code produces output similar to the following: 

AppDomainX.exe
AppDomainX, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
AppName=, AppBase=C:\AppDomain\bin, ConfigFile=C:\AppDomain\bin\AppDomainX.exe.config
Calling from 'AppDomainX.exe' to 'AD #2'.
Failed call; this is expected.
 */
Imports System.Reflection
Imports System.Threading

Module Module1
    Sub Main()

        ' Get and display the friendly name of the default AppDomain.
        Dim callingDomainName As String = Thread.GetDomain().FriendlyName
        Console.WriteLine(callingDomainName)

        ' Get and display the full name of the EXE assembly.
        Dim exeAssembly As String = [Assembly].GetEntryAssembly().FullName
        Console.WriteLine(exeAssembly)

        ' Construct and initialize settings for a second AppDomain.
        Dim ads As New AppDomainSetup()
        ads.ApplicationBase = AppDomain.CurrentDomain.BaseDirectory
        ads.DisallowBindingRedirects = False
        ads.DisallowCodeDownload = True
        ads.ConfigurationFile = _
            AppDomain.CurrentDomain.SetupInformation.ConfigurationFile

        ' Create the second AppDomain.
        Dim ad2 As AppDomain = AppDomain.CreateDomain("AD #2", Nothing, ads)

        ' Create an instance of MarshalbyRefType in the second AppDomain. 
        ' A proxy to the object is returned.
        Dim mbrt As MarshalByRefType = CType( _
            ad2.CreateInstanceAndUnwrap(exeAssembly, _
                 GetType(MarshalByRefType).FullName), MarshalByRefType)

        ' Call a method on the object via the proxy, passing the default 
        ' AppDomain's friendly name in as a parameter.
        mbrt.SomeMethod(callingDomainName)

        ' Unload the second AppDomain. This deletes its object and 
        ' invalidates the proxy object.
        AppDomain.Unload(ad2)
        Try
            ' Call the method again. Note that this time it fails because 
            ' the second AppDomain was unloaded.
            mbrt.SomeMethod(callingDomainName)
            Console.WriteLine("Sucessful call.")
        Catch e As AppDomainUnloadedException
            Console.WriteLine("Failed call; this is expected.")
        End Try

    End Sub
End Module

' Because this class is derived from MarshalByRefObject, a proxy 
' to a MarshalByRefType object can be returned across an AppDomain 
' boundary.
Public Class MarshalByRefType
    Inherits MarshalByRefObject

    '  Call this method via a proxy.
    Public Sub SomeMethod(ByVal callingDomainName As String)

        ' Get this AppDomain's settings and display some of them.
        Dim ads As AppDomainSetup = AppDomain.CurrentDomain.SetupInformation
        Console.WriteLine("AppName={0}, AppBase={1}, ConfigFile={2}", _
            ads.ApplicationName, ads.ApplicationBase, ads.ConfigurationFile)

        ' Display the name of the calling AppDomain and the name 
        ' of the second domain.
        ' NOTE: The application's thread has transitioned between 
        ' AppDomains.
        Console.WriteLine("Calling from '{0}' to '{1}'.", _
            callingDomainName, Thread.GetDomain().FriendlyName)
    End Sub
End Class

'This code produces output similar to the following:
' 
' AppDomainX.exe
' AppDomainX, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
' AppName=, AppBase=C:\AppDomain\bin, ConfigFile=C:\AppDomain\bin\AppDomainX.exe.config
' Calling from 'AppDomainX.exe' to 'AD #2'.
' Failed call; this is expected.

Comentários

Os domínios de aplicativo, que são representados por AppDomain objetos, ajudam a fornecer isolamento, descarregamento e limites de segurança para a execução de código gerenciado.Application domains, which are represented by AppDomain objects, help provide isolation, unloading, and security boundaries for executing managed code.

  • Use domínios de aplicativo para isolar tarefas que podem trazer um processo.Use application domains to isolate tasks that might bring down a process. Se o estado do AppDomain que está executando uma tarefa se tornar instável, o AppDomain poderá ser descarregado sem afetar o processo.If the state of the AppDomain that's executing a task becomes unstable, the AppDomain can be unloaded without affecting the process. Isso é importante quando um processo deve ser executado por longos períodos sem reinicialização.This is important when a process must run for long periods without restarting. Você também pode usar domínios de aplicativo para isolar tarefas que não devem compartilhar dados.You can also use application domains to isolate tasks that should not share data.

  • Se um assembly for carregado no domínio de aplicativo padrão, ele não poderá ser descarregado da memória enquanto o processo estiver em execução.If an assembly is loaded into the default application domain, it cannot be unloaded from memory while the process is running. No entanto, se você abrir um segundo domínio de aplicativo para carregar e executar o assembly, o assembly será descarregado quando o domínio do aplicativo for descarregado.However, if you open a second application domain to load and execute the assembly, the assembly is unloaded when that application domain is unloaded. Use essa técnica para minimizar o conjunto de trabalho de processos de longa execução que usam ocasionalmente grandes DLLs.Use this technique to minimize the working set of long-running processes that occasionally use large DLLs.

Observação

No .NET Core, a implementação de AppDomain é limitada pelo design e não fornece limites de isolamento, descarregamento ou segurança.On .NET Core, the AppDomain implementation is limited by design and does not provide isolation, unloading, or security boundaries. Para o .NET Core, há exatamente um AppDomain.For .NET Core, there is exactly one AppDomain. Isolamento e descarregamento são fornecidos por meio de AssemblyLoadContext.Isolation and unloading are provided through AssemblyLoadContext. Limites de segurança devem ser fornecidos por limites de processo e técnicas de comunicação remota apropriadas.Security boundaries should be provided by process boundaries and appropriate remoting techniques.

Vários domínios de aplicativo podem ser executados em um único processo; no entanto, não há uma correlação um-para-um entre domínios de aplicativo e threads.Multiple application domains can run in a single process; however, there is not a one-to-one correlation between application domains and threads. Vários threads podem pertencer a um único domínio de aplicativo e, embora um determinado thread não seja confinado a um único domínio de aplicativo, em um determinado momento, um thread é executado em um único domínio de aplicativo.Several threads can belong to a single application domain, and while a given thread is not confined to a single application domain, at any given time, a thread executes in a single application domain.

Os domínios de aplicativo são criados usando o método CreateDomain.Application domains are created using the CreateDomain method. AppDomain instâncias são usadas para carregar e executar assemblies (Assembly).AppDomain instances are used to load and execute assemblies (Assembly). Quando um AppDomain não está mais em uso, ele pode ser descarregado.When an AppDomain is no longer in use, it can be unloaded.

A classe AppDomain implementa um conjunto de eventos que permite que os aplicativos respondam quando um assembly é carregado, quando um domínio de aplicativo será descarregado ou quando uma exceção sem tratamento for gerada.The AppDomain class implements a set of events that enable applications to respond when an assembly is loaded, when an application domain will be unloaded, or when an unhandled exception is thrown.

Para obter mais informações sobre como usar domínios de aplicativo, consulte domínios de aplicativo.For more information on using application domains, see Application Domains.

Essa classe implementa as interfaces MarshalByRefObject, _AppDomaine IEvidenceFactory.This class implements the MarshalByRefObject, _AppDomain, and IEvidenceFactory interfaces.

Você nunca deve criar um wrapper remoto para um objeto AppDomain.You should never create a remotable wrapper for an AppDomain object. Isso pode publicar uma referência remota para esse AppDomain, expondo métodos como CreateInstance para acesso remoto e destruindo efetivamente a segurança de acesso ao código para essa AppDomain.Doing so could publish a remote reference to that AppDomain, exposing methods such as CreateInstance to remote access and effectively destroying code access security for that AppDomain. Clientes mal-intencionados que se conectam ao AppDomain remoto podem obter acesso a qualquer recurso ao qual o AppDomain tem acesso.Malicious clients connecting to the remoted AppDomain could obtain access to any resource the AppDomain itself has access to. Não crie wrappers remotos para qualquer tipo que estenda MarshalByRefObject e que implemente métodos que possam ser usados por clientes mal-intencionados para ignorar o sistema de segurança.Do not create remotable wrappers for any type that extends MarshalByRefObject and that implements methods that could be used by malicious clients to bypass the security system.

Cuidado

O valor padrão para a propriedade AppDomainSetup.DisallowCodeDownload é false.The default value for the AppDomainSetup.DisallowCodeDownload property is false. Essa configuração não é segura para os serviços do.This setting is unsafe for services. Para impedir que os serviços baixem código parcialmente confiável, defina essa propriedade como true.To prevent services from downloading partially trusted code, set this property to true.

Propriedades

ActivationContext

Obtém o contexto de ativação para o domínio do aplicativo atual.Gets the activation context for the current application domain.

ApplicationIdentity

Obtém a identidade do aplicativo no domínio do aplicativo.Gets the identity of the application in the application domain.

ApplicationTrust

Obtém informações que descrevem as permissões concedidas a um aplicativo e se o aplicativo tem um nível de confiança que permite que ele seja executado.Gets information describing permissions granted to an application and whether the application has a trust level that allows it to run.

BaseDirectory

Obtém o diretório base usado pelo resolvedor de assembly para investigar assemblies.Gets the base directory that the assembly resolver uses to probe for assemblies.

CurrentDomain

Obtém o domínio de aplicativo atual do Thread atual.Gets the current application domain for the current Thread.

DomainManager

Obtém o Gerenciador de domínio que foi fornecido pelo host quando o domínio do aplicativo foi inicializado.Gets the domain manager that was provided by the host when the application domain was initialized.

DynamicDirectory

Obtém o diretório que usa o resolvedor de assembly para sondar assemblies criados dinamicamente.Gets the directory that the assembly resolver uses to probe for dynamically created assemblies.

Evidence

Obtém a Evidence associada a esse domínio de aplicativo.Gets the Evidence associated with this application domain.

FriendlyName

Obtém o nome amigável desse domínio do aplicativo.Gets the friendly name of this application domain.

Id

Obtém um inteiro que identifica exclusivamente o domínio de aplicativo dentro do processo.Gets an integer that uniquely identifies the application domain within the process.

IsFullyTrusted

Obtém um valor que indica se os assemblies carregados no domínio de aplicativo atual são executados com confiança total.Gets a value that indicates whether assemblies that are loaded into the current application domain execute with full trust.

IsHomogenous

Obtém um valor que indica se o domínio de aplicativo atual tem um conjunto de permissões concedido a todos os assemblies que são carregados no domínio do aplicativo.Gets a value that indicates whether the current application domain has a set of permissions that is granted to all assemblies that are loaded into the application domain.

MonitoringIsEnabled

Obtém ou define um valor que indica se o monitoramento de CPU e memória de domínios de aplicativo está habilitado para o processo atual.Gets or sets a value that indicates whether CPU and memory monitoring of application domains is enabled for the current process. Depois que o monitoramento é habilitado para um processo, ele não pode ser desabilitado.Once monitoring is enabled for a process, it cannot be disabled.

MonitoringSurvivedMemorySize

Obtém o número de bytes que sobreviveram à última coleta e que são conhecidos por serem referenciados pelo domínio do aplicativo atual.Gets the number of bytes that survived the last collection and that are known to be referenced by the current application domain.

MonitoringSurvivedProcessMemorySize

Obtém o total de bytes que sobreviveram da última coleção para todos os domínios de aplicativo no processo.Gets the total bytes that survived from the last collection for all application domains in the process.

MonitoringTotalAllocatedMemorySize

Obtém o tamanho total, em bytes, de todas as alocações de memória que foram feitas pelo domínio do aplicativo desde que ele foi criado, sem subtrair a memória que foi coletada.Gets the total size, in bytes, of all memory allocations that have been made by the application domain since it was created, without subtracting memory that has been collected.

MonitoringTotalProcessorTime

Obtém o tempo total do processador usado por todos os threads durante a execução no domínio do aplicativo atual, desde o início do processo.Gets the total processor time that has been used by all threads while executing in the current application domain, since the process started.

PermissionSet

Obtém o conjunto de permissões de um domínio de aplicativo em área restrita.Gets the permission set of a sandboxed application domain.

RelativeSearchPath

Obtém o caminho no diretório base em que o resolvedor do assembly deve investigar assemblies particulares.Gets the path under the base directory where the assembly resolver should probe for private assemblies.

SetupInformation

Obtém as informações de configuração do domínio do aplicativo para essa instância.Gets the application domain configuration information for this instance.

ShadowCopyFiles

Obtém uma indicação se o domínio do aplicativo é configurado para arquivos de cópia de sombra.Gets an indication whether the application domain is configured to shadow copy files.

Métodos

AppendPrivatePath(String)

Anexa o nome do diretório especificado à lista de caminhos privado.Appends the specified directory name to the private path list.

ApplyPolicy(String)

Retorna o nome de exibição do assembly depois de a política ser aplicada.Returns the assembly display name after policy has been applied.

ClearPrivatePath()

Redefine o caminho que especifica o local dos assemblies privados para a cadeia de caracteres vazia ("").Resets the path that specifies the location of private assemblies to the empty string ("").

ClearShadowCopyPath()

Redefine a lista de diretórios que contêm assemblies de cópia de sombra para a cadeia de caracteres vazia ("").Resets the list of directories containing shadow copied assemblies to the empty string ("").

CreateComInstanceFrom(String, String)

Cria uma nova instância de um tipo COM especificado.Creates a new instance of a specified COM type. Parâmetros especificam o nome de um arquivo que contém um assembly com o tipo e o nome do tipo.Parameters specify the name of a file that contains an assembly containing the type and the name of the type.

CreateComInstanceFrom(String, String, Byte[], AssemblyHashAlgorithm)

Cria uma nova instância de um tipo COM especificado.Creates a new instance of a specified COM type. Parâmetros especificam o nome de um arquivo que contém um assembly com o tipo e o nome do tipo.Parameters specify the name of a file that contains an assembly containing the type and the name of the type.

CreateDomain(String)

Cria um novo domínio de aplicativo com o nome especificado.Creates a new application domain with the specified name.

CreateDomain(String, Evidence)

Cria um novo domínio do aplicativo com o nome especificado usando a evidência fornecida.Creates a new application domain with the given name using the supplied evidence.

CreateDomain(String, Evidence, AppDomainSetup)

Cria um novo domínio do aplicativo usando o nome, evidência e informações de instalação do domínio do aplicativo especificados.Creates a new application domain using the specified name, evidence, and application domain setup information.

CreateDomain(String, Evidence, AppDomainSetup, PermissionSet, StrongName[])

Cria um novo domínio do aplicativo usando o nome, evidência, informações de configuração do domínio do aplicativo, conjunto de permissões padrão e a matriz de assemblies totalmente confiáveis especificados.Creates a new application domain using the specified name, evidence, application domain setup information, default permission set, and array of fully trusted assemblies.

CreateDomain(String, Evidence, String, String, Boolean)

Cria um novo domínio de aplicativo com o nome especificado, usando a evidência, o caminho base do aplicativo, o caminho de pesquisa relativo e um parâmetro que especifica se uma cópia de sombra de um assembly deve ser carregada no domínio de aplicativo.Creates a new application domain with the given name, using evidence, application base path, relative search path, and a parameter that specifies whether a shadow copy of an assembly is to be loaded into the application domain.

CreateDomain(String, Evidence, String, String, Boolean, AppDomainInitializer, String[])

Cria um novo domínio de aplicativo com o nome especificado, usando a evidência, o caminho base do aplicativo, o caminho de pesquisa relativo e um parâmetro que especifica se uma cópia de sombra de um assembly deve ser carregada no domínio de aplicativo.Creates a new application domain with the given name, using evidence, application base path, relative search path, and a parameter that specifies whether a shadow copy of an assembly is to be loaded into the application domain. Especifica um método de retorno de chamada invocado quando o domínio de aplicativo é inicializado e uma matriz de argumentos de cadeia de caracteres para passar o método de retorno de chamada.Specifies a callback method that is invoked when the application domain is initialized, and an array of string arguments to pass the callback method.

CreateInstance(String, String)

Cria uma nova instância do tipo especificado definido no assembly especificado.Creates a new instance of the specified type defined in the specified assembly.

CreateInstance(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[])

Cria uma nova instância do tipo especificado definido no assembly especificado.Creates a new instance of the specified type defined in the specified assembly. Os parâmetros especificam um associador, sinalizadores de associação, argumentos de construtor, informações específicas da cultura usadas para interpretar argumentos e atributos de ativação opcionais.Parameters specify a binder, binding flags, constructor arguments, culture-specific information used to interpret arguments, and optional activation attributes.

CreateInstance(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[], Evidence)

Cria uma nova instância do tipo especificado definido no assembly especificado.Creates a new instance of the specified type defined in the specified assembly. Os parâmetros especificam um associador, sinalizadores de associação, argumentos de construtor, informações específicas da cultura usadas para interpretar argumentos, atributos de ativação e autorização para criar o tipo.Parameters specify a binder, binding flags, constructor arguments, culture-specific information used to interpret arguments, activation attributes, and authorization to create the type.

CreateInstance(String, String, Object[])

Cria uma nova instância do tipo especificado definido no assembly especificado.Creates a new instance of the specified type defined in the specified assembly. Um parâmetro especifica uma matriz de atributos de ativação.A parameter specifies an array of activation attributes.

CreateInstanceAndUnwrap(String, String)

Cria uma nova instância do tipo especificado.Creates a new instance of the specified type. Parâmetros especificam o assembly no qual o tipo é definido e o nome do tipo.Parameters specify the assembly where the type is defined, and the name of the type.

CreateInstanceAndUnwrap(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[])

Cria uma nova instância do tipo indicado definido no assembly especificado, determinando se a diferenciação entre maiúsculas e minúsculas é ignorada no nome do tipo; os atributos de associação e o associador que são usados para selecionar o tipo a ser criado; os argumentos do construtor; a cultura; e os atributos de ativação.Creates a new instance of the specified type defined in the specified assembly, specifying whether the case of the type name is ignored; the binding attributes and the binder that are used to select the type to be created; the arguments of the constructor; the culture; and the activation attributes.

CreateInstanceAndUnwrap(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[], Evidence)

Cria uma nova instância do tipo especificado.Creates a new instance of the specified type. Os parâmetros especificam o nome do tipo e como ele é encontrado e criado.Parameters specify the name of the type, and how it is found and created.

CreateInstanceAndUnwrap(String, String, Object[])

Cria uma nova instância do tipo especificado.Creates a new instance of the specified type. Parâmetros especificam o assembly no qual o tipo, o nome do tipo e uma matriz de atributos de ativação são definidos.Parameters specify the assembly where the type is defined, the name of the type, and an array of activation attributes.

CreateInstanceFrom(String, String)

Cria uma nova instância do tipo especificado definido no arquivo de assembly especificado.Creates a new instance of the specified type defined in the specified assembly file.

CreateInstanceFrom(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[])

Cria uma nova instância do tipo especificado definido no arquivo de assembly especificado.Creates a new instance of the specified type defined in the specified assembly file.

CreateInstanceFrom(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[], Evidence)

Cria uma nova instância do tipo especificado definido no arquivo de assembly especificado.Creates a new instance of the specified type defined in the specified assembly file.

CreateInstanceFrom(String, String, Object[])

Cria uma nova instância do tipo especificado definido no arquivo de assembly especificado.Creates a new instance of the specified type defined in the specified assembly file.

CreateInstanceFromAndUnwrap(String, String)

Cria uma nova instância do tipo especificado definido no arquivo de assembly especificado.Creates a new instance of the specified type defined in the specified assembly file.

CreateInstanceFromAndUnwrap(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[])

Cria uma nova instância do tipo indicado definido no arquivo do assembly especificado, determinando se a diferenciação entre maiúsculas e minúsculas é ignorada no nome do tipo; os atributos de associação e o associador que são usados para selecionar o tipo a ser criado; os argumentos do construtor; a cultura; e os atributos de ativação.Creates a new instance of the specified type defined in the specified assembly file, specifying whether the case of the type name is ignored; the binding attributes and the binder that are used to select the type to be created; the arguments of the constructor; the culture; and the activation attributes.

CreateInstanceFromAndUnwrap(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[], Evidence)

Cria uma nova instância do tipo especificado definido no arquivo de assembly especificado.Creates a new instance of the specified type defined in the specified assembly file.

CreateInstanceFromAndUnwrap(String, String, Object[])

Cria uma nova instância do tipo especificado definido no arquivo de assembly especificado.Creates a new instance of the specified type defined in the specified assembly file.

CreateObjRef(Type)

Cria um objeto que contém todas as informações relevantes necessárias para gerar um proxy usado para se comunicar com um objeto remoto.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Herdado de MarshalByRefObject)
DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess)

Define um assembly dinâmico com o nome e o modo de acesso especificados.Defines a dynamic assembly with the specified name and access mode.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, Evidence)

Define um assembly dinâmico usando o nome, o modo de acesso e a evidência especificados.Defines a dynamic assembly using the specified name, access mode, and evidence.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, Evidence, PermissionSet, PermissionSet, PermissionSet)

Define um assembly dinâmico usando o nome, o modo de acesso, a evidência e as solicitações de permissão especificados.Defines a dynamic assembly using the specified name, access mode, evidence, and permission requests.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, IEnumerable<CustomAttributeBuilder>)

Define um assembly dinâmico com o nome, o modo de acesso e os atributos personalizados especificados.Defines a dynamic assembly with the specified name, access mode, and custom attributes.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, IEnumerable<CustomAttributeBuilder>, SecurityContextSource)

Define um assembly dinâmico com o nome, o modo de acesso e os atributos personalizados especificados e usando a origem especificada para o seu contexto de segurança.Defines a dynamic assembly with the specified name, access mode, and custom attributes, and using the specified source for its security context.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, PermissionSet, PermissionSet, PermissionSet)

Define um assembly dinâmico usando o nome, o modo de acesso e as solicitações de permissão especificados.Defines a dynamic assembly using the specified name, access mode, and permission requests.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String)

Define um assembly dinâmico usando o nome, o modo de acesso e o diretório de armazenamento especificados.Defines a dynamic assembly using the specified name, access mode, and storage directory.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Boolean, IEnumerable<CustomAttributeBuilder>)

Define um assembly dinâmico usando o nome, o modo de acesso, o diretório de armazenamento e a opção de sincronização especificados.Defines a dynamic assembly using the specified name, access mode, storage directory, and synchronization option.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Evidence)

Define um assembly dinâmico usando o nome, o modo de acesso, o diretório de armazenamento e a evidência especificados.Defines a dynamic assembly using the specified name, access mode, storage directory, and evidence.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet)

Define um assembly dinâmico usando o nome, o modo de acesso, o diretório de armazenamento, a evidência e as solicitações de permissão especificados.Defines a dynamic assembly using the specified name, access mode, storage directory, evidence, and permission requests.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet, Boolean)

Define um assembly dinâmico usando o nome, o modo de acesso, o diretório de armazenamento, a evidência, as solicitações de permissão e a opção de sincronização especificados.Defines a dynamic assembly using the specified name, access mode, storage directory, evidence, permission requests, and synchronization option.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet, Boolean, IEnumerable<CustomAttributeBuilder>)

Define um assembly dinâmico com o nome, o modo de acesso, o diretório de armazenamento, a evidência, as solicitações de permissão, a opção de sincronização e os atributos personalizados especificados.Defines a dynamic assembly with the specified name, access mode, storage directory, evidence, permission requests, synchronization option, and custom attributes.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, PermissionSet, PermissionSet, PermissionSet)

Define um assembly dinâmico usando o nome, o modo de acesso, o diretório de armazenamento e as solicitações de permissão especificados.Defines a dynamic assembly using the specified name, access mode, storage directory, and permission requests.

DoCallBack(CrossAppDomainDelegate)

Executa o código em outro domínio de aplicativo que é identificado pelo delegado especificado.Executes the code in another application domain that is identified by the specified delegate.

Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

(Herdado de Object)
ExecuteAssembly(String)

Executa o assembly contido no arquivo especificado.Executes the assembly contained in the specified file.

ExecuteAssembly(String, Evidence)

Executa o assembly contido no arquivo especificado usando a evidência especificada.Executes the assembly contained in the specified file, using the specified evidence.

ExecuteAssembly(String, Evidence, String[])

Executa o assembly contido no arquivo especificado, usando a evidência e os argumentos especificados.Executes the assembly contained in the specified file, using the specified evidence and arguments.

ExecuteAssembly(String, Evidence, String[], Byte[], AssemblyHashAlgorithm)

Executa o assembly contido no arquivo especificado usando a evidência, os argumentos, o valor de hash e o algoritmo de hash especificados.Executes the assembly contained in the specified file, using the specified evidence, arguments, hash value, and hash algorithm.

ExecuteAssembly(String, String[])

Executa o assembly contido no arquivo especificado usando argumentos especificados.Executes the assembly contained in the specified file, using the specified arguments.

ExecuteAssembly(String, String[], Byte[], AssemblyHashAlgorithm)

Executa o assembly contido no arquivo especificado usando os argumentos, o valor de hash e o algoritmo de hash especificados.Executes the assembly contained in the specified file, using the specified arguments, hash value, and hash algorithm.

ExecuteAssemblyByName(AssemblyName, Evidence, String[])

Executa o assembly dado um AssemblyName usando a evidência e os argumentos especificados.Executes the assembly given an AssemblyName, using the specified evidence and arguments.

ExecuteAssemblyByName(AssemblyName, String[])

Executa o assembly dado um AssemblyName usando os argumentos especificados.Executes the assembly given an AssemblyName, using the specified arguments.

ExecuteAssemblyByName(String)

Executa um assembly dado seu nome de exibição.Executes an assembly given its display name.

ExecuteAssemblyByName(String, Evidence)

Executa um assembly dado seu nome de exibição usando a evidência especificada.Executes an assembly given its display name, using the specified evidence.

ExecuteAssemblyByName(String, Evidence, String[])

Executa o assembly dado seu nome de exibição usando a evidência e os argumentos especificados.Executes the assembly given its display name, using the specified evidence and arguments.

ExecuteAssemblyByName(String, String[])

Executa o assembly dado seu nome de exibição usando os argumentos especificados.Executes the assembly given its display name, using the specified arguments.

GetAssemblies()

Obtém os assemblies que foram carregados no contexto de execução desse domínio de aplicativo.Gets the assemblies that have been loaded into the execution context of this application domain.

GetCurrentThreadId()

Obtém o identificador atual de thread.Gets the current thread identifier.

GetData(String)

Obtém o valor armazenado no domínio atual do aplicativo para o nome especificado.Gets the value stored in the current application domain for the specified name.

GetHashCode()

Serve como a função de hash padrão.Serves as the default hash function.

(Herdado de Object)
GetLifetimeService()

Recupera o objeto de serviço de tempo de vida atual que controla a política de ciclo de vida para esta instância.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Herdado de MarshalByRefObject)
GetType()

Obtém o tipo da instância atual.Gets the type of the current instance.

InitializeLifetimeService()

Proporciona ao AppDomain um tempo de vida infinito impedindo que uma concessão seja criada.Gives the AppDomain an infinite lifetime by preventing a lease from being created.

IsCompatibilitySwitchSet(String)

Obtém um valor booliano anulável que indica se alguma a de compatibilidade está definida e, caso esteja, se a opção de compatibilidade especificada está definida.Gets a nullable Boolean value that indicates whether any compatibility switches are set, and if so, whether the specified compatibility switch is set.

IsDefaultAppDomain()

Retorna um valor que indica se o domínio de aplicativo é o domínio de aplicativo padrão para o processo.Returns a value that indicates whether the application domain is the default application domain for the process.

IsFinalizingForUnload()

Indica se esse domínio de aplicativo está descarregando e os objetos que ele contém estão sendo finalizados pelo Common Language Runtime.Indicates whether this application domain is unloading, and the objects it contains are being finalized by the common language runtime.

Load(AssemblyName)

Carrega um Assembly dado seu AssemblyName.Loads an Assembly given its AssemblyName.

Load(AssemblyName, Evidence)

Carrega um Assembly dado seu AssemblyName.Loads an Assembly given its AssemblyName.

Load(Byte[])

Carrega o Assembly com uma imagem baseada em formato COFF, contendo um Assembly emitido.Loads the Assembly with a common object file format (COFF) based image containing an emitted Assembly.

Load(Byte[], Byte[])

Carrega o Assembly com uma imagem baseada em formato COFF, contendo um Assembly emitido.Loads the Assembly with a common object file format (COFF) based image containing an emitted Assembly. Os bytes brutos que representam os símbolos para o Assembly também são carregados.The raw bytes representing the symbols for the Assembly are also loaded.

Load(Byte[], Byte[], Evidence)

Carrega o Assembly com uma imagem baseada em formato COFF, contendo um Assembly emitido.Loads the Assembly with a common object file format (COFF) based image containing an emitted Assembly. Os bytes brutos que representam os símbolos para o Assembly também são carregados.The raw bytes representing the symbols for the Assembly are also loaded.

Load(String)

Carrega um Assembly de acordo com seu nome de exibição.Loads an Assembly given its display name.

Load(String, Evidence)

Carrega um Assembly de acordo com seu nome de exibição.Loads an Assembly given its display name.

MemberwiseClone()

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

(Herdado de Object)
MemberwiseClone(Boolean)

Cria uma cópia superficial do objeto MarshalByRefObject atual.Creates a shallow copy of the current MarshalByRefObject object.

(Herdado de MarshalByRefObject)
ReflectionOnlyGetAssemblies()

Retorna os assemblies que foram carregados no contexto somente de reflexão do domínio do aplicativo.Returns the assemblies that have been loaded into the reflection-only context of the application domain.

SetAppDomainPolicy(PolicyLevel)

Estabelece o nível de política de segurança para esse domínio de aplicativo.Establishes the security policy level for this application domain.

SetCachePath(String)

Estabelece o caminho de diretório especificado como o local em que é feita cópia de sombra dos assemblies.Establishes the specified directory path as the location where assemblies are shadow copied.

SetData(String, Object)

Atribui o valor especificado para a propriedade de domínio do aplicativo especificado.Assigns the specified value to the specified application domain property.

SetData(String, Object, IPermission)

Atribui o valor especificado à propriedade de domínio de aplicativo especificada, com uma permissão especificada para exigir do chamador quando a propriedade for recuperada.Assigns the specified value to the specified application domain property, with a specified permission to demand of the caller when the property is retrieved.

SetDynamicBase(String)

Estabelece o caminho de diretório especificado como o diretório base para subdiretórios em que os arquivos gerados dinamicamente são armazenados e acessados.Establishes the specified directory path as the base directory for subdirectories where dynamically generated files are stored and accessed.

SetPrincipalPolicy(PrincipalPolicy)

Especifica como objetos de identidade e de entidade de segurança devem ser anexados a um thread se a thread tenta se associar a uma entidade de segurança durante a execução nesse domínio do aplicativo.Specifies how principal and identity objects should be attached to a thread if the thread attempts to bind to a principal while executing in this application domain.

SetShadowCopyFiles()

Ativa a cópia de sombra.Turns on shadow copying.

SetShadowCopyPath(String)

Estabelece o caminho de diretório especificado como o lugar para o qual é feita cópia de sombra dos assemblies.Establishes the specified directory path as the location of assemblies to be shadow copied.

SetThreadPrincipal(IPrincipal)

Define o objeto de entidade de segurança padrão a ser anexado aos threads se eles tentam se associar a uma entidade de segurança durante a execução nesse domínio de aplicativo.Sets the default principal object to be attached to threads if they attempt to bind to a principal while executing in this application domain.

ToString()

Obtém uma representação de cadeia de caracteres que inclui o nome amigável do domínio do aplicativo e as políticas de contexto.Obtains a string representation that includes the friendly name of the application domain and any context policies.

Unload(AppDomain)

Descarrega o domínio de aplicativo especificado.Unloads the specified application domain.

Eventos

AssemblyLoad

Ocorre quando um assembly é carregado.Occurs when an assembly is loaded.

AssemblyResolve

Ocorre quando a resolução de um assembly falha.Occurs when the resolution of an assembly fails.

DomainUnload

Ocorre quando um AppDomain está prestes a ser descarregado.Occurs when an AppDomain is about to be unloaded.

FirstChanceException

Ocorre quando uma exceção é lançada no código gerenciado, antes que o runtime procure na pilha de chamadas um manipulador de exceção no domínio do aplicativo.Occurs when an exception is thrown in managed code, before the runtime searches the call stack for an exception handler in the application domain.

ProcessExit

Ocorre quando o processo pai do domínio de aplicativo padrão é encerrado.Occurs when the default application domain's parent process exits.

ReflectionOnlyAssemblyResolve

Ocorre quando a resolução de um assembly falha no contexto somente para reflexão.Occurs when the resolution of an assembly fails in the reflection-only context.

ResourceResolve

Ocorre quando a resolução de um recurso falha devido ao recurso não ser um recurso vinculado ou inserido válido no assembly.Occurs when the resolution of a resource fails because the resource is not a valid linked or embedded resource in the assembly.

TypeResolve

Ocorre quando a resolução de um tipo falha.Occurs when the resolution of a type fails.

UnhandledException

Ocorre quando uma exceção não é capturada.Occurs when an exception is not caught.

Implantações explícitas de interface

_AppDomain.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Mapeia um conjunto de nomes para um conjunto correspondente de identificadores de expedição.Maps a set of names to a corresponding set of dispatch identifiers.

_AppDomain.GetTypeInfo(UInt32, UInt32, IntPtr)

Recupera as informações do tipo de um objeto, que podem ser usadas para obter informações de tipo para uma interface.Retrieves the type information for an object, which can then be used to get the type information for an interface.

_AppDomain.GetTypeInfoCount(UInt32)

Retorna o número de interfaces de informações do tipo que um objeto fornece (0 ou 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

_AppDomain.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fornece acesso a propriedades e métodos expostos por um objeto.Provides access to properties and methods exposed by an object.

Aplica-se a

Veja também