AssemblyName.Name Property

public:
 property System::String ^ Name { System::String ^ get(); void set(System::String ^ value); };

public string Name { get; set; }

public string? Name { get; set; }

member this.Name : string with get, set

Public Property Name As String

Property Value

The simple name of the assembly.

Examples

The following example emits a dynamic assembly and saves it to the current directory. When the assembly is created, the Name property is used to set the simple name of the dynamic assembly.

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

Imports System.Reflection
Imports System.Threading
Imports System.Reflection.Emit

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
 
 
 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
End Class

Remarks

The manifest file is the file that contains the assembly manifest.

For example, the simple name of a single-file assembly named "MyAssembly.dll" is "MyAssembly".

See also

• Specifying Fully Qualified Type Names