AppDomain Klasa

Definicja

Reprezentuje domenę aplikacji, czyli środowisko izolowane, w którym są wykonywane aplikacje.Represents an application domain, which is an isolated environment where applications execute. Klasa ta nie może być dziedziczona.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
Dziedziczenie
Atrybuty
Implementuje

Przykłady

Ten przykład pokazuje, jak utworzyć nowy AppDomain, utworzyć wystąpienie typu w tym nowym AppDomaini komunikować się z obiektem tego typu.This example shows how to create a new AppDomain, instantiate a type in that new AppDomain, and communicate with that type's object. Ponadto w tym przykładzie pokazano, jak zwolnić AppDomain powodujące, że obiekt ma zostać wyrzucony.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.

Uwagi

Domeny aplikacji, które są reprezentowane przez AppDomain obiektów, ułatwiają izolację, wyładowywanie i granice zabezpieczeń na potrzeby wykonywania kodu zarządzanego.Application domains, which are represented by AppDomain objects, help provide isolation, unloading, and security boundaries for executing managed code.

  • Używanie domen aplikacji do izolowania zadań, które mogą spowodować przeprowadzenie procesu.Use application domains to isolate tasks that might bring down a process. Jeśli stan AppDomain wykonywania zadania stanie się niestabilny, AppDomain można zwolnić z pamięci bez wpływu na proces.If the state of the AppDomain that's executing a task becomes unstable, the AppDomain can be unloaded without affecting the process. Jest to ważne, gdy proces musi być uruchomiony przez długie okresy bez ponownego uruchamiania.This is important when a process must run for long periods without restarting. Możesz również użyć domen aplikacji do izolowania zadań, które nie powinny udostępniać danych.You can also use application domains to isolate tasks that should not share data.

  • Jeśli zestaw jest ładowany do domyślnej domeny aplikacji, nie można go zwolnić z pamięci, gdy proces jest uruchomiony.If an assembly is loaded into the default application domain, it cannot be unloaded from memory while the process is running. Jeśli jednak otworzysz drugą domenę aplikacji w celu załadowania i wykonania zestawu, zestaw zostanie zwolniony, gdy domena aplikacji zostanie zwolniona.However, if you open a second application domain to load and execute the assembly, the assembly is unloaded when that application domain is unloaded. Ta technika służy do minimalizowania zestawu roboczego długotrwałych procesów, które czasami używają dużych bibliotek DLL.Use this technique to minimize the working set of long-running processes that occasionally use large DLLs.

Uwaga

W przypadku platformy .NET Core implementacja AppDomain jest ograniczona przez konstrukcję i nie zapewnia izolacji, zwalniania ani granic zabezpieczeń.On .NET Core, the AppDomain implementation is limited by design and does not provide isolation, unloading, or security boundaries. W przypadku platformy .NET Core istnieje dokładnie jedna AppDomain.For .NET Core, there is exactly one AppDomain. Izolacja i wyładowywanie są udostępniane za AssemblyLoadContext.Isolation and unloading are provided through AssemblyLoadContext. Granice zabezpieczeń powinny być zapewnione przez granice procesu i odpowiednie techniki komunikacji zdalnej.Security boundaries should be provided by process boundaries and appropriate remoting techniques.

Wiele domen aplikacji może działać w jednym procesie; nie istnieje jednak korelacja jeden-do-jednego między domenami aplikacji i wątkami.Multiple application domains can run in a single process; however, there is not a one-to-one correlation between application domains and threads. Kilka wątków może należeć do jednej domeny aplikacji, a podczas gdy dany wątek nie jest ograniczony do pojedynczej domeny aplikacji, w danym momencie wątek jest wykonywany w jednej domenie aplikacji.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.

Domeny aplikacji są tworzone przy użyciu metody CreateDomain.Application domains are created using the CreateDomain method. wystąpienia AppDomain są używane do ładowania i uruchamiania zestawów (Assembly).AppDomain instances are used to load and execute assemblies (Assembly). Gdy AppDomain nie jest już używana, można go zwolnić.When an AppDomain is no longer in use, it can be unloaded.

Klasa AppDomain implementuje zestaw zdarzeń, które umożliwiają aplikacjom reagowanie w przypadku załadowania zestawu, gdy domena aplikacji zostanie zwolniona lub gdy zostanie zgłoszony nieobsługiwany wyjątek.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.

