Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Método Type.GetTypeFromCLSID (Guid, String, Boolean)

 

Publicado: octubre de 2016

Obtiene el tipo asociado al identificador de clase (CLSID) indicado desde el servidor especificado y debe indicarse si se producirá una excepción en caso de que se produzca un error al cargar el tipo.

Espacio de nombres:   System
Ensamblado:  mscorlib (en mscorlib.dll)

public static Type GetTypeFromCLSID(
	Guid clsid,
	string server,
	bool throwOnError
)

Parámetros

clsid
Type: System.Guid

Identificador CLSID del tipo que se va a obtener.

server
Type: System.String

Servidor desde el que se va a cargar el tipo. Si el nombre de servidor es null, el resultado que el método devuelve automáticamente es el equipo local.

throwOnError
Type: System.Boolean

true para producir cualquier excepción que se genere.

O bien

false para pasar por alto cualquier excepción que se produzca.

Valor devuelto

Type: System.Type

System.__ComObject independientemente de que CLSID sea válido.

El GetTypeFromCLSID método es compatible con acceso en tiempo de ejecución a objetos COM no administrados de aplicaciones de .NET Framework cuando conoce el identificador de clase del objeto COM (CLSID). El identificador de clase para las clases COM se define en la clave HKEY_CLASSES_ROOT\CLSID del registro. Puede recuperar el valor de la IsCOMObject propiedad para determinar si el tipo devuelto por este método es un objeto COM.

System_CAPS_tipSugerencia

Puede llamar a la GetTypeFromProgID método enlazado tardíamente acceso a COM objetos cuyo identificador de programación (ProgID) sabe.

Crear instancias de un objeto COM no administrado desde su CLSID es un proceso de dos pasos:

  1. Obtener un Type objeto que representa la __ComObject que corresponde al CLSID llamando el GetTypeFromCLSID método.

  2. Llame a la Activator.CreateInstance(Type) método para crear una instancia del objeto COM.

Excepciones como OutOfMemoryException se producirá cuando se especifica true para throwOnError, pero no se producirá ningún error para identificadores CLSID no registrados.

Notas para llamadores:

Este método está pensado para su uso cuando se trabaja con objetos COM, no a los objetos de .NET Framework. Todos los objetos administrados, los que son visibles para COM incluidos (es decir, sus ComVisibleAttribute atributo es true) tiene un GUID que es devuelto por elGUIDpropiedad. Aunque elGetTypeFromCLSIDmétodo devuelve un Type objeto que corresponde al GUID de un objeto administrado concreto, no puede usar dicha Type objeto para crear una instancia de tipo llamando el Activator.CreateInstance método, como se muestra en el ejemplo siguiente.

using System;
using System.Runtime.InteropServices;

[assembly:ComVisible(true)]

// Define two classes, and assign one an explicit GUID.
[GuidAttribute("d055cba3-1f83-4bd7-ba19-e22b1b8ec3c4")]
public class ExplicitGuid
{ }

public class NoExplicitGuid
{ }

