Activator Classe

Definizione

Spazio dei nomi:

System

Assembly:

System.Runtime.dll

Origine:

Activator.cs

Contiene metodi per creare tipi di oggetti, localmente o in remoto, oppure per ottenere riferimenti a oggetti remoti esistenti. La classe non può essere ereditata.

public ref class Activator abstract sealed

public static class Activator

type Activator = class

Public Class Activator

Ereditarietà

Object

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

CreateInstance(String, String)	Crea un'istanza del tipo il cui nome è specificato, usando l'assembly denominato e il costruttore senza parametri.
CreateInstance(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[])	Crea un'istanza del tipo il cui nome è specificato, usando l'assembly denominato e il costruttore più adatto ai parametri specificati.
CreateInstance(String, String, Object[])	Crea un'istanza del tipo il cui nome è specificato, usando l'assembly denominato e il costruttore senza parametri.
CreateInstance(Type)	Crea un'istanza del tipo specificato usando il costruttore senza parametri di tale tipo.
CreateInstance(Type, BindingFlags, Binder, Object[], CultureInfo)	Crea un'istanza del tipo specificato utilizzando il costruttore che corrisponde maggiormente ai parametri specificati.
CreateInstance(Type, BindingFlags, Binder, Object[], CultureInfo, Object[])	Crea un'istanza del tipo specificato utilizzando il costruttore che corrisponde maggiormente ai parametri specificati.
CreateInstance(Type, Boolean)	Crea un'istanza del tipo specificato usando il costruttore senza parametri di tale tipo.
CreateInstance(Type, Object[])	Crea un'istanza del tipo specificato utilizzando il costruttore che corrisponde maggiormente ai parametri specificati.
CreateInstance(Type, Object[], Object[])	Crea un'istanza del tipo specificato utilizzando il costruttore che corrisponde maggiormente ai parametri specificati.
CreateInstance<T>()	Crea un'istanza del tipo designato dal parametro del tipo generico specificato, usando il costruttore senza parametri.
CreateInstanceFrom(String, String)	Crea un'istanza del tipo il cui nome è specificato, usando il file di assembly denominato e il costruttore senza parametri.
CreateInstanceFrom(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[])	Crea un'istanza del tipo il cui nome è specificato, usando il file di assembly denominato e il costruttore più adatto ai parametri specificati.
CreateInstanceFrom(String, String, Object[])	Crea un'istanza del tipo il cui nome è specificato, usando il file di assembly denominato e il costruttore senza parametri.