Aby uzyskać więcej informacji o korzystaniu z domen aplikacji, zobacz domeny aplikacji.For more information on using application domains, see Application Domains.

Ta klasa implementuje interfejsy MarshalByRefObject, _AppDomaini IEvidenceFactory.This class implements the MarshalByRefObject, _AppDomain, and IEvidenceFactory interfaces.

Nigdy nie należy tworzyć otoki zdalnej dla obiektu AppDomain.You should never create a remotable wrapper for an AppDomain object. Dzięki temu można opublikować zdalne odwołanie do tego AppDomain, ujawniając metody, takie jak CreateInstance do dostępu zdalnego i skutecznie niszczyją zabezpieczenia dostępu kodu dla tego 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. Złośliwi klienci łączący się ze zdalnym AppDomain mogą uzyskać dostęp do dowolnego zasobu, do którego AppDomain ma dostęp.Malicious clients connecting to the remoted AppDomain could obtain access to any resource the AppDomain itself has access to. Nie należy tworzyć otok zdalnych dla dowolnego typu, który rozszerza MarshalByRefObject i implementuje metody, które mogą być używane przez złośliwych klientów do pomijania systemu zabezpieczeń.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.

Przestroga

Wartość domyślna właściwości AppDomainSetup.DisallowCodeDownload jest false.The default value for the AppDomainSetup.DisallowCodeDownload property is false. To ustawienie jest niebezpieczne dla usług.This setting is unsafe for services. Aby zapobiec pobieraniu częściowo zaufanego kodu przez usługi, należy ustawić tę właściwość na true.To prevent services from downloading partially trusted code, set this property to true.

Właściwości

ActivationContext

Pobiera kontekst aktywacji dla bieżącej domeny aplikacji.Gets the activation context for the current application domain.

ApplicationIdentity

Pobiera tożsamość aplikacji w domenie aplikacji.Gets the identity of the application in the application domain.

ApplicationTrust

Pobiera informacje opisujące uprawnienia przyznane aplikacji oraz określa, czy aplikacja ma poziom zaufania, który umożliwia jego uruchomienie.Gets information describing permissions granted to an application and whether the application has a trust level that allows it to run.

BaseDirectory

Pobiera katalog podstawowy używany przez program rozpoznawania zestawu do sondowania dla zestawów.Gets the base directory that the assembly resolver uses to probe for assemblies.

CurrentDomain

Pobiera bieżącą domenę aplikacji dla bieżącego Thread.Gets the current application domain for the current Thread.

DomainManager

Pobiera Menedżera domeny, który został dostarczony przez hosta po zainicjowaniu domeny aplikacji.Gets the domain manager that was provided by the host when the application domain was initialized.

DynamicDirectory

Pobiera katalog używany przez program rozpoznawania zestawu do sondowania dla dynamicznie utworzonych zestawów.Gets the directory that the assembly resolver uses to probe for dynamically created assemblies.

Evidence

Pobiera Evidence skojarzona z tą domeną aplikacji.Gets the Evidence associated with this application domain.

FriendlyName

Pobiera przyjazną nazwę tej domeny aplikacji.Gets the friendly name of this application domain.

Id

Pobiera liczbę całkowitą, która jednoznacznie identyfikuje domenę aplikacji w ramach procesu.Gets an integer that uniquely identifies the application domain within the process.

IsFullyTrusted

Pobiera wartość wskazującą, czy zestawy, które są ładowane do bieżącej domeny aplikacji, są wykonywane z pełnym zaufaniem.Gets a value that indicates whether assemblies that are loaded into the current application domain execute with full trust.

IsHomogenous

Pobiera wartość wskazującą, czy bieżąca domena aplikacji ma zestaw uprawnień, które są przydzielane do wszystkich zestawów, które są ładowane do domeny aplikacji.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

Pobiera lub ustawia wartość wskazującą, czy dla bieżącego procesu jest włączone monitorowanie procesora CPU i pamięci dla domen aplikacji.Gets or sets a value that indicates whether CPU and memory monitoring of application domains is enabled for the current process. Po włączeniu monitorowania dla procesu nie można go wyłączyć.Once monitoring is enabled for a process, it cannot be disabled.

MonitoringSurvivedMemorySize

Pobiera liczbę bajtów, które przeżyły ostatnią kolekcję i które są znane do odwołania przez bieżącą domenę aplikacji.Gets the number of bytes that survived the last collection and that are known to be referenced by the current application domain.