public class Example
{
   public static void Main()
   {
      Type explicitType = typeof(ExplicitGuid);
      Guid explicitGuid = explicitType.GUID;

      // Get type of ExplicitGuid from its GUID.
      Type explicitCOM = Type.GetTypeFromCLSID(explicitGuid);
      Console.WriteLine("Created {0} type from CLSID {1}",
                        explicitCOM.Name, explicitGuid);

      // Compare the two type objects.
      Console.WriteLine("{0} and {1} equal: {2}",
                        explicitType.Name, explicitCOM.Name,
                        explicitType.Equals(explicitCOM));                  

      // Instantiate an ExplicitGuid object.
      try {
         Object obj = Activator.CreateInstance(explicitCOM);
         Console.WriteLine("Instantiated a {0} object", obj.GetType().Name);
      } 
      catch (COMException e) {
         Console.WriteLine("COM Exception:\n{0}\n", e.Message);   
      } 

      Type notExplicit = typeof(NoExplicitGuid);
      Guid notExplicitGuid = notExplicit.GUID;

      // Get type of ExplicitGuid from its GUID.
      Type notExplicitCOM = Type.GetTypeFromCLSID(notExplicitGuid);
      Console.WriteLine("Created {0} type from CLSID {1}",
                        notExplicitCOM.Name, notExplicitGuid);

      // Compare the two type objects.
      Console.WriteLine("{0} and {1} equal: {2}",
                        notExplicit.Name, notExplicitCOM.Name,
                        notExplicit.Equals(notExplicitCOM));                  

      // Instantiate an ExplicitGuid object.
      try {
         Object obj = Activator.CreateInstance(notExplicitCOM);
         Console.WriteLine("Instantiated a {0} object", obj.GetType().Name);
      } 
      catch (COMException e) {
         Console.WriteLine("COM Exception:\n{0}\n", e.Message);   
      }   
   }
}
// The example displays the following output:
//       Created __ComObject type from CLSID d055cba3-1f83-4bd7-ba19-e22b1b8ec3c4
//       ExplicitGuid and __ComObject equal: False
//       COM Exception:
//       Retrieving the COM class factory for component with CLSID 
//       {D055CBA3-1F83-4BD7-BA19-E22B1B8EC3C4} failed due to the following error: 
//       80040154 Class not registered 
//       (Exception from HRESULT: 0x80040154 (REGDB_E_CLASSNOTREG)).
//       
//       Created __ComObject type from CLSID 74f03346-a718-3516-ac78-f351c7459ffb
//       NoExplicitGuid and __ComObject equal: False
//       COM Exception:
//       Retrieving the COM class factory for component with CLSID 
//       {74F03346-A718-3516-AC78-F351C7459FFB} failed due to the following error: 
//       80040154 Class not registered 
//       (Exception from HRESULT: 0x80040154 (REGDB_E_CLASSNOTREG)).

En su lugar, el GetTypeFromCLSID sólo debe usarse para recuperar el GUID de un objeto COM no administrado y resultanteType objeto que se pasa a la Activator.CreateInstanceel método debe representar un objeto COM no administrado.

En el ejemplo siguiente se usa el CLSID de Microsoft Word Application object para recuperar un tipo COM que representa la aplicación Microsoft Word desde un servidor llamado computer17.central.contoso.com. A continuación, crea una instancia del tipo llamando el Activator.CreateInstance método y se cierra llamando el Application.Quit (método). Se produce una excepción si se produce un error al cargar el tipo.

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

public class Example
{
   private const string WORD_CLSID = "{000209FF-0000-0000-C000-000000000046}";

   public static void Main()
   {
      try {
         // Start an instance of the Word application.
         var word = Type.GetTypeFromCLSID(Guid.Parse(WORD_CLSID), 
                                          "computer17.central.contoso.com",
                                          true);
         Console.WriteLine("Instantiated Type object from CLSID {0}",
                           WORD_CLSID);
         Object wordObj = Activator.CreateInstance(word);
         Console.WriteLine("Instantiated {0}", 
                           wordObj.GetType().FullName, WORD_CLSID);

         // Close Word.
         word.InvokeMember("Quit", BindingFlags.InvokeMethod, null, 
                           wordObj, new object[] { 0, 0, false } );
      }
      // The method can throw any of a variety of exceptions.
      catch (Exception e) {
         Console.WriteLine("{0}: Unable to instantiate an object for {1}", 
                           e.GetType().Name, WORD_CLSID);
      }      
   }
}
// The example displays the following output:
//    Instantiated Type object from CLSID {000209FF-0000-0000-C000-000000000046}
//    Instantiated Microsoft.Office.Interop.Word.ApplicationClass

.NET Framework
Disponible desde 1.1
Volver al principio
Mostrar: