AppDomain Třída

Definice

Představuje doménu aplikace, což je izolované prostředí, ve kterém se aplikace spouštějí.Represents an application domain, which is an isolated environment where applications execute. Tuto třídu nelze zdědit.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
Dědičnost
Atributy
Implementuje

Příklady

Tento příklad ukazuje, jak vytvořit novou AppDomain, vytvořit instanci typu v tomto novém AppDomaina komunikovat s objektem typu.This example shows how to create a new AppDomain, instantiate a type in that new AppDomain, and communicate with that type's object. Kromě toho tento příklad ukazuje, jak uvolnit AppDomain způsobující uvolnění paměti objektu.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.

Poznámky

Domény aplikace, které jsou reprezentovány AppDomain objekty, vám pomůžou zajistit izolaci, vykládku a hranice zabezpečení pro provádění spravovaného kódu.Application domains, which are represented by AppDomain objects, help provide isolation, unloading, and security boundaries for executing managed code.

  • Použijte aplikační domény k izolaci úloh, které by mohly vyvolat proces.Use application domains to isolate tasks that might bring down a process. Pokud stav AppDomain, který spouští úlohu, se nestabilní, AppDomain lze uvolnit, aniž by to ovlivnilo proces.If the state of the AppDomain that's executing a task becomes unstable, the AppDomain can be unloaded without affecting the process. To je důležité v případě, že proces musí být spuštěn po dlouhou dobu bez restartování.This is important when a process must run for long periods without restarting. Domény aplikace můžete použít také k izolaci úloh, které by neměly sdílet data.You can also use application domains to isolate tasks that should not share data.

  • Pokud je sestavení načteno do výchozí domény aplikace, nelze je uvolnit z paměti, když je proces spuštěn.If an assembly is loaded into the default application domain, it cannot be unloaded from memory while the process is running. Pokud však otevřete druhou doménu aplikace pro načtení a spuštění sestavení, je sestavení uvolněno při uvolnění domény aplikace.However, if you open a second application domain to load and execute the assembly, the assembly is unloaded when that application domain is unloaded. Tuto techniku použijte k minimalizaci pracovní sady dlouhotrvajících procesů, které občas využívají velké knihovny DLL.Use this technique to minimize the working set of long-running processes that occasionally use large DLLs.

Poznámka

V .NET Core je implementace AppDomain omezená návrhem a neposkytuje izolaci, vykládku nebo hranice zabezpečení.On .NET Core, the AppDomain implementation is limited by design and does not provide isolation, unloading, or security boundaries. Pro .NET Core existuje přesně jeden AppDomain.For .NET Core, there is exactly one AppDomain. Izolaci a uvolnění jsou k dispozici prostřednictvím AssemblyLoadContext.Isolation and unloading are provided through AssemblyLoadContext. Hranice zabezpečení by měly být poskytovány hranicemi procesů a vhodnými techniky vzdálené komunikace.Security boundaries should be provided by process boundaries and appropriate remoting techniques.

V jednom procesu lze spustit více domén aplikace. Neexistuje však korelace 1:1 mezi doménami aplikace a vlákny.Multiple application domains can run in a single process; however, there is not a one-to-one correlation between application domains and threads. Několik vláken může patřit do jedné aplikační domény a zatímco dané vlákno není omezeno na jednu doménu aplikace v daném čase, podproces se spustí v jedné doméně aplikace.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.

Domény aplikace jsou vytvořeny pomocí metody CreateDomain.Application domains are created using the CreateDomain method. instance AppDomain slouží k načítání a spouštění sestavení (Assembly).AppDomain instances are used to load and execute assemblies (Assembly). Pokud se AppDomain již nepoužívá, může být uvolněna.When an AppDomain is no longer in use, it can be unloaded.

Třída AppDomain implementuje sadu událostí, které umožní aplikacím reagovat při načtení sestavení, když dojde k uvolnění domény aplikace, nebo když je vyvolána neošetřená výjimka.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.

Další informace o používání domén aplikací najdete v tématu aplikační domény.For more information on using application domains, see Application Domains.

