Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

Type.GetTypeFromCLSID méthode (Guid, String, Boolean)

 

Date de publication : novembre 2016

Obtient le type associé à l'identificateur de classe (CLSID) spécifié à partir du serveur défini, indiquant s'il faut lever une exception en cas d'erreur pendant le chargement du type.

Espace de noms:   System
Assembly:  mscorlib (dans mscorlib.dll)

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

Paramètres

clsid
Type: System.Guid

CLSID du type à obtenir.

server
Type: System.String

Serveur à partir duquel le type doit être chargé. Si le nom de serveur est null, cette méthode revient automatiquement à la machine locale.

throwOnError
Type: System.Boolean

true pour lever toute exception qui se produit.

ou

false pour ignorer toute exception qui se produit.

Valeur de retour

Type: System.Type

System.__ComObject que le CLSID soit valide ou non.

Le GetTypeFromCLSID méthode prend en charge l’accès à liaison tardive aux objets COM non managés à partir d’applications .NET Framework lorsque vous connaissez l’identificateur de classe de l’objet COM (CLSID). L’identificateur de classe pour les classes COM est définie dans la clé HKEY_CLASSES_ROOT\CLSID du Registre. Vous pouvez récupérer la valeur de la IsCOMObject propriété pour déterminer si le type retourné par cette méthode est un objet COM.

System_CAPS_tipAstuce

Vous pouvez appeler la GetTypeFromProgID méthode pour l’accès à liaison tardive à COM d’objets dont identificateur programmatique (ProgID) que vous connaissez.

L’instanciation d’un objet COM non managé à partir de son CLSID est un processus en deux étapes :

  1. Obtenir un Type objet qui représente le __ComObject qui correspond au CLSID en appelant le GetTypeFromCLSID (méthode).

  2. Appelez le Activator.CreateInstance(Type) pour instancier l’objet COM (méthode).

Exceptions telles que OutOfMemoryException sera levée lors de la spécification true pour throwOnError, mais non CLSID n’échouera pas.

Remarques à l’attention des appelants :

Cette méthode est destinée à utiliser lorsque vous travaillez avec des objets COM, pas avec les objets .NET Framework. Tous les objets, y compris celles qui sont visibles par COM gérés (autrement dit, leurs ComVisibleAttribute attribut est true) ont un GUID qui est retourné par laGUIDpropriété. Bien que leGetTypeFromCLSIDméthode renvoie un Type objet qui correspond au GUID d’un objet managé particulier, vous ne pouvez pas utiliser Type objet pour créer une instance de type en appelant le Activator.CreateInstance méthode, comme le montre l’exemple suivant.

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)).

Au lieu de cela, la GetTypeFromCLSID doit uniquement être utilisé pour récupérer le GUID d’un objet COM non managé et résultantType objet qui est passé à la Activator.CreateInstanceméthode doit représenter un objet COM non managé.

L’exemple suivant utilise le CLSID de Microsoft Word Application object pour récupérer un type COM qui représente l’application Microsoft Word à partir d’un serveur nommé computer17.central.contoso.com. Elle instancie ensuite le type en appelant le Activator.CreateInstance (méthode) et se ferme en appelant le Application.Quit (méthode). Une exception est levée si une erreur se produit pendant le chargement du type.

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 depuis 1.1
Retour au début
Afficher: