Share via

AssemblyName.KeyPair-Eigenschaft

  • Artikel

Ruft das vom öffentlichen Schlüssel oder vom Token des öffentlichen Schlüssels der Assembly generierte kryptografische Schlüsselpaar, bestehend aus öffentlichem und privatem Schlüssel, ab oder legt dieses fest.

Namespace: System.Reflection
Assembly: mscorlib (in mscorlib.dll)

Syntax

'Declaration
Public Property KeyPair As StrongNameKeyPair
'Usage
Dim instance As AssemblyName
Dim value As StrongNameKeyPair

value = instance.KeyPair

instance.KeyPair = value

public StrongNameKeyPair KeyPair { get; set; }

public:
property StrongNameKeyPair^ KeyPair {
    StrongNameKeyPair^ get ();
    void set (StrongNameKeyPair^ value);
}

/** @property */
public StrongNameKeyPair get_KeyPair ()

/** @property */
public void set_KeyPair (StrongNameKeyPair value)

public function get KeyPair () : StrongNameKeyPair

public function set KeyPair (value : StrongNameKeyPair)

Eigenschaftenwert

Ein StrongNameKeyPair-Objekt mit dem kryptografischen Schlüsselpaar, bestehend aus öffentlichem und privatem Schlüssel, das vom öffentlichen Schlüssel oder dem Token des öffentlichen Schlüssels der Assembly generiert wurde.

Hinweise

Beim Laden einer Assembly durch die Laufzeit wird die AssemblyName.KeyPair-Eigenschaft nicht festgelegt. Die Get-Methode der Eigenschaft ist nur dann nützlich, wenn der Benutzer die Eigenschaft nach dem Laden der Assembly festgelegt hat und anschließend abrufen möchte.

Beispiel

Imports System
Imports System.Reflection
Imports System.Threading
Imports System.IO
Imports System.Globalization
Imports System.Reflection.Emit
Imports System.Configuration.Assemblies
Imports System.Text
Imports Microsoft.VisualBasic


Public Class AssemblyName_CodeBase
   
   Public Shared Sub MakeAssembly(myAssemblyName As AssemblyName, fileName As String)
      ' Get the assembly builder from the application domain associated with the current thread.
      Dim myAssemblyBuilder As AssemblyBuilder = Thread.GetDomain().DefineDynamicAssembly(myAssemblyName, AssemblyBuilderAccess.RunAndSave)
      ' Create a dynamic module in the assembly.
      Dim myModuleBuilder As ModuleBuilder = myAssemblyBuilder.DefineDynamicModule("MyModule", fileName)
      ' Create a type in the module.
      Dim myTypeBuilder As TypeBuilder = myModuleBuilder.DefineType("MyType")
      ' Create a method called 'Main'.
      Dim myMethodBuilder As MethodBuilder = myTypeBuilder.DefineMethod("Main", MethodAttributes.Public Or MethodAttributes.HideBySig Or MethodAttributes.Static, GetType(object), Nothing)
      ' Get the Intermediate Language generator for the method.
      Dim myILGenerator As ILGenerator = 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)
   End Sub 'MakeAssembly
   
   
   Public Shared Sub Main()
      

      ' Create a dynamic assembly with name 'MyAssembly' and build version '1.0.0.2001'.
      Dim myAssemblyName As New AssemblyName()
      ' Set the codebase to the physical directory were the assembly resides.
      myAssemblyName.CodeBase = [String].Concat("file:///", 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.
      Dim myAssemblies As [Assembly]() = Thread.GetDomain().GetAssemblies()
      
      ' Get the dynamic assembly named 'MyAssembly'. 
      Dim myAssembly As [Assembly] = Nothing
      Dim i As Integer
      For i = 0 To myAssemblies.Length - 1
         If [String].Compare(myAssemblies(i).GetName().Name, "MyAssembly") = 0 Then
            myAssembly = myAssemblies(i)
         End If 
      Next i ' Display the full assembly information to the console.
      If Not (myAssembly Is Nothing) Then
      Console.WriteLine(ControlChars.CrLf +"Displaying the full assembly name."+ ControlChars.CrLf)
      Console.WriteLine(myAssembly.GetName().FullName)
      Console.WriteLine(ControlChars.CrLf +"Displaying the public key." + ControlChars.CrLf)
      Dim pk() As Byte
      pk = myAssembly.GetName().GetPublicKey()
      For i = 0 To (pk.GetLength(0)) - 1
         Console.Write("{0:x}", pk(i))
      Next i
      Console.WriteLine()
      Console.WriteLine(ControlChars.CrLf +"Displaying the public key token."+ ControlChars.CrLf)
      Dim pt() As Byte
      pt = myAssembly.GetName().GetPublicKeyToken()
      For i = 0 To (pt.GetLength(0)) - 1
         Console.Write("{0:x}", pt(i))
      Next i
      End If
   End Sub 'Main 
End Class 'AssemblyName_CodeBase 

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 = String.Concat("file:///", 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]);
      }
   }
}

using namespace System;
using namespace System::Reflection;
using namespace System::Threading;
using namespace System::IO;
using namespace System::Globalization;
using namespace System::Reflection::Emit;
using namespace System::Configuration::Assemblies;
using namespace System::Text;
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", static_cast<MethodAttributes>(MethodAttributes::Public | MethodAttributes::HideBySig | MethodAttributes::Static), void::typeid, nullptr );

   // 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 );
}

int main()
{
   // Create a dynamic assembly with name 'MyAssembly' and build version '1.0.0.2001'.
   AssemblyName^ myAssemblyName = gcnew AssemblyName;

   // Set the codebase to the physical directory were the assembly resides.
   myAssemblyName->CodeBase = String::Concat( "file:///", Directory::GetCurrentDirectory() );

   // Set the culture information of the assembly to 'English-American'.
   myAssemblyName->CultureInfo = gcnew 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 = gcnew StrongNameKeyPair( File::Open( "KeyPair.snk", FileMode::Open, FileAccess::Read ) );
   myAssemblyName->Name = "MyAssembly";
   myAssemblyName->Version = gcnew Version( "1.0.0.2001" );
   MakeAssembly( myAssemblyName, "MyAssembly.exe" );

   // Get the assemblies loaded in the current application domain.
   array<Assembly^>^myAssemblies = Thread::GetDomain()->GetAssemblies();

   // Get the dynamic assembly named 'MyAssembly'. 
   Assembly^ myAssembly = nullptr;
   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 != nullptr )
   {
      Console::WriteLine( "\nDisplaying the full assembly name.\n" );
      Console::WriteLine( myAssembly->GetName()->FullName );
      Console::WriteLine( "\nDisplaying the public key.\n" );
      array<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" );
      array<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(String.Concat("file:///", 
            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

Plattformen

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

Siehe auch

Referenz

AssemblyName-Klasse
AssemblyName-Member
System.Reflection-Namespace