Tato třída implementuje rozhraní MarshalByRefObject, _AppDomaina IEvidenceFactory.This class implements the MarshalByRefObject, _AppDomain, and IEvidenceFactory interfaces.

Nikdy byste neměli vytvořit nepodporovanou obálku pro objekt AppDomain.You should never create a remotable wrapper for an AppDomain object. Tím by bylo možné publikovat vzdálený odkaz na tento AppDomaina vystavit metody, jako je například CreateInstance pro vzdálený přístup a efektivně zničit zabezpečení přístupu kódu pro tento 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. Zlomyslní klienti, kteří se připojují ke vzdáleným AppDomain by mohli získat přístup k jakémukoli prostředku, ke kterému mají přístup AppDomain sám.Malicious clients connecting to the remoted AppDomain could obtain access to any resource the AppDomain itself has access to. Nevytvářejte vzdáleně odbalení pro jakýkoli typ, který rozšiřuje MarshalByRefObject a implementuje metody, které by mohly být používány zlomyslnými klienty k obejít systému zabezpečení.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.

Upozornění

Výchozí hodnota vlastnosti AppDomainSetup.DisallowCodeDownload je false.The default value for the AppDomainSetup.DisallowCodeDownload property is false. Toto nastavení je pro služby nebezpečné.This setting is unsafe for services. Chcete-li zabránit službám stahovat částečně důvěryhodný kód, nastavte tuto vlastnost na true.To prevent services from downloading partially trusted code, set this property to true.

Vlastnosti

ActivationContext

Získá aktivační kontext pro aktuální doménu aplikace.Gets the activation context for the current application domain.

ApplicationIdentity

Získá identitu aplikace v doméně aplikace.Gets the identity of the application in the application domain.

ApplicationTrust

Získává informace popisující oprávnění udělená aplikaci a zda má aplikace úroveň důvěryhodnosti, která umožňuje její spuštění.Gets information describing permissions granted to an application and whether the application has a trust level that allows it to run.

BaseDirectory

Získá základní adresář, který překladač sestavení používá k testování sestavení.Gets the base directory that the assembly resolver uses to probe for assemblies.

CurrentDomain

Získá aktuální doménu aplikace pro aktuální Thread.Gets the current application domain for the current Thread.

DomainManager

Získá správce domény, který poskytl hostitel při inicializaci domény aplikace.Gets the domain manager that was provided by the host when the application domain was initialized.

DynamicDirectory

Získá adresář, který překladač sestavení používá k testování pro dynamicky vytvořená sestavení.Gets the directory that the assembly resolver uses to probe for dynamically created assemblies.

Evidence

Získá Evidence přidružené k této doméně aplikace.Gets the Evidence associated with this application domain.

FriendlyName

Získá popisný název této domény aplikace.Gets the friendly name of this application domain.

Id

Získá celé číslo, které jedinečně identifikuje doménu aplikace v rámci procesu.Gets an integer that uniquely identifies the application domain within the process.

IsFullyTrusted

Získá hodnotu, která označuje, zda jsou sestavení, která jsou načtena do aktuální domény aplikace, spuštěna s úplným vztahem důvěryhodnosti.Gets a value that indicates whether assemblies that are loaded into the current application domain execute with full trust.

IsHomogenous

Získá hodnotu, která označuje, zda má aktuální doména aplikace sadu oprávnění udělených pro všechna sestavení, která jsou načtena do domény aplikace.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

Získává nebo nastavuje hodnotu, která indikuje, jestli je pro aktuální proces povolené monitorování CPU a paměti pro domény aplikace.Gets or sets a value that indicates whether CPU and memory monitoring of application domains is enabled for the current process. Když je monitorování povolené pro určitý proces, nedá se zakázat.Once monitoring is enabled for a process, it cannot be disabled.

MonitoringSurvivedMemorySize

Vrátí počet bajtů, které byly zachovány v poslední kolekci a jsou známy, na které se odkazuje aktuální doména aplikace.Gets the number of bytes that survived the last collection and that are known to be referenced by the current application domain.

MonitoringSurvivedProcessMemorySize

Získá celkový počet bajtů, které byly zachovány z poslední kolekce pro všechny domény aplikace v procesu.Gets the total bytes that survived from the last collection for all application domains in the process.

MonitoringTotalAllocatedMemorySize

Získá celkovou velikost přidělení paměti (v bajtech), která byla vytvořena aplikační doménou od jejího vytvoření, bez odčítání paměti, která byla shromážděna.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

Získá celkový čas procesoru, který byl použit všemi vlákny při spuštění v aktuální doméně aplikace, od spuštění procesu.Gets the total processor time that has been used by all threads while executing in the current application domain, since the process started.

PermissionSet

Získá sadu oprávnění pro doménu aplikace v izolovaném prostoru.Gets the permission set of a sandboxed application domain.

RelativeSearchPath

Získá cestu pod základním adresářem, kde by měl překladač sestavení PROBE test pro soukromá sestavení.Gets the path under the base directory where the assembly resolver should probe for private assemblies.

SetupInformation

Získá informace o konfiguraci domény aplikace pro tuto instanci.Gets the application domain configuration information for this instance.

ShadowCopyFiles

Získá informaci, jestli je doména aplikace nakonfigurovaná na soubory stínových kopií.Gets an indication whether the application domain is configured to shadow copy files.

Metody

AppendPrivatePath(String)

Připojí zadaný název adresáře k seznamu privátních cest.Appends the specified directory name to the private path list.

ApplyPolicy(String)

Po použití zásady vrátí zobrazovaný název sestavení.Returns the assembly display name after policy has been applied.

ClearPrivatePath()

Obnoví cestu, která určuje umístění privátních sestavení do prázdného řetězce ("").Resets the path that specifies the location of private assemblies to the empty string ("").

ClearShadowCopyPath()

Obnoví seznam adresářů obsahující Stínová zkopírovaná sestavení do prázdného řetězce ("").Resets the list of directories containing shadow copied assemblies to the empty string ("").

CreateComInstanceFrom(String, String)

Vytvoří novou instanci určeného typu COM.Creates a new instance of a specified COM type. Parametry určují název souboru, který obsahuje sestavení obsahující typ a název typu.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)

Vytvoří novou instanci určeného typu COM.Creates a new instance of a specified COM type. Parametry určují název souboru, který obsahuje sestavení obsahující typ a název typu.Parameters specify the name of a file that contains an assembly containing the type and the name of the type.

CreateDomain(String)

Vytvoří novou doménu aplikace se zadaným názvem.Creates a new application domain with the specified name.

CreateDomain(String, Evidence)

Vytvoří novou doménu aplikace se zadaným názvem pomocí poskytnuté legitimace.Creates a new application domain with the given name using the supplied evidence.

CreateDomain(String, Evidence, AppDomainSetup)

Vytvoří novou doménu aplikace pomocí zadaného názvu, legitimace a informací o nastavení domény aplikace.Creates a new application domain using the specified name, evidence, and application domain setup information.

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

Vytvoří novou doménu aplikace pomocí zadaného názvu, legitimace, informace o nastavení domény aplikace, výchozí sady oprávnění a pole plně důvěryhodných sestavení.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)

Vytvoří novou doménu aplikace se zadaným názvem, používá legitimaci, základní cestu aplikace, relativní cestu hledání a parametr, který určuje, jestli se má do domény aplikace načíst Stínová kopie sestavení.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[])

Vytvoří novou doménu aplikace se zadaným názvem, používá legitimaci, základní cestu aplikace, relativní cestu hledání a parametr, který určuje, jestli se má do domény aplikace načíst Stínová kopie sestavení.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. Určuje metodu zpětného volání, která je vyvolána při inicializaci domény aplikace, a pole řetězcových argumentů, které mají předat metodu zpětného volání.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)

Vytvoří novou instanci určeného typu definovaného v zadaném sestavení.Creates a new instance of the specified type defined in the specified assembly.

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

Vytvoří novou instanci určeného typu definovaného v zadaném sestavení.Creates a new instance of the specified type defined in the specified assembly. Parametry určují pořadač, příznaky vazby, argumenty konstruktoru, informace specifické pro jazykovou verzi sloužící k interpretaci argumentů a volitelné aktivační atributy.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)

Vytvoří novou instanci určeného typu definovaného v zadaném sestavení.Creates a new instance of the specified type defined in the specified assembly. Parametry určují pořadač, příznaky vazeb, argumenty konstruktoru, informace specifické pro jazykovou verzi, které slouží k interpretaci argumentů, aktivačních atributů a autorizaci pro vytvoření typu.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[])

Vytvoří novou instanci určeného typu definovaného v zadaném sestavení.Creates a new instance of the specified type defined in the specified assembly. Parametr určuje pole aktivačních atributů.A parameter specifies an array of activation attributes.

CreateInstanceAndUnwrap(String, String)

Vytvoří novou instanci zadaného typu.Creates a new instance of the specified type. Parametry určují sestavení, kde je definován typ a název typu.Parameters specify the assembly where the type is defined, and the name of the type.

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

Vytvoří novou instanci zadaného typu definovaného v zadaném sestavení a určí, jestli se má ignorovat případ názvu typu. atributy vazby a pořadač, které slouží k výběru typu, který se má vytvořit; argumenty konstruktoru; Jazyková verze; a aktivační atributy.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)

Vytvoří novou instanci zadaného typu.Creates a new instance of the specified type. Parametry určují název typu a způsob jeho nalezení a vytvoření.Parameters specify the name of the type, and how it is found and created.

CreateInstanceAndUnwrap(String, String, Object[])

Vytvoří novou instanci zadaného typu.Creates a new instance of the specified type. Parametry určují sestavení, kde je definován typ, název typu a pole aktivačních atributů.Parameters specify the assembly where the type is defined, the name of the type, and an array of activation attributes.

CreateInstanceFrom(String, String)

Vytvoří novou instanci určeného typu definovaného v určeném souboru sestavení.Creates a new instance of the specified type defined in the specified assembly file.

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

Vytvoří novou instanci určeného typu definovaného v určeném souboru sestavení.Creates a new instance of the specified type defined in the specified assembly file.

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

Vytvoří novou instanci určeného typu definovaného v určeném souboru sestavení.Creates a new instance of the specified type defined in the specified assembly file.

CreateInstanceFrom(String, String, Object[])

Vytvoří novou instanci určeného typu definovaného v určeném souboru sestavení.Creates a new instance of the specified type defined in the specified assembly file.

CreateInstanceFromAndUnwrap(String, String)

Vytvoří novou instanci určeného typu definovaného v určeném souboru sestavení.Creates a new instance of the specified type defined in the specified assembly file.

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

Vytvoří novou instanci zadaného typu definovaného v zadaném souboru sestavení a určí, jestli se má ignorovat případ názvu typu. atributy vazby a pořadač, které slouží k výběru typu, který se má vytvořit; argumenty konstruktoru; Jazyková verze; a aktivační atributy.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)

Vytvoří novou instanci určeného typu definovaného v určeném souboru sestavení.Creates a new instance of the specified type defined in the specified assembly file.

CreateInstanceFromAndUnwrap(String, String, Object[])

Vytvoří novou instanci určeného typu definovaného v určeném souboru sestavení.Creates a new instance of the specified type defined in the specified assembly file.

CreateObjRef(Type)

Vytvoří objekt, který obsahuje všechny relevantní informace požadované pro vygenerování proxy serveru, který se používá ke komunikaci se vzdáleným objektem.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Zděděno od MarshalByRefObject)
DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess)

Definuje dynamické sestavení se zadaným názvem a režimem přístupu.Defines a dynamic assembly with the specified name and access mode.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, Evidence)

Definuje dynamické sestavení pomocí zadaného názvu, režimu přístupu a legitimace.Defines a dynamic assembly using the specified name, access mode, and evidence.

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

Definuje dynamické sestavení pomocí zadaného názvu, režimu přístupu, legitimace a žádostí o oprávnění.Defines a dynamic assembly using the specified name, access mode, evidence, and permission requests.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, IEnumerable<CustomAttributeBuilder>)

