AppDomainSetup.AppDomainInitializerArguments Propriedade

Definição

Obtém ou define os argumentos passados para o método de retorno de chamada representado pelo delegado AppDomainInitializer. O método de retorno de chamada é invocado quando o domínio do aplicativo é inicializado.

public:
 property cli::array <System::String ^> ^ AppDomainInitializerArguments { cli::array <System::String ^> ^ get(); void set(cli::array <System::String ^> ^ value); };
public string[] AppDomainInitializerArguments { get; set; }
member this.AppDomainInitializerArguments : string[] with get, set
Public Property AppDomainInitializerArguments As String()

Valor da propriedade

String[]

Uma matriz de cadeias de caracteres que é passada para o método de retorno de chamada representado pelo delegado AppDomainInitializer quando o método de retorno de chamada é invocado durante a inicialização de AppDomain.

Exemplos

O exemplo de código a seguir cria um domínio de aplicativo filho chamado ChildDomain, usando um AppDomainSetup objeto e uma evidência do domínio de aplicativo padrão. A AppDomainInitializer propriedade é definida como o método AppDomainInitde retorno de chamada, que é invocado quando o domínio filho é inicializado. Os argumentos para o método de retorno de chamada são colocados em uma matriz de cadeias de caracteres, que é atribuída à AppDomainInitializerArguments propriedade. Quando o domínio filho é criado, o método de retorno de chamada simplesmente imprime as cadeias de caracteres.

using namespace System;
using namespace System::Security::Policy;

public ref class AppDomainInitializerExample
{
    // The callback method invoked when the child application domain is
    // initialized. The method simply displays the arguments that were
    // passed to it.
    //
public:
    static void AppDomainInit(array<String^>^ args)
    {
        Console::WriteLine("AppDomain \"{0}\" is initialized with these " +
            "arguments:", AppDomain::CurrentDomain->FriendlyName);
        for each (String^ arg in args)
        {
            Console::WriteLine("    {0}", arg);
        }
    }
};

int main()
{
    // Get a reference to the default application domain.
    //
    AppDomain^ currentDomain = AppDomain::CurrentDomain;
    
    // Create the AppDomainSetup that will be used to set up the child
    // AppDomain.
    AppDomainSetup^ domainSetup = gcnew AppDomainSetup();

    // Use the evidence from the default application domain to
    // create evidence for the child application domain.
    //
    Evidence^ evidence = gcnew Evidence(currentDomain->Evidence);

    // Create an AppDomainInitializer delegate that represents the
    // callback method, AppDomainInit. Assign this delegate to the
    // AppDomainInitializer property of the AppDomainSetup object.
    //
    AppDomainInitializer^ domainInitializer =
        gcnew AppDomainInitializer(AppDomainInitializerExample::AppDomainInit);
    domainSetup->AppDomainInitializer = domainInitializer;

    // Create an array of strings to pass as arguments to the callback
    // method. Assign the array to the AppDomainInitializerArguments
    // property.
    array<String^>^ initialArguments = {"String1", "String2"};
    domainSetup->AppDomainInitializerArguments = initialArguments;

    // Create a child application domain named "ChildDomain", using
    // the evidence and the AppDomainSetup object.
    //
    AppDomain^ appDomain = AppDomain::CreateDomain("ChildDomain",
        evidence, domainSetup);

    Console::WriteLine("Press the Enter key to exit the example program.");
    Console::ReadLine();
}

/* This code example produces the following output:

AppDomain "ChildDomain" is initialized with these arguments:
String1
String2
*/
using System;
using System.Security.Policy;

public class Example
{
    public static void Main()
    {
        // Get a reference to the default application domain.
        //
        AppDomain current = AppDomain.CurrentDomain;

        // Create the AppDomainSetup that will be used to set up the child
        // AppDomain.
        AppDomainSetup ads = new AppDomainSetup();

        // Use the evidence from the default application domain to
        // create evidence for the child application domain.
        //
        Evidence ev = new Evidence(current.Evidence);

        // Create an AppDomainInitializer delegate that represents the
        // callback method, AppDomainInit. Assign this delegate to the
        // AppDomainInitializer property of the AppDomainSetup object.
        //
        AppDomainInitializer adi = new AppDomainInitializer(AppDomainInit);
        ads.AppDomainInitializer = adi;

        // Create an array of strings to pass as arguments to the callback
        // method. Assign the array to the AppDomainInitializerArguments
        // property.
        string[] initArgs = {"String1", "String2"};
        ads.AppDomainInitializerArguments = initArgs;

        // Create a child application domain named "ChildDomain", using
        // the evidence and the AppDomainSetup object.
        //
        AppDomain ad = AppDomain.CreateDomain("ChildDomain", ev, ads);

        Console.WriteLine("Press the Enter key to exit the example program.");
        Console.ReadLine();
    }

    // The callback method invoked when the child application domain is
    // initialized. The method simply displays the arguments that were
    // passed to it.
    //
    public static void AppDomainInit(string[] args)
    {
        Console.WriteLine("AppDomain \"{0}\" is initialized with these arguments:",
            AppDomain.CurrentDomain.FriendlyName);
        foreach (string arg in args)
        {
            Console.WriteLine("    {0}", arg);
        }
    }
}

/* This code example produces the following output:

AppDomain "ChildDomain" is initialized with these arguments:
    String1
    String2
 */
open System
open System.Security.Policy

// Get a reference to the default application domain.
let current = AppDomain.CurrentDomain

// Create the AppDomainSetup that will be used to set up the child
// AppDomain.
let ads = AppDomainSetup()

// Use the evidence from the default application domain to
// create evidence for the child application domain.
let ev = Evidence current.Evidence

// The callback function invoked when the child application domain is
// initialized. The function simply displays the arguments that were
// passed to it.
let appDomainInit args =
    printfn $"AppDomain \"{AppDomain.CurrentDomain.FriendlyName}\" is initialized with these arguments:"
    for arg in args do
        printfn $"    {arg}"

// Create an AppDomainInitializer delegate that represents the
// callback method, AppDomainInit. Assign this delegate to the
// AppDomainInitializer property of the AppDomainSetup object.
let adi = AppDomainInitializer appDomainInit
ads.AppDomainInitializer <- adi

// Create an array of strings to pass as arguments to the callback
// method. Assign the array to the AppDomainInitializerArguments
// property.
let initArgs = [| "String1"; "String2" |]
ads.AppDomainInitializerArguments <- initArgs

// Create a child application domain named "ChildDomain", using
// the evidence and the AppDomainSetup object.
let ad = AppDomain.CreateDomain("ChildDomain", ev, ads)

printfn "Press the Enter key to exit the example program."
stdin.ReadLine() |> ignore

(* This code example produces the following output:

AppDomain "ChildDomain" is initialized with these arguments:
    String1
    String2
 *)
Imports System.Security.Policy

Public Class Example

    Public Shared Sub Main()

        ' Get a reference to the default application domain.
        '
        Dim current As AppDomain = AppDomain.CurrentDomain

        ' Create the AppDomainSetup that will be used to set up the child
        ' AppDomain.
        Dim ads As New AppDomainSetup()

        ' Use the evidence from the default application domain to
        ' create evidence for the child application domain.
        '
        Dim ev As Evidence = New Evidence(current.Evidence)

        ' Create an AppDomainInitializer delegate that represents the 
        ' callback method, AppDomainInit. Assign this delegate to the
        ' AppDomainInitializer property of the AppDomainSetup object.
        '
        Dim adi As New AppDomainInitializer(AddressOf AppDomainInit)
        ads.AppDomainInitializer = adi

        ' Create an array of strings to pass as arguments to the callback
        ' method. Assign the array to the AppDomainInitializerArguments
        ' property.
        Dim initArgs() As String = {"String1", "String2"}
        ads.AppDomainInitializerArguments = initArgs

        ' Create a child application domain named "ChildDomain", using 
        ' the evidence and the AppDomainSetup object.
        '
        Dim ad As AppDomain = _
            AppDomain.CreateDomain("ChildDomain", ev, ads)

        Console.WriteLine("Press the Enter key to exit the example program.")
        Console.ReadLine()
    End Sub

    ' The callback method invoked when the child application domain is
    ' initialized. The method simply displays the arguments that were
    ' passed to it.
    '
    Public Shared Sub AppDomainInit(ByVal args() As String)
        Console.WriteLine("AppDomain ""{0}"" is initialized with these arguments:", _
            AppDomain.CurrentDomain.FriendlyName)
        For Each arg As String In args
            Console.WriteLine("    {0}", arg)
        Next
    End Sub
End Class

' This code example produces the following output:
'
'AppDomain "ChildDomain" is initialized with these arguments:
'    String1
'    String2

Comentários

Use a AppDomainInitializer propriedade para especificar um método de retorno de chamada que é invocado durante AppDomain a inicialização. Se a AppDomainInitializer propriedade não estiver definida, a matriz atribuída a essa propriedade não será usada.

O método de retorno de chamada é executado no contexto do domínio do aplicativo recém-criado.

Aplica-se a

Confira também