Activator Classe

Definizione

public ref class Activator abstract sealed

public ref class Activator sealed : System::Runtime::InteropServices::_Activator

public static class Activator

[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
public sealed class Activator : System.Runtime.InteropServices._Activator

[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class Activator : System.Runtime.InteropServices._Activator

type Activator = class

[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
type Activator = class
    interface _Activator

[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Activator = class
    interface _Activator

Public Class Activator

Public NotInheritable Class Activator
Implements _Activator

Ereditarietà

Object

Activator

Attributi

ClassInterfaceAttribute ComVisibleAttribute

Implementazioni

_Activator

Esempio

Nell'esempio seguente viene illustrato come usare la Activator classe per costruire oggetti in modo dinamico in fase di esecuzione.

using namespace System;
using namespace System::Reflection;
using namespace System::Text;

public ref class SomeType
{
public:
    void DoSomething(int x)
    {
        Console::WriteLine("100 / {0} = {1}", x, 100 / x);
    }
};

void main()
{
    // Create an instance of the StringBuilder type using 
    // Activator.CreateInstance.
    Object^ o = Activator::CreateInstance(StringBuilder::typeid);

    // Append a string into the StringBuilder object and display the 
    // StringBuilder.
    StringBuilder^ sb = (StringBuilder^) o;
    sb->Append("Hello, there.");
    Console::WriteLine(sb);

    // Create an instance of the SomeType class that is defined in this 
    // assembly.
    System::Runtime::Remoting::ObjectHandle^ oh = 
        Activator::CreateInstanceFrom(Assembly::GetEntryAssembly()->CodeBase, 
                                      SomeType::typeid->FullName);

    // Call an instance method defined by the SomeType type using this object.
    SomeType^ st = (SomeType^) oh->Unwrap();

    st->DoSomething(5);
};

/* This code produces the following output:
 
Hello, there.
100 / 5 = 20
 */

using System;
using System.Reflection;
using System.Text;

public class SomeType
{
    public void DoSomething(int x)
    {
        Console.WriteLine("100 / {0} = {1}", x, 100 / x);
    }
}

public class Example
{
    static void Main()
    {
        // Create an instance of the StringBuilder type using
        // Activator.CreateInstance.
        Object o = Activator.CreateInstance(typeof(StringBuilder));

        // Append a string into the StringBuilder object and display the
        // StringBuilder.
        StringBuilder sb = (StringBuilder) o;
        sb.Append("Hello, there.");
        Console.WriteLine(sb);

        // Create an instance of the SomeType class that is defined in this
        // assembly.
        System.Runtime.Remoting.ObjectHandle oh =
            Activator.CreateInstanceFrom(Assembly.GetEntryAssembly().CodeBase,
                                         typeof(SomeType).FullName);

        // Call an instance method defined by the SomeType type using this object.
        SomeType st = (SomeType) oh.Unwrap();

        st.DoSomething(5);
    }
}

/* This code produces the following output:

Hello, there.
100 / 5 = 20
 */

open System
open System.Reflection
open System.Text

type SomeType() =
    member _.DoSomething(x) = printfn $"100 / {x} = {100 / x}"

// Create an instance of the StringBuilder type using Activator.CreateInstance.
let o = Activator.CreateInstance typeof<StringBuilder>

// Append a string into the StringBuilder object and display the StringBuilder.
let sb = o :?> StringBuilder
sb.Append "Hello, there." |> ignore
printfn $"{sb}"

// Create an instance of the SomeType class that is defined in this assembly.
let oh = 
    Activator.CreateInstanceFrom(Assembly.GetEntryAssembly().Location, typeof<SomeType>.FullName)

// Call an instance method defined by the SomeType type using this object.
let st = oh.Unwrap() :?> SomeType

st.DoSomething 5

(* This code produces the following output:

Hello, there.
100 / 5 = 20
 *)

Imports System.Reflection
Imports System.Text

Module Module1
    Sub Main()
        ' Create an instance of the StringBuilder type using 
        ' Activator.CreateInstance.
        Dim o As Object = Activator.CreateInstance(GetType(StringBuilder))

        ' Append a string into the StringBuilder object and display the 
        ' StringBuilder.
        Dim sb As StringBuilder = CType(o, StringBuilder)
        sb.Append("Hello, there.")
        Console.WriteLine(sb)

        ' Create an instance of the SomeType class that is defined in this assembly.
        Dim oh As System.Runtime.Remoting.ObjectHandle = _
            Activator.CreateInstanceFrom(Assembly.GetEntryAssembly().CodeBase, _
                                         GetType(SomeType).FullName)

        ' Call an instance method defined by the SomeType type using this object.
        Dim st As SomeType = CType(oh.Unwrap(), SomeType)

        st.DoSomething(5)
    End Sub

    Class SomeType
        Public Sub DoSomething(ByVal x As Int32)
            Console.WriteLine("100 / {0} = {1}", x, 100 \ x)
        End Sub
    End Class
End Module

' This code produces the following output:
' 
' Hello, there.
' 100 / 5 = 20

Commenti

Il CreateInstance metodo crea un'istanza di un tipo definito in un assembly richiamando il costruttore che corrisponde meglio agli argomenti specificati. Se non vengono specificati argomenti, viene richiamato il costruttore che non accetta parametri, ovvero il costruttore senza parametri.

È necessario disporre di autorizzazioni sufficienti per cercare e chiamare un costruttore; in caso contrario, viene generata un'eccezione. Per impostazione predefinita, solo i costruttori pubblici vengono considerati durante la ricerca di un costruttore. Se non è possibile trovare un costruttore o un costruttore senza parametri, viene generata un'eccezione.

Un parametro del binder specifica un oggetto che cerca un assembly per un costruttore appropriato. È possibile specificare i propri criteri di associazione e ricerca. Se non viene specificato alcun binder, viene usato un bindinger predefinito. Per altre informazioni, vedere le classi System.Reflection.Binder e System.Reflection.BindingFlags.

Un parametro di prova influisce sui criteri di sicurezza e sulle autorizzazioni per il costruttore. Per altre informazioni, vedere la classe System.Security.Policy.Evidence.

È possibile creare un'istanza di un tipo in un sito locale o remoto. Se il tipo viene creato in remoto, un parametro dell'attributo di attivazione specifica l'URI del sito remoto. La chiamata per creare l'istanza potrebbe passare attraverso siti intermedi prima di raggiungere il sito remoto. Altri attributi di attivazione possono modificare l'ambiente o il contesto in cui la chiamata opera nei siti remoti e intermedi.

Se l'istanza viene creata in locale, viene restituito un riferimento a tale oggetto. Se l'istanza viene creata in remoto, viene restituito un riferimento a un proxy. L'oggetto remoto viene modificato tramite il proxy come se fosse un oggetto locale.

Il GetObject metodo crea un proxy a un oggetto remoto attualmente in esecuzione, a un oggetto noto con attivazione server o a un servizio Web XML. È possibile specificare il supporto di connessione, ovvero il canale. Per altre informazioni, vedere la classe System.Runtime.Remoting.Channels.ChannelServices.

Gli assembly contengono definizioni di tipo. Il CreateInstance metodo crea un'istanza di un tipo da un assembly attualmente in esecuzione. Il metodo crea un'istanza CreateInstanceFrom da un file che contiene un assembly. Il CreateComInstanceFrom metodo crea un'istanza di un oggetto COM da un file che contiene un assembly.

Metodi

Implementazioni dell'interfaccia esplicita

Si applica a