Definuje dynamické sestavení se zadaným názvem, režimem přístupu a vlastními atributy.Defines a dynamic assembly with the specified name, access mode, and custom attributes.

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

Definuje dynamické sestavení se zadaným názvem, režimem přístupu a vlastními atributy a používá zadaný zdroj pro svůj kontext zabezpečení.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)

Definuje dynamické sestavení pomocí zadaného názvu, režimu přístupu a žádostí o oprávnění.Defines a dynamic assembly using the specified name, access mode, and permission requests.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String)

Definuje dynamické sestavení pomocí zadaného názvu, režimu přístupu a adresáře úložiště.Defines a dynamic assembly using the specified name, access mode, and storage directory.

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

Definuje dynamické sestavení pomocí zadaného názvu, režimu přístupu, adresáře úložiště a možnosti synchronizace.Defines a dynamic assembly using the specified name, access mode, storage directory, and synchronization option.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Evidence)

Definuje dynamické sestavení pomocí zadaného názvu, režimu přístupu, adresáře úložiště a legitimace.Defines a dynamic assembly using the specified name, access mode, storage directory, and evidence.

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

Definuje dynamické sestavení pomocí zadaného názvu, režimu přístupu, adresáře úložiště, legitimace a žádostí o oprávnění.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)

Definuje dynamické sestavení pomocí zadaného názvu, režimu přístupu, adresáře úložiště, legitimace, žádostí o oprávnění a možností synchronizace.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>)

Definuje dynamické sestavení se zadaným názvem, režimem přístupu, adresářem úložiště, legitimací, žádostmi o oprávnění, možností synchronizace a vlastními atributy.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)

Definuje dynamické sestavení pomocí zadaného názvu, režimu přístupu, adresáře úložiště a žádostí o oprávnění.Defines a dynamic assembly using the specified name, access mode, storage directory, and permission requests.

DoCallBack(CrossAppDomainDelegate)

Spustí kód v jiné doméně aplikace, která je identifikována zadaným delegátem.Executes the code in another application domain that is identified by the specified delegate.

Equals(Object)

Určuje, zda se zadaný objekt rovná aktuálnímu objektu.Determines whether the specified object is equal to the current object.

(Zděděno od Object)
ExecuteAssembly(String)

Provede sestavení obsažené v zadaném souboru.Executes the assembly contained in the specified file.

ExecuteAssembly(String, Evidence)

Provede sestavení obsažené v zadaném souboru pomocí zadaného legitimace.Executes the assembly contained in the specified file, using the specified evidence.

ExecuteAssembly(String, Evidence, String[])

Provede sestavení obsažené v zadaném souboru pomocí zadaných legitimací a argumentů.Executes the assembly contained in the specified file, using the specified evidence and arguments.

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

Provede sestavení obsažené v zadaném souboru pomocí zadaných legitimací, argumentů, hodnoty hash a algoritmu hash.Executes the assembly contained in the specified file, using the specified evidence, arguments, hash value, and hash algorithm.

ExecuteAssembly(String, String[])

Provede sestavení obsažené v zadaném souboru pomocí zadaných argumentů.Executes the assembly contained in the specified file, using the specified arguments.

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

Provede sestavení obsažené v zadaném souboru pomocí zadaných argumentů, hodnoty hash a algoritmu hash.Executes the assembly contained in the specified file, using the specified arguments, hash value, and hash algorithm.

ExecuteAssemblyByName(AssemblyName, Evidence, String[])

Provede sestavení podle AssemblyNamepomocí zadaných legitimací a argumentů.Executes the assembly given an AssemblyName, using the specified evidence and arguments.

ExecuteAssemblyByName(AssemblyName, String[])

Spustí sestavení s použitím zadaných argumentů AssemblyName.Executes the assembly given an AssemblyName, using the specified arguments.

ExecuteAssemblyByName(String)

Provede sestavení se zadaným zobrazovaným názvem.Executes an assembly given its display name.

ExecuteAssemblyByName(String, Evidence)

Provede sestavení se zadaným zobrazovaným názvem pomocí zadaného legitimace.Executes an assembly given its display name, using the specified evidence.