MonitoringSurvivedProcessMemorySize

Pobiera łączną liczbę bajtów przetworzonych z ostatniej kolekcji dla wszystkich domen aplikacji w procesie.Gets the total bytes that survived from the last collection for all application domains in the process.

MonitoringTotalAllocatedMemorySize

Pobiera łączny rozmiar (w bajtach) wszystkich alokacji pamięci wykonanych przez domenę aplikacji od momentu utworzenia, bez odejmowania pamięci, która została zebrana.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

Pobiera łączny czas procesora, który był używany przez wszystkie wątki podczas wykonywania w bieżącej domenie aplikacji, od momentu rozpoczęcia 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

Pobiera zestaw uprawnień domeny aplikacji w trybie piaskownicy.Gets the permission set of a sandboxed application domain.

RelativeSearchPath

Pobiera ścieżkę do katalogu podstawowego, w którym program rozpoznawania zestawu powinien sondować dla zestawów prywatnych.Gets the path under the base directory where the assembly resolver should probe for private assemblies.

SetupInformation

Pobiera informacje o konfiguracji domeny aplikacji dla tego wystąpienia.Gets the application domain configuration information for this instance.

ShadowCopyFiles

Pobiera informację o tym, czy domena aplikacji jest skonfigurowana do kopiowania plików w tle.Gets an indication whether the application domain is configured to shadow copy files.

Metody

AppendPrivatePath(String)

Dołącza określoną nazwę katalogu do listy ścieżek prywatnych.Appends the specified directory name to the private path list.

ApplyPolicy(String)

Zwraca nazwę wyświetlaną zestawu po zastosowaniu zasad.Returns the assembly display name after policy has been applied.

ClearPrivatePath()

Resetuje ścieżkę określającą lokalizację prywatnych zestawów do pustego ciągu ("").Resets the path that specifies the location of private assemblies to the empty string ("").

ClearShadowCopyPath()

Resetuje listę katalogów zawierających skopiowane zestawy w tle do pustego ciągu ("").Resets the list of directories containing shadow copied assemblies to the empty string ("").

CreateComInstanceFrom(String, String)

Tworzy nowe wystąpienie określonego typu COM.Creates a new instance of a specified COM type. Parametry określają nazwę pliku, który zawiera zestaw zawierający typ i nazwę 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)

Tworzy nowe wystąpienie określonego typu COM.Creates a new instance of a specified COM type. Parametry określają nazwę pliku, który zawiera zestaw zawierający typ i nazwę typu.Parameters specify the name of a file that contains an assembly containing the type and the name of the type.

CreateDomain(String)

Tworzy nową domenę aplikacji o określonej nazwie.Creates a new application domain with the specified name.

CreateDomain(String, Evidence)

Tworzy nową domenę aplikacji o podanej nazwie przy użyciu dostarczonych dowodów.Creates a new application domain with the given name using the supplied evidence.

CreateDomain(String, Evidence, AppDomainSetup)

Tworzy nową domenę aplikacji przy użyciu określonej nazwy, dowodów i informacji o konfiguracji domeny aplikacji.Creates a new application domain using the specified name, evidence, and application domain setup information.

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

Tworzy nową domenę aplikacji przy użyciu określonej nazwy, dowodów, informacji o konfiguracji domeny aplikacji, domyślnego zestawu uprawnień i tablicy w pełni zaufanych zestawów.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)

Tworzy nową domenę aplikacji o podaną nazwę, używając dowodów, ścieżki bazowej aplikacji, ścieżki wyszukiwania względnego i parametru, który określa, czy kopia w tle zestawu ma zostać załadowana do domeny aplikacji.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[])

Tworzy nową domenę aplikacji o podaną nazwę, używając dowodów, ścieżki bazowej aplikacji, ścieżki wyszukiwania względnego i parametru, który określa, czy kopia w tle zestawu ma zostać załadowana do domeny aplikacji.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. Określa metodę wywołania zwrotnego, która jest wywoływana, gdy domena aplikacji zostanie zainicjowana, i tablicę argumentów ciągu do przekazania metody wywołania zwrotnego.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)

Tworzy nowe wystąpienie określonego typu zdefiniowanego w podanym zestawie.Creates a new instance of the specified type defined in the specified assembly.

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

Tworzy nowe wystąpienie określonego typu zdefiniowanego w podanym zestawie.Creates a new instance of the specified type defined in the specified assembly. Parametry określają spinacz, flagi powiązań, argumenty konstruktora, informacje specyficzne dla kultury używane do interpretowania argumentów i opcjonalne atrybuty aktywacji.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)

Tworzy nowe wystąpienie określonego typu zdefiniowanego w podanym zestawie.Creates a new instance of the specified type defined in the specified assembly. Parametry określają spinacz, flagi powiązania, argumenty konstruktora, informacje specyficzne dla kultury służące do interpretowania argumentów, atrybutów aktywacji i autoryzacji w celu utworzenia 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[])

Tworzy nowe wystąpienie określonego typu zdefiniowanego w podanym zestawie.Creates a new instance of the specified type defined in the specified assembly. Parametr określa tablicę atrybutów aktywacji.A parameter specifies an array of activation attributes.

CreateInstanceAndUnwrap(String, String)

Tworzy nowe wystąpienie określonego typu.Creates a new instance of the specified type. Parametry określają zestaw, w którym jest zdefiniowany typ, i nazwę 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[])

Tworzy nowe wystąpienie określonego typu zdefiniowane w określonym zestawie, określając, czy przypadek nazwy typu jest ignorowany; atrybuty powiązania i spinacz, które są używane do wybierania typu, który ma zostać utworzony; argumenty konstruktora; Kultura; i atrybuty aktywacji.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)

Tworzy nowe wystąpienie określonego typu.Creates a new instance of the specified type. Parametry określają nazwę typu oraz sposób ich znajdowania i tworzenia.Parameters specify the name of the type, and how it is found and created.

CreateInstanceAndUnwrap(String, String, Object[])

Tworzy nowe wystąpienie określonego typu.Creates a new instance of the specified type. Parametry określają zestaw, w którym jest zdefiniowany typ, nazwę typu i tablicę atrybutów aktywacji.Parameters specify the assembly where the type is defined, the name of the type, and an array of activation attributes.

CreateInstanceFrom(String, String)

Tworzy nowe wystąpienie określonego typu zdefiniowanego w podanym pliku zestawu.Creates a new instance of the specified type defined in the specified assembly file.

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

Tworzy nowe wystąpienie określonego typu zdefiniowanego w podanym pliku zestawu.Creates a new instance of the specified type defined in the specified assembly file.

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

Tworzy nowe wystąpienie określonego typu zdefiniowanego w podanym pliku zestawu.Creates a new instance of the specified type defined in the specified assembly file.

CreateInstanceFrom(String, String, Object[])

Tworzy nowe wystąpienie określonego typu zdefiniowanego w podanym pliku zestawu.Creates a new instance of the specified type defined in the specified assembly file.

CreateInstanceFromAndUnwrap(String, String)

Tworzy nowe wystąpienie określonego typu zdefiniowanego w podanym pliku zestawu.Creates a new instance of the specified type defined in the specified assembly file.

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

Tworzy nowe wystąpienie określonego typu zdefiniowane w określonym pliku zestawu, określając, czy przypadek nazwy typu jest ignorowany; atrybuty powiązania i spinacz, które są używane do wybierania typu, który ma zostać utworzony; argumenty konstruktora; Kultura; i atrybuty aktywacji.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)

Tworzy nowe wystąpienie określonego typu zdefiniowanego w podanym pliku zestawu.Creates a new instance of the specified type defined in the specified assembly file.

CreateInstanceFromAndUnwrap(String, String, Object[])

Tworzy nowe wystąpienie określonego typu zdefiniowanego w podanym pliku zestawu.Creates a new instance of the specified type defined in the specified assembly file.

CreateObjRef(Type)

Tworzy obiekt, który zawiera wszystkie istotne informacje wymagane do wygenerowania serwera proxy używanego do komunikacji z obiektem zdalnym.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Odziedziczone po MarshalByRefObject)
DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess)

Definiuje dynamiczny zestaw z określoną nazwą i trybem dostępu.Defines a dynamic assembly with the specified name and access mode.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, Evidence)

Definiuje zestaw dynamiczny przy użyciu określonej nazwy, trybu dostępu i dowodu.Defines a dynamic assembly using the specified name, access mode, and evidence.

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

Definiuje zestaw dynamiczny przy użyciu określonej nazwy, trybu dostępu, dowodów i żądań uprawnień.Defines a dynamic assembly using the specified name, access mode, evidence, and permission requests.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, IEnumerable<CustomAttributeBuilder>)

Definiuje dynamiczny zestaw z określoną nazwą, trybem dostępu i atrybutami niestandardowymi.Defines a dynamic assembly with the specified name, access mode, and custom attributes.

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

Definiuje dynamiczny zestaw z określoną nazwą, trybem dostępu i atrybutami niestandardowymi oraz przy użyciu określonego źródła dla jego kontekstu zabezpieczeń.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)

Definiuje zestaw dynamiczny przy użyciu określonej nazwy, trybu dostępu i żądań uprawnień.Defines a dynamic assembly using the specified name, access mode, and permission requests.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String)

Definiuje zestaw dynamiczny przy użyciu określonej nazwy, trybu dostępu i katalogu magazynu.Defines a dynamic assembly using the specified name, access mode, and storage directory.

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

Definiuje zestaw dynamiczny przy użyciu określonej nazwy, trybu dostępu, katalogu magazynu i opcji synchronizacji.Defines a dynamic assembly using the specified name, access mode, storage directory, and synchronization option.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Evidence)

Definiuje zestaw dynamiczny przy użyciu określonej nazwy, trybu dostępu, katalogu magazynu i dowodu.Defines a dynamic assembly using the specified name, access mode, storage directory, and evidence.

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

Definiuje zestaw dynamiczny przy użyciu określonej nazwy, trybu dostępu, katalogu magazynu, dowodów i żądań uprawnień.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)

Definiuje zestaw dynamiczny przy użyciu określonej nazwy, trybu dostępu, katalogu magazynu, dowodów, żądań uprawnień i opcji synchronizacji.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>)

Definiuje dynamiczny zestaw z określoną nazwą, trybem dostępu, katalogiem magazynu, dowodem, żądaniami uprawnień, opcjami synchronizacji i atrybutami niestandardowymi.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)

Definiuje zestaw dynamiczny przy użyciu określonej nazwy, trybu dostępu, katalogu magazynu i żądań uprawnień.Defines a dynamic assembly using the specified name, access mode, storage directory, and permission requests.

DoCallBack(CrossAppDomainDelegate)

Wykonuje kod w innej domenie aplikacji, który jest identyfikowany przez określony delegat.Executes the code in another application domain that is identified by the specified delegate.

Equals(Object)

Określa, czy określony obiekt jest równy bieżącemu obiektowi.Determines whether the specified object is equal to the current object.

(Odziedziczone po Object)
ExecuteAssembly(String)

Wykonuje zestaw zawarty w określonym pliku.Executes the assembly contained in the specified file.

ExecuteAssembly(String, Evidence)

Wykonuje zestaw zawarty w określonym pliku przy użyciu określonych dowodów.Executes the assembly contained in the specified file, using the specified evidence.

ExecuteAssembly(String, Evidence, String[])

Wykonuje zestaw zawarty w określonym pliku przy użyciu określonych dowodów i argumentów.Executes the assembly contained in the specified file, using the specified evidence and arguments.

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

Wykonuje zestaw zawarty w określonym pliku przy użyciu określonych dowodów, argumentów, wartości skrótu i algorytmu wyznaczania wartości skrótu.Executes the assembly contained in the specified file, using the specified evidence, arguments, hash value, and hash algorithm.

ExecuteAssembly(String, String[])

Wykonuje zestaw zawarty w określonym pliku przy użyciu określonych argumentów.Executes the assembly contained in the specified file, using the specified arguments.

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

Wykonuje zestaw zawarty w określonym pliku, używając określonych argumentów, wartości skrótu i algorytmu wyznaczania wartości skrótu.Executes the assembly contained in the specified file, using the specified arguments, hash value, and hash algorithm.

ExecuteAssemblyByName(AssemblyName, Evidence, String[])

Wykonuje zestaw danych AssemblyNameprzy użyciu określonych dowodów i argumentów.Executes the assembly given an AssemblyName, using the specified evidence and arguments.

ExecuteAssemblyByName(AssemblyName, String[])

Wykonuje zestaw danych AssemblyNameprzy użyciu określonych argumentów.Executes the assembly given an AssemblyName, using the specified arguments.

ExecuteAssemblyByName(String)

Wykonuje zestaw z nazwą wyświetlaną.Executes an assembly given its display name.

ExecuteAssemblyByName(String, Evidence)

Wykonuje zestaw z nazwą wyświetlaną, używając określonego dowodu.Executes an assembly given its display name, using the specified evidence.

