Como posso obter a versão do assembly em execução?

Estou tentando obter a versão do assembly em execução no C # 3.0 usando o seguinte código:

var assemblyFullName = Assembly.GetExecutingAssembly().FullName;
var version = assemblyFullName .Split(',')[1].Split('=')[1];

Existe outra maneira adequada de fazer isso?

Duas opções ... independentemente do tipo de aplicativo, você sempre pode chamar:

Assembly.GetExecutingAssembly().GetName().Version

Se um aplicativo Windows Forms , você sempre pode acessar via aplicativo se procurar especificamente a versão do produto.

Application.ProductVersion

Usar GetExecutingAssemblypara uma referência de montagem nem sempre é uma opção. Como tal, eu pessoalmente acho útil criar uma classe auxiliar estática em projetos nos quais eu possa precisar fazer referência à montagem subjacente ou à versão da montagem:

// A sample assembly reference class that would exist in the `Core` project.
public static class CoreAssembly
{
    public static readonly Assembly Reference = typeof(CoreAssembly).Assembly;
    public static readonly Version Version = Reference.GetName().Version;
}

Depois, posso fazer uma referência limpa CoreAssembly.Versionno meu código, conforme necessário.

No MSDN, o Assembly.GetExecutingAssembly Method , é uma observação sobre o método "getexecutingassembly", que por motivos de desempenho, você deve chamar esse método somente quando não souber em tempo de design o assembly que está sendo executado no momento.

A maneira recomendada de recuperar um objeto Assembly que representa o assembly atual é usar a Type.Assemblypropriedade de um tipo encontrado no assembly.

O exemplo a seguir ilustra:

using System;
using System.Reflection;

public class Example
{
    public static void Main()
    {
        Console.WriteLine("The version of the currently executing assembly is: {0}",
                          typeof(Example).Assembly.GetName().Version);
    }
}

/* This example produces output similar to the following:
   The version of the currently executing assembly is: 1.1.0.0

É claro que isso é muito semelhante à resposta da classe auxiliar "classe estática pública CoreAssembly", mas, se você conhece pelo menos um tipo de montagem em execução, não é obrigatório criar uma classe auxiliar e economiza seu tempo.

using System.Reflection;
{
    string version = Assembly.GetEntryAssembly().GetName().Version.ToString();
}

Comentários do MSDN http://msdn.microsoft.com/en-us/library/system.reflection.assembly.getentryassembly%28v=vs.110%29.aspx :

O GetEntryAssemblymétodo pode retornar nullquando um assembly gerenciado for carregado a partir de um aplicativo não gerenciado. Por exemplo, se um aplicativo não gerenciado criar uma instância de um componente COM escrito em C #, uma chamada ao GetEntryAssemblymétodo do componente C # retornará null, porque o ponto de entrada do processo era um código não gerenciado, e não um assembly gerenciado.

Isso deve fazer:

Assembly assem = Assembly.GetExecutingAssembly();
AssemblyName aName = assem.GetName();
return aName.Version.ToString();

Finalmente decidi typeof(MyClass).GetTypeInfo().Assembly.GetName().Versionpor um aplicativo netstandard1.6. Todas as outras respostas propostas apresentaram uma solução parcial. Esta é a única coisa que me deu exatamente o que eu precisava.

Originado de uma combinação de lugares:

https://msdn.microsoft.com/en-us/library/x4cw969y(v=vs.110).aspx

https://msdn.microsoft.com/en-us/library/2exyydhb(v=vs.110).aspx

Product Version pode ser preferido se você estiver usando controle de versão via GitVersion ou outro software de controle de versão.

Para obter isso na sua biblioteca de classes, você pode ligar para System.Diagnostics.FileVersionInfo.ProductVersion:

using System.Diagnostics;
using System.Reflection;

//...

var assemblyLocation = Assembly.GetExecutingAssembly().Location;
var productVersion = FileVersionInfo.GetVersionInfo(assemblyLocation).ProductVersion