ExecuteAssemblyByName(String, Evidence, String[])

Provede sestavení podle jeho zobrazovaného názvu pomocí zadaných legitimací a argumentů.Executes the assembly given its display name, using the specified evidence and arguments.

ExecuteAssemblyByName(String, String[])

Provede sestavení podle jeho zobrazovaného názvu pomocí zadaných argumentů.Executes the assembly given its display name, using the specified arguments.

GetAssemblies()

Načte sestavení, která byla načtena do kontextu provádění této domény aplikace.Gets the assemblies that have been loaded into the execution context of this application domain.

GetCurrentThreadId()

Získá aktuální identifikátor vlákna.Gets the current thread identifier.

GetData(String)

Získá hodnotu uloženou v aktuální aplikační doméně pro zadaný název.Gets the value stored in the current application domain for the specified name.

GetHashCode()

Slouží jako výchozí funkce hash.Serves as the default hash function.

(Zděděno od Object)
GetLifetimeService()

Načte aktuální objekt služby životnosti, který řídí zásady životního cyklu pro tuto instanci.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Zděděno od MarshalByRefObject)
GetType()

Získá typ aktuální instance.Gets the type of the current instance.

InitializeLifetimeService()

Poskytuje AppDomain nekonečné životnosti tím, že brání v vytváření zapůjčení.Gives the AppDomain an infinite lifetime by preventing a lease from being created.

IsCompatibilitySwitchSet(String)

Získá logickou hodnotu s možnou hodnotou null, která označuje, zda jsou nastaveny všechny přepínače kompatibility a pokud ano, zda je nastaven zadaný přepínač kompatibility.Gets a nullable Boolean value that indicates whether any compatibility switches are set, and if so, whether the specified compatibility switch is set.

IsDefaultAppDomain()

Vrátí hodnotu, která označuje, zda je doména aplikace výchozí aplikační doménou pro daný proces.Returns a value that indicates whether the application domain is the default application domain for the process.

IsFinalizingForUnload()

Určuje, zda je tato doména aplikace uvolňována, a objekty, které obsahuje, jsou finalizován modulem CLR (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)

Načte Assembly, který je daný AssemblyName.Loads an Assembly given its AssemblyName.

Load(AssemblyName, Evidence)

Načte Assembly, který je daný AssemblyName.Loads an Assembly given its AssemblyName.

Load(Byte[])

Načte Assembly s obrázkem založený na formátu COFF (Common Object File Format), který obsahuje emitované Assembly.Loads the Assembly with a common object file format (COFF) based image containing an emitted Assembly.

Load(Byte[], Byte[])

Načte Assembly s obrázkem založený na formátu COFF (Common Object File Format), který obsahuje emitované Assembly.Loads the Assembly with a common object file format (COFF) based image containing an emitted Assembly. Načtou se také nezpracované bajty představující symboly pro Assembly.The raw bytes representing the symbols for the Assembly are also loaded.

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

Načte Assembly s obrázkem založený na formátu COFF (Common Object File Format), který obsahuje emitované Assembly.Loads the Assembly with a common object file format (COFF) based image containing an emitted Assembly. Načtou se také nezpracované bajty představující symboly pro Assembly.The raw bytes representing the symbols for the Assembly are also loaded.

Load(String)

Načte Assembly, který má zobrazované jméno.Loads an Assembly given its display name.

Load(String, Evidence)

Načte Assembly, který má zobrazované jméno.Loads an Assembly given its display name.

MemberwiseClone()

Vytvoří kopii aktuálního Objectbez podstruktury.Creates a shallow copy of the current Object.

(Zděděno od Object)
MemberwiseClone(Boolean)

Vytvoří kopii aktuálního MarshalByRefObject objektu bez podstruktury.Creates a shallow copy of the current MarshalByRefObject object.

(Zděděno od MarshalByRefObject)
ReflectionOnlyGetAssemblies()

Vrátí sestavení, která byla načtena do kontextu pouze pro reflexi domény aplikace.Returns the assemblies that have been loaded into the reflection-only context of the application domain.

SetAppDomainPolicy(PolicyLevel)

