Exportar (0) Imprimir
Expandir Tudo
Este artigo foi traduzido por máquina. Coloque o ponteiro do mouse sobre as frases do artigo para ver o texto original. Mais informações.
Tradução
Original

Classe AppDomain

Representa um domínio de aplicativo, que é um ambiente isolado onde os aplicativos são executados. Esta classe não pode ser herdada.

Namespace:  System
Assembly:  mscorlib (em mscorlib.dll)

[ClassInterfaceAttribute(ClassInterfaceType.None)]
[ComVisibleAttribute(true)]
public sealed class AppDomain : MarshalByRefObject, 
	_AppDomain, IEvidenceFactory

Domínios de aplicativo, que são representados por AppDomain objetos, ajudar a fornecer isolamento, o descarregamento e limites de segurança para a execução de código gerenciado.

  • Uso aplicativo domínios para Isole as tarefas que podem derrubar um processo.Se o estado do AppDomain que está executando uma tarefa torna-se instável, o AppDomain pode ser descarregado sem que afete o processo.Isso é importante quando um processo deve executar por longos períodos sem reiniciar.Você também pode usar domínios de aplicativos para isolar as tarefas que não devem compartilhar dados.

  • Se um assembly foi carregado para um domínio de aplicação padrão, este não pode ser descarregado da memória enquanto o processo estiver em execução.No entanto, se você em em aberto um segundo domínio do aplicativo para carregar e executar o assembly, o assembly é descarregado quando esse domínio do aplicativo é descarregado.Use essa técnica para minimizar o conjunto de trabalho de processos de longa que ocasionalmente usar DLLs grandes.

Múltiplos domínios de aplicação podem ser executados em um único processo; no entanto, não há uma correlação de um para um entre dominios de aplicação e threads.Vários segmentos podem pertencer a um domínio único aplicativo e enquanto um determinado segmento não está restrito a um domínio, o único aplicativo, a qualquer momento, um segmento executa em um domínio único aplicativo.

Domínios de aplicativo são criados usando o CreateDomain método. AppDomain instâncias são usadas para carregar e executar () assembliesAssembly). Quando um AppDomain é não mais em uso, ele pode ser descarregado.

The AppDomain classe implementa um conjunto de eventos que permitem que os aplicativos responder quando um assembly é carregado, quando um domínio do aplicativo será descarregado, ou quando uma exceção sem tratamento será lançada.

Para obter mais informações sobre como usar domínios de aplicativo, consulte Domínios de aplicativo.

Essa classe implementa a MarshalByRefObject, _AppDomain, e IEvidenceFactory interfaces.

Você nunca deve criar um invólucro remoto para um AppDomain objeto. Ao fazer isso, foi possível publicar uma referência remota que AppDomain, expor métodos, sistema autônomo CreateInstance para acesso remoto e destruir com eficácia a segurança de acesso do código para que AppDomain. Mal-intencionado clientes conectando-se para o remoto AppDomain foi possível obter acesso a qualquer recurso do AppDomain Se tem acesso. Não crie remoto invólucros para qualquer tipo que estende MarshalByRefObject e que implementa os métodos que podem ser usados por clientes mal intencionados para ignorar o sistema de segurança.

Observação de cuidadoCuidado:

O valor padrão para o AppDomainSetup.DisallowCodeDownload propriedade é false. Essa configuração não é seguro para serviços.Para impedir que serviços Baixando código parcialmente confiável, defina esta propriedade como true.

Windows Mobile for Pocket PC, Windows Mobile for Smartphone, Windows CE Observação Zoom, Para Cima e Ampliar:

Não há suporte para carregar assemblies em uma área de código neutro de domínio para uso por vários domínios do aplicativo.

Este exemplo mostra como criar um novo AppDomain, criar uma instância de um tipo em que novos AppDomaine se comunicar com objeto desse tipo. Além disso, este exemplo mostra como descarregar o AppDomain fazendo com que o objeto para o lixo coletado.

using System;
using System.Reflection;
using System.Threading;

class Module1
{
    publicstaticvoid 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 = 
            System.Environment.CurrentDirectory;
        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.publicclass MarshalByRefType : MarshalByRefObject
{
    //  Call this method via a proxy.publicvoid 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.
 */

Quaisquer membros static (Shared no Visual Basic) públicos deste tipo são thread-safe. Não há garantia de que qualquer membro de instância seja thread-safe.

Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile for Smartphone, Windows Mobile for Pocket PC, Xbox 360

o.NET Framework e.NET Compact Framework não oferecem suporte a todas as versões de cada plataforma. Para obter uma lista de versões suportadas, consulte Requisitos de sistema do .NET framework.

.NET Framework

Compatível com: 3.5, 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Compatível com: 3.5, 2.0, 1.0

XNA Framework

Compatível com: , 1.0

Contribuições da comunidade

ADICIONAR
A Microsoft está realizando uma pesquisa online para saber sua opinião sobre o site do MSDN. Se você optar por participar, a pesquisa online lhe será apresentada quando você sair do site do MSDN.

Deseja participar?
Mostrar:
© 2014 Microsoft