Informations
Le sujet que vous avez demandé est indiqué ci-dessous. Toutefois, ce sujet ne figure pas dans la bibliothèque.

AssemblyName.GetPublicKey, méthode

Mise à jour : novembre 2007

Obtient la clé publique de l'assembly.

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

public byte[] GetPublicKey()
public byte[] GetPublicKey()
public function GetPublicKey() : byte[]

Valeur de retour

Type : System.Byte[]

Tableau de type byte contenant la clé publique de l'assembly.

ExceptionCondition
SecurityException

Une clé publique a été fournie (par exemple, à l'aide de la méthode SetPublicKey), alors qu'aucun jeton de clé publique n'a été fourni.

L'exemple suivant émet un assembly dynamique et le sauvegarde dans le répertoire actif. Lorsque l'assembly est créé, la méthode SetPublicKey est utilisée pour donner une clé publique à l'assembly. Puis la méthode GetPublicKey est utilisée pour récupérer la clé publique, qui est affichée sur la console.


using System;
using System.Reflection;
using System.Threading;
using System.IO;
using System.Globalization;
using System.Reflection.Emit;
using System.Configuration.Assemblies;
using System.Text;

public class AssemblyName_CodeBase
{
   public static void MakeAssembly(AssemblyName myAssemblyName, string fileName)
   {
      // Get the assembly builder from the application domain associated with the current thread.
      AssemblyBuilder myAssemblyBuilder = Thread.GetDomain().DefineDynamicAssembly(myAssemblyName, AssemblyBuilderAccess.RunAndSave);
      // Create a dynamic module in the assembly.
      ModuleBuilder myModuleBuilder = myAssemblyBuilder.DefineDynamicModule("MyModule", fileName);
      // Create a type in the module.
      TypeBuilder myTypeBuilder = myModuleBuilder.DefineType("MyType");
      // Create a method called 'Main'.
      MethodBuilder myMethodBuilder = myTypeBuilder.DefineMethod("Main", MethodAttributes.Public | MethodAttributes.HideBySig |
         MethodAttributes.Static, typeof(void), null);
      // Get the Intermediate Language generator for the method.
      ILGenerator myILGenerator = myMethodBuilder.GetILGenerator();
      // Use the utility method to generate the IL instructions that print a string to the console.
      myILGenerator.EmitWriteLine("Hello World!");
      // Generate the 'ret' IL instruction.
      myILGenerator.Emit(OpCodes.Ret);
      // End the creation of the type.
      myTypeBuilder.CreateType();
      // Set the method with name 'Main' as the entry point in the assembly.
      myAssemblyBuilder.SetEntryPoint(myMethodBuilder);
      myAssemblyBuilder.Save(fileName);
   }

   public static void Main()
   {
      // Create a dynamic assembly with name 'MyAssembly' and build version '1.0.0.2001'.
      AssemblyName myAssemblyName = new AssemblyName();
      // Set the codebase to the physical directory were the assembly resides.
      myAssemblyName.CodeBase = Directory.GetCurrentDirectory();
      // Set the culture information of the assembly to 'English-American'.
      myAssemblyName.CultureInfo = new CultureInfo("en-US");
      // Set the hash algoritm to 'SHA1'.
      myAssemblyName.HashAlgorithm = AssemblyHashAlgorithm.SHA1;
      myAssemblyName.VersionCompatibility = AssemblyVersionCompatibility.SameProcess;
      myAssemblyName.Flags = AssemblyNameFlags.PublicKey;
      // Provide this assembly with a strong name.
      myAssemblyName.KeyPair = new StrongNameKeyPair(File.Open("KeyPair.snk", FileMode.Open, FileAccess.Read));
      myAssemblyName.Name = "MyAssembly";
      myAssemblyName.Version = new Version("1.0.0.2001");
      MakeAssembly(myAssemblyName, "MyAssembly.exe");

      // Get the assemblies loaded in the current application domain.
      Assembly[] myAssemblies = Thread.GetDomain().GetAssemblies();

      // Get the dynamic assembly named 'MyAssembly'. 
      Assembly myAssembly = null;
      for(int i = 0; i < myAssemblies.Length; i++)
         if(String.Compare(myAssemblies[i].GetName().Name, "MyAssembly") == 0)
            myAssembly = myAssemblies[i];

      // Display the full assembly information to the console.
      if(myAssembly != null)
      {
         Console.WriteLine("\nDisplaying the full assembly name.\n");
         Console.WriteLine(myAssembly.GetName().FullName);
         Console.WriteLine("\nDisplaying the public key.\n");
         byte []pk;
         pk = myAssembly.GetName().GetPublicKey();
 	 for (int i=0;i<pk.GetLength(0);i++)
 		Console.Write ("{0:x}", pk[i]);
         Console.WriteLine();
         Console.WriteLine("\nDisplaying the public key token.\n");
         byte []pt;
         pt = myAssembly.GetName().GetPublicKeyToken();
 	 for (int i=0;i<pt.GetLength(0);i++)
 		Console.Write ("{0:x}", pt[i]);
      }
   }
}


import System.*;
import System.Reflection.*;
import System.Threading.*;
import System.IO.*;
import System.Globalization.*;
import System.Reflection.Emit.*;
import System.Configuration.Assemblies.*;
import System.Text.*;

public class AssemblyNameCodeBase
{
    public static void MakeAssembly(AssemblyName myAssemblyName, 
        String fileName)
    {
        // Get the assembly builder from the application domain associated 
        // with the current thread.
        AssemblyBuilder myAssemblyBuilder = System.Threading.Thread.
            GetDomain().DefineDynamicAssembly(myAssemblyName, 
            AssemblyBuilderAccess.RunAndSave);

        // Create a dynamic module in the assembly.
        ModuleBuilder myModuleBuilder = myAssemblyBuilder.
            DefineDynamicModule("MyModule", fileName);

        // Create a type in the module.
        TypeBuilder myTypeBuilder = myModuleBuilder.DefineType("MyType");

        // Create a method called 'main'.
        MethodBuilder myMethodBuilder = myTypeBuilder.DefineMethod("main", 
            MethodAttributes.Public | MethodAttributes.HideBySig 
            | MethodAttributes.Static, void.class.ToType(), null);

        // Get the Intermediate Language generator for the method.
        ILGenerator myILGenerator = myMethodBuilder.GetILGenerator();

        // Use the utility method to generate the IL instructions 
        // that print a string to the console.
        myILGenerator.EmitWriteLine("Hello World!");

        // Generate the 'ret' IL instruction.
        myILGenerator.Emit(OpCodes.Ret);

        // End the creation of the type.
        myTypeBuilder.CreateType();

        // Set the method with name 'main' as the entry point in the assembly.
        myAssemblyBuilder.SetEntryPoint(myMethodBuilder);
        myAssemblyBuilder.Save(fileName);
    } //MakeAssembly

    public static void main(String[] args)
    {
        // Create a dynamic assembly with name 'MyAssembly' and 
        // build version '1.0.0.2001'.
        AssemblyName myAssemblyName = new AssemblyName();

        // Set the codebase to the physical directory were the assembly resides.
        myAssemblyName.set_CodeBase(Directory.GetCurrentDirectory());

        // Set the culture information of the assembly to 'English-American'.
        myAssemblyName.set_CultureInfo(new CultureInfo("en-US"));

        // Set the hash algoritm to 'SHA1'.
        myAssemblyName.set_HashAlgorithm(AssemblyHashAlgorithm.SHA1);
        myAssemblyName.set_VersionCompatibility(
            AssemblyVersionCompatibility.SameProcess);
        myAssemblyName.set_Flags(AssemblyNameFlags.PublicKey);

        // Provide this assembly with a strong name.
        myAssemblyName.set_KeyPair(new StrongNameKeyPair(File.Open(
            "KeyPair.snk", FileMode.Open, FileAccess.Read)));
        myAssemblyName.set_Name("MyAssembly");
        myAssemblyName.set_Version(new Version("1.0.0.2001"));
        MakeAssembly(myAssemblyName, "MyAssembly.exe");

        // Get the assemblies loaded in the current application domain.
        Assembly myAssemblies[] = System.Threading.Thread.GetDomain().
            GetAssemblies();

        // Get the dynamic assembly named 'MyAssembly'. 
        Assembly myAssembly = null;
        for (int i = 0; i < myAssemblies.length; i++) {
            if (String.Compare(((Assembly)myAssemblies.get_Item(i)).GetName().
                get_Name(), "MyAssembly") == 0) {

                myAssembly = (Assembly)myAssemblies.get_Item(i);
            }
        }

        // Display the full assembly information to the console.
        if (myAssembly != null) {
            Console.WriteLine("\nDisplaying the full assembly name.\n");
            Console.WriteLine(myAssembly.GetName().get_FullName());
            Console.WriteLine("\nDisplaying the public key.\n");

            ubyte pk[];
            pk = myAssembly.GetName().GetPublicKey();
            for (int i = 0; i < pk.GetLength(0); i++) {
                Console.Write("{0:x}", pk.get_Item(i));
            }

            Console.WriteLine();
            Console.WriteLine("\nDisplaying the public key token.\n");

            ubyte pt[];
            pt = myAssembly.GetName().GetPublicKeyToken();
            for (int i = 0; i < pt.GetLength(0); i++) {
                Console.Write("{0:x}", pt.get_Item(i));
            }
        }
    } //main
} //AssemblyNameCodeBase


Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professionnel Édition x64, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile pour Smartphone, Windows Mobile pour Pocket PC, Xbox 360

Le .NET Framework et le .NET Compact Framework ne prennent pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

.NET Framework

Pris en charge dans : 3.5, 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Pris en charge dans : 3.5, 2.0, 1.0

XNA Framework

Pris en charge dans : 2.0, 1.0

Ajouts de la communauté

Afficher:
© 2014 Microsoft