Vytvoří úroveň zásad zabezpečení pro tuto doménu aplikace.Establishes the security policy level for this application domain.

SetCachePath(String)

Vytvoří zadanou cestu k adresáři jako umístění, kam se kopírují Stínová sestavení.Establishes the specified directory path as the location where assemblies are shadow copied.

SetData(String, Object)

Přiřadí zadanou hodnotu k zadané vlastnosti domény aplikace.Assigns the specified value to the specified application domain property.

SetData(String, Object, IPermission)

Přiřadí zadanou hodnotu k zadané vlastnosti domény aplikace se zadaným oprávněním pro vyžádání volajícího, když je vlastnost načtena.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)

Zřídí zadanou cestu k adresáři jako základní adresář pro podadresáře, kde jsou uložené dynamicky generované soubory a jsou k nim přistupované.Establishes the specified directory path as the base directory for subdirectories where dynamically generated files are stored and accessed.

SetPrincipalPolicy(PrincipalPolicy)

Určuje, jakým způsobem by se měly objekty zabezpečení a identity připojit ke vláknu, pokud se vlákno pokusí vytvořit připojení k objektu zabezpečení při provádění v této doméně aplikace.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()

Zapne stínové kopírování.Turns on shadow copying.

SetShadowCopyPath(String)

Vytvoří zadanou cestu k adresáři jako umístění sestavení, která se mají zkopírovat stínové kopie.Establishes the specified directory path as the location of assemblies to be shadow copied.

SetThreadPrincipal(IPrincipal)

Nastaví výchozí objekt zabezpečení, který má být připojen k vláknům při pokusu o vytvoření vazby k objektu zabezpečení při spuštění v této doméně aplikace.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()

Získá řetězcovou reprezentaci, která obsahuje popisný název domény aplikace a všechny zásady kontextu.Obtains a string representation that includes the friendly name of the application domain and any context policies.

Unload(AppDomain)

Uvolní zadanou doménu aplikace.Unloads the specified application domain.

Události

AssemblyLoad

Vyvolá se v případě, že je načteno sestavení.Occurs when an assembly is loaded.

AssemblyResolve

Nastane, pokud se nezdařil překlad sestavení.Occurs when the resolution of an assembly fails.

DomainUnload

Vyvolá se v případě, že dojde k uvolnění AppDomain.Occurs when an AppDomain is about to be unloaded.

FirstChanceException

Nastane, pokud je vyvolána výjimka ve spravovaném kódu, než modul runtime vyhledá v zásobníku volání obslužnou rutinu výjimky v doméně aplikace.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

Nastane, pokud se ukončí nadřazený proces výchozí domény aplikace.Occurs when the default application domain's parent process exits.

ReflectionOnlyAssemblyResolve

Vyvolá se v případě, že překlad sestavení se v kontextu pouze pro reflexi nezdařil.Occurs when the resolution of an assembly fails in the reflection-only context.

ResourceResolve

Vyvolá se v případě, že překlad prostředku se nezdařil, protože prostředek není platným propojeným nebo integrovaným prostředkem v sestavení.Occurs when the resolution of a resource fails because the resource is not a valid linked or embedded resource in the assembly.

TypeResolve

Vyvolá se v případě, že překlad typu se nezdařil.Occurs when the resolution of a type fails.

UnhandledException

Nastane, pokud není zachycena výjimka.Occurs when an exception is not caught.

Explicitní implementace rozhraní

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

Mapuje sadu názvů na odpovídající sadu identifikátorů pro rozesílání.Maps a set of names to a corresponding set of dispatch identifiers.

_AppDomain.GetTypeInfo(UInt32, UInt32, IntPtr)

Načte informace o typu objektu, který lze použít k získání informací o typu pro rozhraní.Retrieves the type information for an object, which can then be used to get the type information for an interface.

_AppDomain.GetTypeInfoCount(UInt32)

Získá počet rozhraní typu informací, které objekt poskytuje (0 nebo 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)

Poskytuje přístup k vlastnostem a metodám vystaveným objektem.Provides access to properties and methods exposed by an object.

Platí pro

Viz také