ExecuteAssemblyByName(String, Evidence, String[])

Wykonuje zestaw z nazwą wyświetlaną, przy użyciu określonych dowodów i argumentów.Executes the assembly given its display name, using the specified evidence and arguments.

ExecuteAssemblyByName(String, String[])

Wykonuje zestaw z nazwą wyświetlaną, używając określonych argumentów.Executes the assembly given its display name, using the specified arguments.

GetAssemblies()

Pobiera zestawy, które zostały załadowane do kontekstu wykonywania tej domeny aplikacji.Gets the assemblies that have been loaded into the execution context of this application domain.

GetCurrentThreadId()

Pobiera bieżący identyfikator wątku.Gets the current thread identifier.

GetData(String)

Pobiera wartość przechowywaną w bieżącej domenie aplikacji dla określonej nazwy.Gets the value stored in the current application domain for the specified name.

GetHashCode()

Służy jako domyślna funkcja skrótu.Serves as the default hash function.

(Odziedziczone po Object)
GetLifetimeService()

Pobiera bieżący obiekt usługi okresu istnienia, który kontroluje zasady okresu istnienia dla tego wystąpienia.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Odziedziczone po MarshalByRefObject)
GetType()

Pobiera typ bieżącego wystąpienia.Gets the type of the current instance.

InitializeLifetimeService()

Zapewnia AppDomain nieskończony okres istnienia, uniemożliwiając utworzenie dzierżawy.Gives the AppDomain an infinite lifetime by preventing a lease from being created.

IsCompatibilitySwitchSet(String)

Pobiera wartość logiczną null, która wskazuje, czy są ustawione wszystkie przełączniki zgodności, a jeśli tak, to czy ustawiony jest określony przełącznik zgodności.Gets a nullable Boolean value that indicates whether any compatibility switches are set, and if so, whether the specified compatibility switch is set.

IsDefaultAppDomain()

Zwraca wartość wskazującą, czy domena aplikacji jest domyślną domeną dla procesu.Returns a value that indicates whether the application domain is the default application domain for the process.

IsFinalizingForUnload()

Wskazuje, czy ta domena aplikacji jest wyładowywanie, a zawarte w niej obiekty są finalizowane przez środowisko uruchomieniowe języka wspólnego.Indicates whether this application domain is unloading, and the objects it contains are being finalized by the common language runtime.

Load(AssemblyName)

Ładuje Assembly z uwzględnieniem AssemblyName.Loads an Assembly given its AssemblyName.

Load(AssemblyName, Evidence)

Ładuje Assembly z uwzględnieniem AssemblyName.Loads an Assembly given its AssemblyName.

Load(Byte[])

Ładuje Assembly ze obrazem opartym na formacie Common Object Format (COFF) zawierającym emitowany Assembly.Loads the Assembly with a common object file format (COFF) based image containing an emitted Assembly.

Load(Byte[], Byte[])

Ładuje Assembly ze obrazem opartym na formacie Common Object Format (COFF) zawierającym emitowany Assembly.Loads the Assembly with a common object file format (COFF) based image containing an emitted Assembly. Są również ładowane nieprzetworzone bajty reprezentujące symbole dla Assembly.The raw bytes representing the symbols for the Assembly are also loaded.

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

Ładuje Assembly ze obrazem opartym na formacie Common Object Format (COFF) zawierającym emitowany Assembly.Loads the Assembly with a common object file format (COFF) based image containing an emitted Assembly. Są również ładowane nieprzetworzone bajty reprezentujące symbole dla Assembly.The raw bytes representing the symbols for the Assembly are also loaded.

Load(String)

Ładuje Assembly, uwzględniając jego nazwę wyświetlaną.Loads an Assembly given its display name.

Load(String, Evidence)

Ładuje Assembly, uwzględniając jego nazwę wyświetlaną.Loads an Assembly given its display name.

MemberwiseClone()

Tworzy skróconą kopię bieżącego Object.Creates a shallow copy of the current Object.

(Odziedziczone po Object)
MemberwiseClone(Boolean)

Tworzy skróconą kopię bieżącego obiektu MarshalByRefObject.Creates a shallow copy of the current MarshalByRefObject object.

(Odziedziczone po MarshalByRefObject)
ReflectionOnlyGetAssemblies()

Zwraca zestawy, które zostały załadowane do kontekstu przeznaczonego tylko do odbicia w domenie aplikacji.Returns the assemblies that have been loaded into the reflection-only context of the application domain.

