This documentation is archived and is not being maintained.

AssemblyName::Version Property

Gets or sets the major, minor, build, and revision numbers of the assembly.

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

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

Property Value

Type: System::Version
An object that represents the major, minor, build, and revision numbers of the assembly.

All components of the version must be integers greater than or equal to zero. Metadata restricts the major, minor, build, and revision components for an assembly to a maximum value of UInt16::MaxValue - 1. If a component exceeds this value, no error is thrown; however, in a dynamic assembly, that component is zero.

This section contains two examples. The first example shows how to retrieve the version of the currently executing assembly. The second example shows how to use the Version property to specify the assembly version when you emit a dynamic assembly.

Example 1

The following example retrieves and displays the version numbers of the currently executing assembly and the assembly that contains the String class.


using namespace System;
using namespace System::Reflection;

[assembly:AssemblyVersion("1.1.0.0")];

void main()
{
    Console::WriteLine("The version of the currently executing assembly is: {0}",
        Assembly::GetExecutingAssembly()->GetName()->Version);

    Console::WriteLine("The version of mscorlib.dll is: {0}",
        String::typeid->Assembly->GetName()->Version);
}

/* This example produces output similar to the following:

The version of the currently executing assembly is: 1.1.0.0
The version of mscorlib.dll is: 2.0.0.0
 */


Example 2

The following example emits a dynamic assembly and saves it to the current directory. When the assembly is created, the Version property is used to specify version information for the assembly.


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( "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;
   myAssemblyName->Name = "MyAssembly";
   myAssemblyName->Version = gcnew Version( "1.0.0.2001" );
   MakeAssembly( myAssemblyName, "MyAssembly.exe" );

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


.NET Framework

Supported in: 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Supported in: 4, 3.5 SP1

Portable Class Library

Supported in: Portable Class Library

Windows 7, Windows Vista SP1 or later, Windows XP SP3, Windows XP SP2 x64 Edition, Windows Server 2008 (Server Core not supported), Windows Server 2008 R2 (Server Core supported with SP1 or later), Windows Server 2003 SP2

The .NET Framework does not support all versions of every platform. For a list of the supported versions, see .NET Framework System Requirements.
Show: