Activator Clase

Definición

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

Herencia

Object

Activator

Atributos

ClassInterfaceAttribute ComVisibleAttribute

Implementaciones

_Activator

Ejemplos

En el ejemplo siguiente se muestra cómo usar la Activator clase para construir objetos dinámicamente en tiempo de ejecución.

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

Comentarios

El CreateInstance método crea una instancia de un tipo definido en un ensamblado invocando el constructor que mejor coincide con los argumentos especificados. Si no se especifica ningún argumento, se invoca el constructor que no toma ningún parámetro, es decir, el constructor sin parámetros.

Debe tener permiso suficiente para buscar y llamar a un constructor; de lo contrario, se produce una excepción. De forma predeterminada, solo se tienen en cuenta los constructores públicos durante la búsqueda de un constructor. Si no se encuentra ningún constructor o constructor sin parámetros, se produce una excepción.

Un parámetro de enlazador especifica un objeto que busca un ensamblado para un constructor adecuado. Puede especificar su propio enlazador y criterios de búsqueda. Si no se especifica ningún enlazador, se usa un enlazador predeterminado. Para obtener más información, vea las clases System.Reflection.Binder y System.Reflection.BindingFlags.

Un parámetro de evidencia afecta a la directiva de seguridad y los permisos para el constructor. Para obtener más información, vea la clase System.Security.Policy.Evidence.

Se puede crear una instancia de un tipo en un sitio local o remoto. Si el tipo se crea de forma remota, un parámetro de atributo de activación especifica el URI del sitio remoto. La llamada para crear la instancia podría pasar por sitios intermedios antes de llegar al sitio remoto. Otros atributos de activación pueden modificar el entorno, o contexto, en el que la llamada funciona en los sitios remotos e intermedios.

Si la instancia se crea localmente, se devuelve una referencia a ese objeto. Si la instancia se crea de forma remota, se devuelve una referencia a un proxy. El objeto remoto se manipula a través del proxy como si fuera un objeto local.

El GetObject método crea un proxy en un objeto remoto actualmente en ejecución, un objeto conocido activado por el servidor o un servicio web XML. Puede especificar el medio de conexión, es decir, el canal. Para obtener más información, vea la clase System.Runtime.Remoting.Channels.ChannelServices.

Los ensamblados contienen definiciones de tipo. El CreateInstance método crea una instancia de un tipo a partir de un ensamblado que se está ejecutando actualmente. El CreateInstanceFrom método crea una instancia a partir de un archivo que contiene un ensamblado. El CreateComInstanceFrom método crea una instancia de un objeto COM a partir de un archivo que contiene un ensamblado.

Métodos

Implementaciones de interfaz explícitas

Se aplica a