Programaticamente obter o número da versão de uma DLL


151

É possível obter o número da versão programaticamente de qualquer DLL do .NET?

Se sim, como?


10
Não posso acreditar que isso foi solicitado há 6 minutos, estava prestes a perguntar o mesmo!
tpower 18/11/2009

2
verifique também este link para obter a versão com incremento automático - blog.mbcharbonneau.com/2007/03/13/…
JL.

Respostas:


119
Assembly assembly = Assembly.LoadFrom("MyAssembly.dll");
Version ver = assembly.GetName().Version;

Importante: Note-se que esta não é a melhor resposta para a pergunta original. Não se esqueça de ler mais nesta página.


28
Isso carrega o MyAssembly.dll na má idéia em execução do AppDomain ....
staafl

12
Eu recomendo Assemblyname.GetAssemblyNameevitar esses problemas #
staafl 10/10

7
carregar um assembly no domínio do aplicativo é lento, irreversível (não é possível descarregá-lo sem matar o domínio), requer permissões e é suscetível de causar efeitos colaterais, como a execução de beforefieldinitinicializadores de tipo, e não é obrigatório neste caso. Essas razões são suficientes?
staafl

7
@staafl: Sim; não apenas para mim, mas também para todo mundo lendo esta página no futuro.
Kris

6
FileVersionInfo.GetVersionInfo("foo.dll").FileVersionfaz bem o trabalho e não carrega a dll no aplicativo.
Jack

181

Isso funciona se a dll for .net ou Win32 . Os métodos de reflexão funcionam apenas se a dll for .net. Além disso, se você usar a reflexão, terá a sobrecarga de carregar a dll inteira na memória. O método abaixo não carrega o conjunto na memória.

// Get the file version.
FileVersionInfo myFileVersionInfo = FileVersionInfo.GetVersionInfo(@"C:\MyAssembly.dll");

// Print the file name and version number.
Console.WriteLine("File: " + myFileVersionInfo.FileDescription + '\n' +
                  "Version number: " + myFileVersionInfo.FileVersion);

De: http://msdn.microsoft.com/en-us/library/system.diagnostics.fileversioninfo.fileversion.aspx

fonte original


5
Eu gosto disso. Por que você se incomodaria em carregar a dll e depois usaria a reflexão apenas para obter a versão, quando tudo que você realmente quer fazer é isso ???
aggieNick02

@ ben, você poderia editar a postagem? Vi que havia perdido -1 representante ao adicionar um voto negativo, que não me lembro de ter feito. não me permitirá alterá-lo, a menos que você edite a postagem. Felicidades!
Luke Duddridge

9
Se você gostaria de ter certeza de obter o executável / dll realmente atualmente em uso: em vez de um nome de arquivo estático ( @"C:\MyAssembly.dll"acima), você pode usar System.Reflection.Assembly.GetExecutingAssembly().Location(ou se uma dll: Assembly.GetAssembly(typeof(AClassInTheDll)).Location)
Conrad

4
É a diferença entre os atributos AssemblyVersion e AssemblyFileVersion. O AssemblyFileVersion é carimbado da maneira que a API do Windows pode obter o valor. O AssemblyVersion faz parte do nome forte e não é necessariamente o mesmo que o AssemblyFileVersion.
daughey

51

Primeiro de tudo, existem duas possíveis 'versões' nas quais você pode estar interessado:

  • Versão do arquivo do sistema de arquivos do Windows, aplicável a todos os arquivos executáveis

  • Versão de compilação do assembly, incorporada em um assembly .NET pelo compilador (obviamente aplicável apenas aos arquivos DLL e exe do assembly .NET)

No primeiro caso, você deve usar a resposta de Ben Anderson; neste último caso, use AssemblyName.GetAssemblyName(@"c:\path\to\file.dll").Versionou a resposta de Tataro, caso a montagem seja referenciada pelo seu código.

Observe que você pode ignorar todas as respostas que usam .Load()/ .LoadFrom()métodos, pois elas realmente carregam a montagem no AppDomain atual - o que é análogo a cortar uma árvore para ver quantos anos ela tem.


32

Aqui está uma boa maneira de usar um pouco de reflexão para obter uma versão de uma DLL contendo uma classe específica:

var ver = System.Reflection.Assembly.GetAssembly(typeof(!Class!)).GetName().Version;

Apenas substitua! Classe! com o nome de uma classe definida na DLL da qual você deseja obter a versão.

Este é o meu método preferido, porque se eu mover as DLLs para diferentes implantações, não preciso alterar o caminho do arquivo.


3
Observe que isso só funciona se o assembly em questão for referenciado estaticamente pelo atual.
staafl

2
Esta é a melhor resposta desde a DLL não é necessariamente a entrada de montagem nem mesmo a montagem isso é chamado de
CAD cara

1
Consulte stackoverflow.com/a/909583/492 para obter diferentes tipos de informações sobre a versão. por exemploFileVersionInfo
CAD cara

22

Para obtê-lo para o assembly iniciado (winform, aplicativo de console, etc ...)

using System.Reflection;
...
Assembly.GetEntryAssembly().GetName().Version

6
GetExecutingAssembly () também pode ajudar.
Bolt Thunder

10

Kris, sua versão funciona muito bem quando é necessário carregar o assembly a partir do arquivo DLL real (e se a DLL estiver lá!), No entanto, ocorrerá um erro indesejado se a DLL for EMBEDDED (ou seja, não um arquivo, mas um arquivo incorporado DLL).

A outra coisa é que, se alguém usa um esquema de versão com algo como " 1.2012.0508.0101 ", quando alguém obtém a string da versão, você realmente obtém " 1.2012.518.101 "; observe os zeros ausentes .

Então, aqui estão algumas funções extras para obter a versão de uma DLL (incorporada ou do arquivo DLL):

    public static System.Reflection.Assembly GetAssembly(string pAssemblyName)
    {
        System.Reflection.Assembly tMyAssembly = null;

        if (string.IsNullOrEmpty(pAssemblyName)) { return tMyAssembly; }
        tMyAssembly = GetAssemblyEmbedded(pAssemblyName);
        if (tMyAssembly == null) { GetAssemblyDLL(pAssemblyName); }

        return tMyAssembly;
    }//System.Reflection.Assembly GetAssemblyEmbedded(string pAssemblyDisplayName)


    public static System.Reflection.Assembly GetAssemblyEmbedded(string pAssemblyDisplayName)
    {
        System.Reflection.Assembly tMyAssembly = null;

        if(string.IsNullOrEmpty(pAssemblyDisplayName)) { return tMyAssembly; }
        try //try #a
        {
            tMyAssembly = System.Reflection.Assembly.Load(pAssemblyDisplayName);
        }// try #a
        catch (Exception ex)
        {
            string m = ex.Message;
        }// try #a
        return tMyAssembly;
    }//System.Reflection.Assembly GetAssemblyEmbedded(string pAssemblyDisplayName)


    public static System.Reflection.Assembly GetAssemblyDLL(string pAssemblyNameDLL)
    {
        System.Reflection.Assembly tMyAssembly = null;

        if (string.IsNullOrEmpty(pAssemblyNameDLL)) { return tMyAssembly; }
        try //try #a
        {
            if (!pAssemblyNameDLL.ToLower().EndsWith(".dll")) { pAssemblyNameDLL += ".dll"; }
            tMyAssembly = System.Reflection.Assembly.LoadFrom(pAssemblyNameDLL);
        }// try #a
        catch (Exception ex)
        {
            string m = ex.Message;
        }// try #a
        return tMyAssembly;
    }//System.Reflection.Assembly GetAssemblyFile(string pAssemblyNameDLL)


    public static string GetVersionStringFromAssembly(string pAssemblyDisplayName)
    {
        string tVersion = "Unknown";
        System.Reflection.Assembly tMyAssembly = null;

        tMyAssembly = GetAssembly(pAssemblyDisplayName);
        if (tMyAssembly == null) { return tVersion; }
        tVersion = GetVersionString(tMyAssembly.GetName().Version.ToString());
        return tVersion;
    }//string GetVersionStringFromAssemblyEmbedded(string pAssemblyDisplayName)


    public static string GetVersionString(Version pVersion)
    {
        string tVersion = "Unknown";
        if (pVersion == null) { return tVersion; }
        tVersion = GetVersionString(pVersion.ToString());
        return tVersion;
    }//string GetVersionString(Version pVersion)


    public static string GetVersionString(string pVersionString)
    {
        string tVersion = "Unknown";
        string[] aVersion;

        if (string.IsNullOrEmpty(pVersionString)) { return tVersion; }
        aVersion = pVersionString.Split('.');
        if (aVersion.Length > 0) { tVersion = aVersion[0]; }
        if (aVersion.Length > 1) { tVersion += "." + aVersion[1]; }
        if (aVersion.Length > 2) { tVersion += "." + aVersion[2].PadLeft(4, '0'); }
        if (aVersion.Length > 3) { tVersion += "." + aVersion[3].PadLeft(4, '0'); }

        return tVersion;
    }//string GetVersionString(Version pVersion)


    public static string GetVersionStringFromAssemblyEmbedded(string pAssemblyDisplayName)
    {
        string tVersion = "Unknown";
        System.Reflection.Assembly tMyAssembly = null;

        tMyAssembly = GetAssemblyEmbedded(pAssemblyDisplayName);
        if (tMyAssembly == null) { return tVersion; }
        tVersion = GetVersionString(tMyAssembly.GetName().Version.ToString());
        return tVersion;
    }//string GetVersionStringFromAssemblyEmbedded(string pAssemblyDisplayName)


    public static string GetVersionStringFromAssemblyDLL(string pAssemblyDisplayName)
    {
        string tVersion = "Unknown";
        System.Reflection.Assembly tMyAssembly = null;

        tMyAssembly = GetAssemblyDLL(pAssemblyDisplayName);
        if (tMyAssembly == null) { return tVersion; }
        tVersion = GetVersionString(tMyAssembly.GetName().Version.ToString());
        return tVersion;
    }//string GetVersionStringFromAssemblyEmbedded(string pAssemblyDisplayName)

2
var versionAttrib = new AssemblyName(Assembly.GetExecutingAssembly().FullName);

2

Responder por @Ben provou ser útil para mim. Mas eu precisava verificar a versão do produto, pois era o principal incremento que acontecia no meu software e seguia a versão semântica.

myFileVersionInfo.ProductVersion

Este método atendeu minhas expectativas

Atualização: em vez de mencionar explicitamente o caminho da DLL no programa (conforme necessário na versão de produção), podemos obter a versão do produto usando o Assembly.

Assembly assembly = Assembly.GetExecutingAssembly();
FileVersionInfo fileVersionInfo =FileVersionInfo.GetVersionInfo(assembly.Location); 
string ProdVersion= fileVersionInfo.ProductVersion;

Nota: se a versão contiver asterisco para o valor incrementado automaticamente, esse método retornará o asterisco em vez do número real gerado (ou seja, não funcionará se você colocar 1,0. * Nas informações de montagem).
Ronen Ness

Sim! No entanto, escolhi a automação Jeniks para atualização de versão, para que o assembly sempre tenha uma combinação perfeita da versão dll.
Prasan Dutt 29/07/19

1

Você pode usar os métodos System.Reflection.Assembly.Load * () e, em seguida, pegue o AssemblyInfo.


0

Embora a pergunta original possa não ter sido específica para um serviço da Web, aqui está um testWebService completo que você pode adicionar para exibir uma resposta não armazenada em cache do serviço da Web mais a versão do arquivo. Usamos a versão do arquivo em vez da versão do assembly porque queremos conhecer uma versão, mas com todas as versões 1.0.0.0 do assembly, o site pode ser facilmente corrigido (o link de assinatura e demanda ainda está ativo!). Substitua @ Class @ pelo nome do controlador de API da Web em que este serviço está incorporado. É bom para um go / nogo em um serviço da Web, além de uma verificação rápida da versão.

  [Route("api/testWebService")]
  [AllowAnonymous]
  [HttpGet]
  public HttpResponseMessage TestWebService()
  {
      HttpResponseMessage responseMessage = Request.CreateResponse(HttpStatusCode.OK);
      string loc = Assembly.GetAssembly(typeof(@Class@)).Location;
      FileVersionInfo versionInfo = FileVersionInfo.GetVersionInfo(loc);
      responseMessage.Content = new StringContent($"<h2>The XXXXX web service GET test succeeded.</h2>{DateTime.Now}<br/><br/>File Version: {versionInfo.FileVersion}");
      responseMessage.Content.Headers.ContentType = new MediaTypeHeaderValue("text/html");
      Request.RegisterForDispose(responseMessage);
      return responseMessage;
  }

Também achei necessário adicionar o seguinte ao web.config em configuração para torná-lo realmente anônimo

<location path="api/testwebservice">
    <system.web>
        <authorization>
            <allow users="*" />
        </authorization>
    </system.web>
</location>
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.