AppDomain.CreateComInstanceFrom Método

Referencia

Definición

Espacio de nombres:: System

Ensamblado:: mscorlib.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Crea una nueva instancia de un tipo COM especificado.

Sobrecargas

CreateComInstanceFrom(String, String)	Crea una nueva instancia de un tipo COM especificado. Los parámetros especifican el nombre de un archivo que contiene un ensamblado con el tipo y el nombre del tipo.
CreateComInstanceFrom(String, String, Byte[], AssemblyHashAlgorithm)	Crea una nueva instancia de un tipo COM especificado. Los parámetros especifican el nombre de un archivo que contiene un ensamblado con el tipo y el nombre del tipo.

CreateComInstanceFrom(String, String)

Crea una nueva instancia de un tipo COM especificado. Los parámetros especifican el nombre de un archivo que contiene un ensamblado con el tipo y el nombre del tipo.

public:
 System::Runtime::Remoting::ObjectHandle ^ CreateComInstanceFrom(System::String ^ assemblyName, System::String ^ typeName);

public System.Runtime.Remoting.ObjectHandle CreateComInstanceFrom (string assemblyName, string typeName);

member this.CreateComInstanceFrom : string * string -> System.Runtime.Remoting.ObjectHandle

Public Function CreateComInstanceFrom (assemblyName As String, typeName As String) As ObjectHandle

Parámetros

assemblyName: String

Nombre de un archivo que contiene un ensamblado que define el tipo solicitado.

typeName: String

Nombre del tipo solicitado.

Devoluciones

ObjectHandle

Objeto contenedor de la nueva instancia especificada por typeName. El valor devuelto debe desempaquetarse para obtener acceso al objeto real.

Excepciones

ArgumentNullException

assemblyName o typeName es null.

TypeLoadException

No se puede cargar el tipo.

AppDomainUnloadedException

La operación se intenta en un dominio de aplicación descargado.

MissingMethodException

No se ha encontrado ningún constructor público sin parámetros.

FileNotFoundException

No se ha encontrado assemblyName.

MemberAccessException

typeName es una clase abstracta.

o bien

Este miembro se invocó con un mecanismo de enlace en tiempo de ejecución.

NotSupportedException

El llamador no puede ofrecer atributos de activación para un objeto que no hereda de MarshalByRefObject.

ArgumentException

assemblyName es una cadena vacía ("").

BadImageFormatException

assemblyName no es un ensamblado válido.

FileLoadException

Se cargó un ensamblado o módulo dos veces con dos evidencias diferentes.

NullReferenceException

El objeto COM al que se hace referencia es null.

Ejemplos

En el ejemplo siguiente se muestra

using namespace System;
using namespace System::Reflection;
using namespace System::Runtime::InteropServices;

[ComVisible(true)]
public ref class MyComVisibleType
{
public:
   MyComVisibleType()
   {
      Console::WriteLine( "MyComVisibleType instantiated!" );
   }

};


[ComVisible(false)]
public ref class MyComNonVisibleType
{
public:
   MyComNonVisibleType()
   {
      Console::WriteLine( "MyComNonVisibleType instantiated!" );
   }

};

void CreateComInstance( String^ typeName )
{
   try
   {
      AppDomain^ currentDomain = AppDomain::CurrentDomain;
      String^ assemblyName = currentDomain->FriendlyName;
      currentDomain->CreateComInstanceFrom( assemblyName, typeName );
   }
   catch ( Exception^ e ) 
   {
      Console::WriteLine( e->Message );
   }

}

int main()
{
   CreateComInstance( "MyComNonVisibleType" ); // Fail!
   CreateComInstance( "MyComVisibleType" ); // OK!
}

using System;
using System.Reflection;
using System.Runtime.InteropServices;

[ComVisible(true)]
class MyComVisibleType {
   public MyComVisibleType() {
      Console.WriteLine("MyComVisibleType instantiated!");
   }
}

[ComVisible(false)]
class MyComNonVisibleType {
   public MyComNonVisibleType() {
      Console.WriteLine("MyComNonVisibleType instantiated!");
   }
}

class Test {
   public static void Main() {
      CreateComInstance("MyComNonVisibleType");   // Fail!
      CreateComInstance("MyComVisibleType");      // OK!
   }

   static void CreateComInstance(string typeName) {
      try {
         AppDomain currentDomain = AppDomain.CurrentDomain;
         string assemblyName = currentDomain.FriendlyName;
         currentDomain.CreateComInstanceFrom(assemblyName, typeName);
      } catch (Exception e) {
         Console.WriteLine(e.Message);
      }
   }
}

open System
open System.Runtime.InteropServices

[<ComVisible true>]
type MyComVisibleType() =
    do
        printfn "MyComVisibleType instantiated!"

[<ComVisible false>]
type MyComNonVisibleType() =
    do
        printfn "MyComNonVisibleType instantiated!"

let createComInstance typeName =
    try
        let currentDomain = AppDomain.CurrentDomain
        let assemblyName = currentDomain.FriendlyName
        currentDomain.CreateComInstanceFrom(assemblyName, typeName)
        |> ignore
    with e ->
        printfn $"{e.Message}"

createComInstance "MyComNonVisibleType"   // Fail!
createComInstance "MyComVisibleType"      // OK!

Imports System.Reflection
Imports System.Runtime.InteropServices

<ComVisible(True)> _
Class MyComVisibleType

   Public Sub New()
      Console.WriteLine("MyComVisibleType instantiated!")
   End Sub

End Class

<ComVisible(False)> _
Class MyComNonVisibleType

   Public Sub New()
      Console.WriteLine("MyComNonVisibleType instantiated!")
   End Sub

End Class

Module Test

   Sub Main()
      CreateComInstance("MyComNonVisibleType")   ' Fail!
      CreateComInstance("MyComVisibleType")      ' OK!
   End Sub

   Sub CreateComInstance(typeName As String)
      Try
         Dim currentDomain As AppDomain = AppDomain.CurrentDomain
         Dim assemblyName As String = currentDomain.FriendlyName
         currentDomain.CreateComInstanceFrom(assemblyName, typeName)
      Catch e As Exception
         Console.WriteLine(e.Message)
      End Try
   End Sub

End Module 'Test

Comentarios

Use este método para crear objetos de forma remota sin tener que cargar el tipo localmente.

El valor devuelto debe desajustarse para tener acceso al objeto real.

Un System.Runtime.InteropServices.ComVisibleAttribute atributo con un valor de true debe aplicarse explícitamente o de forma predeterminada al tipo COM para que este método cree una instancia de ese tipo; de lo contrario, TypeLoadException se produce .

Consulte también

CreateComInstanceFrom(String, String)

Se aplica a

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

Crea una nueva instancia de un tipo COM especificado. Los parámetros especifican el nombre de un archivo que contiene un ensamblado con el tipo y el nombre del tipo.

public:
 System::Runtime::Remoting::ObjectHandle ^ CreateComInstanceFrom(System::String ^ assemblyFile, System::String ^ typeName, cli::array <System::Byte> ^ hashValue, System::Configuration::Assemblies::AssemblyHashAlgorithm hashAlgorithm);

public System.Runtime.Remoting.ObjectHandle CreateComInstanceFrom (string assemblyFile, string typeName, byte[] hashValue, System.Configuration.Assemblies.AssemblyHashAlgorithm hashAlgorithm);

member this.CreateComInstanceFrom : string * string * byte[] * System.Configuration.Assemblies.AssemblyHashAlgorithm -> System.Runtime.Remoting.ObjectHandle

Public Function CreateComInstanceFrom (assemblyFile As String, typeName As String, hashValue As Byte(), hashAlgorithm As AssemblyHashAlgorithm) As ObjectHandle