Export (0) Print
Expand All

AssemblyName Constructor

.NET Framework 1.1

Initializes a new instance of the AssemblyName class.

[Visual Basic]
Public Sub New()
[C#]
public AssemblyName();
[C++]
public: AssemblyName();
[JScript]
public function AssemblyName();

Remarks [Visual Basic, C#, C++]

[Visual Basic] 
Imports System
Imports System.Reflection
Imports System.Threading
Imports System.Reflection.Emit
Imports Microsoft.VisualBasic

Public Class AssemblyName_Constructor
   
   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)
      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()
      myAssemblyName.Name = "MyAssembly"
      myAssemblyName.Version = New Version("1.0.0.2001")
      MakeAssembly(myAssemblyName, "MyAssembly.exe")
      
      ' Get all the assemblies currently loaded in the 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
      If Not (myAssembly Is Nothing) Then
         Console.WriteLine(ControlChars.Cr + "Displaying the assembly name" + ControlChars.Cr)
         Console.WriteLine(myAssembly)
      End If
   End Sub 'Main 
End Class 'AssemblyName_Constructor 

[C#] 

using System;
using System.Reflection;
using System.Threading;
using System.Reflection.Emit;

public class AssemblyName_Constructor
{
   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(); 
      myAssemblyName.Name = "MyAssembly";
      myAssemblyName.Version = new Version("1.0.0.2001");
      MakeAssembly(myAssemblyName, "MyAssembly.exe");

      // Get all the assemblies currently loaded in the 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];
      }
      if(myAssembly != null)
      {
         Console.WriteLine("\nDisplaying the assembly name\n");
         Console.WriteLine(myAssembly);
      }
   }
}

[C++] 

#using <mscorlib.dll>

using namespace System;
using namespace System::Reflection;
using namespace System::Threading;
using namespace System::Reflection::Emit;

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(S"MyModule", fileName);
   // Create a type in the module.
   TypeBuilder* myTypeBuilder = myModuleBuilder->DefineType(S"MyType");
   // Create a method called 'Main'.
   MethodBuilder* myMethodBuilder = myTypeBuilder->DefineMethod(S"Main",
      static_cast<MethodAttributes>( MethodAttributes::Public | MethodAttributes::HideBySig | MethodAttributes::Static ),
      __typeof(void), 0);
   // 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(S"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 = new AssemblyName(); 
   myAssemblyName->Name = S"MyAssembly";
   myAssemblyName->Version = new Version(S"1.0.0.2001");
   MakeAssembly(myAssemblyName, S"MyAssembly.exe");

   // Get all the assemblies currently loaded in the application domain.
   Assembly* myAssemblies[] = Thread::GetDomain()->GetAssemblies();

   // Get the dynamic assembly named 'MyAssembly'. 
   Assembly* myAssembly = 0;
   for (int i = 0; i < myAssemblies->Length; i++) {
      if (String::Compare(myAssemblies[i]->GetName()->Name, S"MyAssembly") == 0)
         myAssembly = myAssemblies[i];
   }
   if (myAssembly != 0) {
      Console::WriteLine("\nDisplaying the assembly name\n");
      Console::WriteLine(myAssembly);
   }
}

Requirements

Platforms: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 family, .NET Compact Framework

See Also

AssemblyName Class | AssemblyName Members | System.Reflection Namespace

Show:
© 2014 Microsoft