SetAppDomainPolicy(PolicyLevel)

Ustanawia poziom zasad zabezpieczeń dla tej domeny aplikacji.Establishes the security policy level for this application domain.

SetCachePath(String)

Określa ścieżkę katalogu jako lokalizację, w której zestawy są kopiowane w tle.Establishes the specified directory path as the location where assemblies are shadow copied.

SetData(String, Object)

Przypisuje określoną wartość do określonej właściwości domeny aplikacji.Assigns the specified value to the specified application domain property.

SetData(String, Object, IPermission)

Przypisuje określoną wartość do określonej właściwości domeny aplikacji z określonym uprawnieniem do żądania obiektu wywołującego podczas pobierania właściwości.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)

Określa ścieżkę katalogu jako katalog podstawowy dla podkatalogów, w których są przechowywane i dostępne dynamicznie generowane pliki.Establishes the specified directory path as the base directory for subdirectories where dynamically generated files are stored and accessed.

SetPrincipalPolicy(PrincipalPolicy)

Określa, w jaki sposób obiekty Principal i Identity powinny być dołączone do wątku, jeśli wątek podejmie próbę powiązania z podmiotem zabezpieczeń podczas wykonywania w tej domenie aplikacji.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()

Włącza kopiowanie w tle.Turns on shadow copying.

SetShadowCopyPath(String)

Ustanawia określoną ścieżkę katalogu jako lokalizację zestawów do skopiowania w tle.Establishes the specified directory path as the location of assemblies to be shadow copied.

SetThreadPrincipal(IPrincipal)

Ustawia domyślny obiekt Principal do dołączenia do wątków, jeśli spróbuje powiązać się z podmiotem zabezpieczeń podczas wykonywania w tej domenie aplikacji.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()

Uzyskuje reprezentację w postaci ciągu, która zawiera przyjazną nazwę domeny aplikacji i wszystkie zasady kontekstowe.Obtains a string representation that includes the friendly name of the application domain and any context policies.

Unload(AppDomain)

Zwalnia określoną domenę aplikacji.Unloads the specified application domain.

Zdarzenia

AssemblyLoad

Występuje po załadowaniu zestawu.Occurs when an assembly is loaded.

AssemblyResolve

Występuje, gdy rozpoznanie zestawu zakończy się niepowodzeniem.Occurs when the resolution of an assembly fails.

DomainUnload

Występuje, gdy AppDomain zostanie zwolniona.Occurs when an AppDomain is about to be unloaded.

FirstChanceException

Występuje, gdy wyjątek jest zgłaszany w kodzie zarządzanym, zanim środowisko uruchomieniowe przeszuka stos wywołań dla programu obsługi wyjątków w domenie aplikacji.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

Występuje, gdy domyślny proces nadrzędny domeny aplikacji zostanie zakończony.Occurs when the default application domain's parent process exits.

ReflectionOnlyAssemblyResolve

Występuje, gdy rozpoznawanie zestawu zakończy się niepowodzeniem w kontekście tylko odbicia.Occurs when the resolution of an assembly fails in the reflection-only context.

ResourceResolve

Występuje, gdy rozpoznawanie zasobu nie powiedzie się, ponieważ zasób nie jest prawidłowym połączonym lub osadzonym zasobem w zestawie.Occurs when the resolution of a resource fails because the resource is not a valid linked or embedded resource in the assembly.

TypeResolve

Występuje, gdy rozpoznanie typu nie powiedzie się.Occurs when the resolution of a type fails.

UnhandledException

Występuje, gdy wyjątek nie zostanie przechwycony.Occurs when an exception is not caught.

Jawne implementacje interfejsu

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

Zestaw nazw jest mapowany na odpowiedni zestaw identyfikatorów wysyłania.Maps a set of names to a corresponding set of dispatch identifiers.

_AppDomain.GetTypeInfo(UInt32, UInt32, IntPtr)

Pobiera informacje o typie dla obiektu, których następnie można użyć do uzyskania informacji o typie interfejsu.Retrieves the type information for an object, which can then be used to get the type information for an interface.

_AppDomain.GetTypeInfoCount(UInt32)

Pobiera informację o liczbie typów interfejsów, jakie zawiera obiekt (0 lub 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)

Umożliwia dostęp do właściwości i metod udostępnianych przez obiekt.Provides access to properties and methods exposed by an object.

Dotyczy

Zobacz też