Export (0) Print
Expand All

AssemblyName::SetPublicKeyToken Method

Sets the public key token, which is the last 8 bytes of the SHA-1 hash of the public key under which the application or assembly is signed.

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

public:
void SetPublicKeyToken(
	array<unsigned char>^ publicKeyToken
)

Parameters

publicKeyToken
Type: array<System::Byte>

A byte array containing the public key token of the assembly.

When you set the public key by calling the SetPublicKey method, you must also use the SetPublicKeyToken method to provide a public key token. Otherwise, a SecurityException is thrown when the GetPublicKey method is called.

The following example emits a dynamic assembly and saves it to the current directory. When the assembly is created, the SetPublicKeyToken method is used to set the assembly's public key token. The GetPublicKeyToken method is then used to retrieve the public key token, which is displayed to the console.

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 = 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;

   // Get the whole contents of the 'PublicKey.snk' into a Byte array.
   FileStream^ publicKeyStream = File::Open( "PublicKey.snk", FileMode::Open );
   array<Byte>^publicKey = gcnew array<Byte>(publicKeyStream->Length);
   publicKeyStream->Read( publicKey, 0, (int)publicKeyStream->Length );

   // Provide the assembly with a public key.
   myAssemblyName->SetPublicKey( publicKey );

   // Get the whole contents of the 'PublicKeyToken.snk' into a Byte array.
   FileStream^ publicKeyTokenStream = File::Open( "PublicKeyToken.snk", FileMode::Open );
   array<Byte>^publicKeyToken = gcnew array<Byte>(publicKeyTokenStream->Length);
   publicKeyTokenStream->Read( publicKeyToken, 0, (int)publicKeyToken->Length );

   // Provide the assembly with a public key token.
   myAssemblyName->SetPublicKeyToken( publicKeyToken );
   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" );
      String^ assemblyName = myAssembly->GetName()->FullName;
      Console::WriteLine( assemblyName );
      Console::WriteLine( "\nDisplaying the public key for the assembly\n" );
      array<Byte>^publicKeyBytes = myAssembly->GetName()->GetPublicKey();
      Console::WriteLine( Encoding::ASCII->GetString( publicKeyBytes ) );
      Console::WriteLine( "\nDisplaying the public key token for the assembly\n" );
      array<Byte>^publicKeyTokenBytes = myAssembly->GetName()->GetPublicKeyToken();
      Console::WriteLine( Encoding::ASCII->GetString( publicKeyTokenBytes ) );
   }
}

.NET Framework

Supported in: 4.6, 4.5, 4, 3.5, 3.0, 2.0, 1.1

.NET Framework Client Profile

Supported in: 4, 3.5 SP1

XNA Framework

Supported in: 3.0, 2.0, 1.0

Portable Class Library

Supported in: Portable Class Library

Supported in: Windows Phone 8.1

Supported in: Windows Phone Silverlight 8.1

Supported in: Windows Phone Silverlight 8
Show:
© 2015 Microsoft