Atualmente, tenho um aplicativo exibindo o número da compilação em sua janela de título. Isso é bom, exceto que isso não significa nada para a maioria dos usuários, que querem saber se possuem a versão mais recente - eles tendem a se referir a ela como "da última quinta-feira" em vez da versão 1.0.8.4321.

O plano é colocar a data da compilação lá - então "Aplicativo criado em 21/10/2009", por exemplo.

Estou lutando para encontrar uma maneira programática de extrair a data de compilação como uma sequência de texto para uso como este.

Para o número da compilação, usei:

Assembly.GetExecutingAssembly().GetName().Version.ToString()

depois de definir como eles surgiram.

Eu gostaria de algo assim para a data de compilação (e hora, para pontos de bônus).

Os ponteiros aqui são muito apreciados (desculpe trocadilhos, se apropriado), ou soluções mais limpas ...

Jeff Atwood tinha algumas coisas a dizer sobre esse problema em Determinando a data da compilação da maneira mais difícil .

O método mais confiável é recuperar o registro de data e hora do vinculador do cabeçalho PE incorporado no arquivo executável - algum código C # (de Joe Spivey) para isso dos comentários ao artigo de Jeff:

public static DateTime GetLinkerTime(this Assembly assembly, TimeZoneInfo target = null)
{
    var filePath = assembly.Location;
    const int c_PeHeaderOffset = 60;
    const int c_LinkerTimestampOffset = 8;

    var buffer = new byte[2048];

    using (var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
        stream.Read(buffer, 0, 2048);

    var offset = BitConverter.ToInt32(buffer, c_PeHeaderOffset);
    var secondsSince1970 = BitConverter.ToInt32(buffer, offset + c_LinkerTimestampOffset);
    var epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);

    var linkTimeUtc = epoch.AddSeconds(secondsSince1970);

    var tz = target ?? TimeZoneInfo.Local;
    var localTime = TimeZoneInfo.ConvertTimeFromUtc(linkTimeUtc, tz);

    return localTime;
}

Exemplo de uso:

var linkTimeLocal = Assembly.GetExecutingAssembly().GetLinkerTime();

ATUALIZAÇÃO: O método estava funcionando para o .Net Core 1.0, mas parou de funcionar após o lançamento do .Net Core 1.1 (fornece anos aleatórios no intervalo de 1900-2020)

Adicione abaixo à linha de comando do evento de pré-construção:

echo %date% %time% > "$(ProjectDir)\Resources\BuildDate.txt"

Adicione este arquivo como recurso, agora você tem a string 'BuildDate' em seus recursos.

Para criar recursos, consulte Como criar e usar recursos no .NET .

O caminho

Como apontado por @ c00000fd nos comentários . A Microsoft está mudando isso. E enquanto muitas pessoas não usam a versão mais recente de seu compilador, suspeito que essa mudança torne essa abordagem inquestionavelmente ruim. E, embora seja um exercício divertido, eu recomendaria que as pessoas simplesmente incorporassem uma data de construção em seu binário por qualquer outro meio necessário, se for importante rastrear a data de construção do próprio binário.

Isso pode ser feito com alguma geração trivial de código, que provavelmente já é a primeira etapa do seu script de construção. Isso e o fato de as ferramentas ALM / Build / DevOps ajudarem muito com isso e devem ser preferidas a qualquer outra coisa.

Deixo o restante desta resposta aqui apenas para fins históricos.

O novo caminho

Mudei de idéia sobre isso e, atualmente, use esse truque para obter a data de compilação correta.

#region Gets the build date and time (by reading the COFF header)

// http://msdn.microsoft.com/en-us/library/ms680313

struct _IMAGE_FILE_HEADER
{
    public ushort Machine;
    public ushort NumberOfSections;
    public uint TimeDateStamp;
    public uint PointerToSymbolTable;
    public uint NumberOfSymbols;
    public ushort SizeOfOptionalHeader;
    public ushort Characteristics;
};

static DateTime GetBuildDateTime(Assembly assembly)
{
    var path = assembly.GetName().CodeBase;
    if (File.Exists(path))
    {
        var buffer = new byte[Math.Max(Marshal.SizeOf(typeof(_IMAGE_FILE_HEADER)), 4)];
        using (var fileStream = new FileStream(path, FileMode.Open, FileAccess.Read))
        {
            fileStream.Position = 0x3C;
            fileStream.Read(buffer, 0, 4);
            fileStream.Position = BitConverter.ToUInt32(buffer, 0); // COFF header offset
            fileStream.Read(buffer, 0, 4); // "PE\0\0"
            fileStream.Read(buffer, 0, buffer.Length);
        }
        var pinnedBuffer = GCHandle.Alloc(buffer, GCHandleType.Pinned);
        try
        {
            var coffHeader = (_IMAGE_FILE_HEADER)Marshal.PtrToStructure(pinnedBuffer.AddrOfPinnedObject(), typeof(_IMAGE_FILE_HEADER));

            return TimeZone.CurrentTimeZone.ToLocalTime(new DateTime(1970, 1, 1) + new TimeSpan(coffHeader.TimeDateStamp * TimeSpan.TicksPerSecond));
        }
        finally
        {
            pinnedBuffer.Free();
        }
    }
    return new DateTime();
}

#endregion

O jeito antigo

Bem, como você gera números de compilação? O Visual Studio (ou o compilador C #) realmente fornece números de compilação e revisão automáticos se você alterar o atributo AssemblyVersion para, por exemplo,1.0.*

O que acontecerá é que a compilação será igual ao número de dias desde 1º de janeiro de 2000, horário local, e a revisão será igual ao número de segundos desde o horário local da meia-noite, dividido por 2.

consulte Conteúdo da comunidade, números de compilação e revisão automáticos

por exemplo AssemblyInfo.cs

[assembly: AssemblyVersion("1.0.*")] // important: use wildcard for build and revision numbers!

SampleCode.cs

var version = Assembly.GetEntryAssembly().GetName().Version;
var buildDateTime = new DateTime(2000, 1, 1).Add(new TimeSpan(
TimeSpan.TicksPerDay * version.Build + // days since 1 January 2000
TimeSpan.TicksPerSecond * 2 * version.Revision)); // seconds since midnight, (multiply by 2 to get original)

Adicione abaixo à linha de comando do evento de pré-construção:

echo %date% %time% > "$(ProjectDir)\Resources\BuildDate.txt"

Adicione este arquivo como recurso, agora você tem a string 'BuildDate' em seus recursos.

Depois de inserir o arquivo no Recurso (como arquivo de texto público), acessei-o via

string strCompTime = Properties.Resources.BuildDate;

Para criar recursos, consulte Como criar e usar recursos no .NET .

Uma abordagem que me surpreende que ninguém tenha mencionado ainda é usar modelos de texto T4 para geração de código.

<#@ template debug="false" hostspecific="true" language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System" #>
<#@ output extension=".g.cs" #>
using System;
namespace Foo.Bar
{
    public static partial class Constants
    {
        public static DateTime CompilationTimestampUtc { get { return new DateTime(<# Write(DateTime.UtcNow.Ticks.ToString()); #>L, DateTimeKind.Utc); } }
    }
}

Prós:

• Independente da localidade
• Permite muito mais do que apenas o tempo de compilação

Contras:

• Aplicável apenas a bibliotecas em que você controla a fonte
• Requer a configuração do seu projeto (e servidor de compilação, se isso não ocorrer) para executar o modelo em uma etapa de pré-compilação . (Veja também T4 sem VS ).

Em relação à técnica de extrair informações de data / versão da compilação dos bytes de um cabeçalho PE do assembly, a Microsoft alterou os parâmetros de compilação padrão começando no Visual Studio 15.4. O novo padrão inclui compilação determinística, que torna um carimbo de data / hora válido e os números de versão incrementados automaticamente uma coisa do passado. O campo de registro de data e hora ainda está presente, mas é preenchido com um valor permanente que é um hash de uma coisa ou outra, mas não indica o tempo de construção.

Alguns antecedentes detalhados aqui

Para aqueles que priorizam um carimbo de data / hora útil sobre a compilação determinística, há uma maneira de substituir o novo padrão. Você pode incluir uma tag no arquivo .csproj do assembly de interesse da seguinte maneira:

  <PropertyGroup>
      ...
      <Deterministic>false</Deterministic>
  </PropertyGroup>

Atualização: eu apoio a solução de modelo de texto T4 descrita em outra resposta aqui. Usei-o para resolver meu problema de maneira limpa, sem perder o benefício da compilação determinística. Um cuidado é que o Visual Studio só executa o compilador T4 quando o arquivo .tt é salvo, não no tempo de compilação. Isso pode ser estranho se você excluir o resultado .cs do controle de origem (já que você espera que seja gerado) e outro desenvolvedor verificar o código. Sem salvar novamente, eles não terão o arquivo .cs. Existe um pacote no nuget (eu acho chamado AutoT4) que faz a compilação do T4 parte de cada compilação. Ainda não enfrentei a solução para isso durante a implantação da produção, mas espero que algo semelhante o ajude.

Eu sou apenas novato em C #, talvez minha resposta pareça boba - eu exibo a data de compilação a partir da data em que o arquivo executável foi gravado pela última vez:

string w_file = "MyProgram.exe"; 
string w_directory = Directory.GetCurrentDirectory();

DateTime c3 =  File.GetLastWriteTime(System.IO.Path.Combine(w_directory, w_file));
RTB_info.AppendText("Program created at: " + c3.ToString());

Tentei usar o método File.GetCreationTime, mas obtive resultados estranhos: a data do comando era 29/05/2012, mas a data do Windows Explorer mostrava 2012-05-23. Depois de procurar essa discrepância, descobri que o arquivo provavelmente foi criado em 23/05/2012 (como mostrado pelo Windows Explorer), mas copiado para a pasta atual em 29-05-2012 (como mostrado pelo comando File.GetCreationTime) - portanto para estar no lado seguro, estou usando o comando File.GetLastWriteTime.

Zalek

Muitas ótimas respostas aqui, mas acho que posso adicionar as minhas por causa da simplicidade, desempenho (em comparação com soluções relacionadas a recursos) entre plataformas (funciona também com o Net Core) e evita qualquer ferramenta de terceiros. Basta adicionar este destino msbuild ao csproj.

<Target Name="Date" BeforeTargets="CoreCompile">
    <WriteLinesToFile File="$(IntermediateOutputPath)gen.cs" Lines="static partial class Builtin { public static long CompileTime = $([System.DateTime]::UtcNow.Ticks) %3B }" Overwrite="true" />
    <ItemGroup>
        <Compile Include="$(IntermediateOutputPath)gen.cs" />
    </ItemGroup>
</Target>

e agora você tem Builtin.CompileTimeou new DateTime(Builtin.CompileTime, DateTimeKind.Utc)se precisar dessa maneira.

ReSharper não vai gostar. Você pode ignorá-lo ou adicionar uma classe parcial ao projeto também, mas funciona assim mesmo.

Para projetos do .NET Core, adaptei a resposta do Postlagerkarte para atualizar o campo Copyright da montagem com a data da compilação.

Editar diretamente csproj

O seguinte pode ser adicionado diretamente ao primeiro PropertyGroupno csproj:

<Copyright>Copyright © $([System.DateTime]::UtcNow.Year) Travis Troyer ($([System.DateTime]::UtcNow.ToString("s")))</Copyright>

Alternativa: Propriedades do Projeto Visual Studio

Ou cole a expressão interna diretamente no campo Copyright na seção Package das propriedades do projeto no Visual Studio:

Copyright © $([System.DateTime]::UtcNow.Year) Travis Troyer ($([System.DateTime]::UtcNow.ToString("s")))

Isso pode ser um pouco confuso, porque o Visual Studio avaliará a expressão e exibirá o valor atual na janela, mas também atualizará o arquivo do projeto adequadamente nos bastidores.

Em toda a solução via Directory.Build.props

Você pode colocar o <Copyright>elemento acima em um Directory.Build.propsarquivo na raiz da solução e aplicá-lo automaticamente a todos os projetos no diretório, assumindo que cada projeto não forneça seu próprio valor de Copyright.

<Project>
 <PropertyGroup>
   <Copyright>Copyright © $([System.DateTime]::UtcNow.Year) Travis Troyer ($([System.DateTime]::UtcNow.ToString("s")))</Copyright>
 </PropertyGroup>
</Project>

Directory.Build.props: personalize sua compilação

Resultado

A expressão de exemplo fornecerá direitos autorais como este:

Copyright © 2018 Travis Troyer (2018-05-30T14:46:23)

Recuperação

Você pode visualizar as informações de direitos autorais das propriedades do arquivo no Windows ou obtê-las em tempo de execução:

var version = FileVersionInfo.GetVersionInfo(Assembly.GetEntryAssembly().Location);

Console.WriteLine(version.LegalCopyright);

O método acima pode ser ajustado para montagens já carregadas no processo , usando a imagem do arquivo na memória (em vez de relê-lo do armazenamento):

using System;
using System.Runtime.InteropServices;
using Assembly = System.Reflection.Assembly;

static class Utils
{
    public static DateTime GetLinkerDateTime(this Assembly assembly, TimeZoneInfo tzi = null)
    {
        // Constants related to the Windows PE file format.
        const int PE_HEADER_OFFSET = 60;
        const int LINKER_TIMESTAMP_OFFSET = 8;

        // Discover the base memory address where our assembly is loaded
        var entryModule = assembly.ManifestModule;
        var hMod = Marshal.GetHINSTANCE(entryModule);
        if (hMod == IntPtr.Zero - 1) throw new Exception("Failed to get HINSTANCE.");

        // Read the linker timestamp
        var offset = Marshal.ReadInt32(hMod, PE_HEADER_OFFSET);
        var secondsSince1970 = Marshal.ReadInt32(hMod, offset + LINKER_TIMESTAMP_OFFSET);

        // Convert the timestamp to a DateTime
        var epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
        var linkTimeUtc = epoch.AddSeconds(secondsSince1970);
        var dt = TimeZoneInfo.ConvertTimeFromUtc(linkTimeUtc, tzi ?? TimeZoneInfo.Local);
        return dt;
    }
}

Para quem precisa obter o tempo de compilação no Windows 8 / Windows Phone 8:

    public static async Task<DateTimeOffset?> RetrieveLinkerTimestamp(Assembly assembly)
    {
        var pkg = Windows.ApplicationModel.Package.Current;
        if (null == pkg)
        {
            return null;
        }

        var assemblyFile = await pkg.InstalledLocation.GetFileAsync(assembly.ManifestModule.Name);
        if (null == assemblyFile)
        {
            return null;
        }

        using (var stream = await assemblyFile.OpenSequentialReadAsync())
        {
            using (var reader = new DataReader(stream))
            {
                const int PeHeaderOffset = 60;
                const int LinkerTimestampOffset = 8;

                //read first 2048 bytes from the assembly file.
                byte[] b = new byte[2048];
                await reader.LoadAsync((uint)b.Length);
                reader.ReadBytes(b);
                reader.DetachStream();

                //get the pe header offset
                int i = System.BitConverter.ToInt32(b, PeHeaderOffset);

                //read the linker timestamp from the PE header
                int secondsSince1970 = System.BitConverter.ToInt32(b, i + LinkerTimestampOffset);

                var dt = new DateTimeOffset(1970, 1, 1, 0, 0, 0, DateTimeOffset.Now.Offset) + DateTimeOffset.Now.Offset;
                return dt.AddSeconds(secondsSince1970);
            }
        }
    }

Para quem precisa obter o tempo de compilação no Windows Phone 7:

    public static async Task<DateTimeOffset?> RetrieveLinkerTimestampAsync(Assembly assembly)
    {
        const int PeHeaderOffset = 60;
        const int LinkerTimestampOffset = 8;            
        byte[] b = new byte[2048];

        try
        {
            var rs = Application.GetResourceStream(new Uri(assembly.ManifestModule.Name, UriKind.Relative));
            using (var s = rs.Stream)
            {
                var asyncResult = s.BeginRead(b, 0, b.Length, null, null);
                int bytesRead = await Task.Factory.FromAsync<int>(asyncResult, s.EndRead);
            }
        }
        catch (System.IO.IOException)
        {
            return null;
        }

        int i = System.BitConverter.ToInt32(b, PeHeaderOffset);
        int secondsSince1970 = System.BitConverter.ToInt32(b, i + LinkerTimestampOffset);
        var dt = new DateTimeOffset(1970, 1, 1, 0, 0, 0, DateTimeOffset.Now.Offset) + DateTimeOffset.Now.Offset;
        dt = dt.AddSeconds(secondsSince1970);
        return dt;
    }

OBSERVAÇÃO: em todos os casos, você está executando em uma sandbox, para poder obter o tempo de compilação dos assemblies implantados com o aplicativo. (ou seja, isso não funcionará em nada no GAC).

Em 2018, algumas das soluções acima não funcionam mais ou não funcionam com o .NET Core.

Eu uso a seguinte abordagem, que é simples e funciona para o meu projeto .NET Core 2.0.

Adicione o seguinte ao seu .csproj dentro do PropertyGroup:

    <Today>$([System.DateTime]::Now)</Today>

Isso define uma PropertyFunction que você pode acessar no seu comando de pré-construção.

Sua pré-construção se parece com isso

echo $(today) > $(ProjectDir)BuildTimeStamp.txt

Defina a propriedade do BuildTimeStamp.txt como recurso incorporado.

Agora você pode ler o carimbo de hora como este

public static class BuildTimeStamp
    {
        public static string GetTimestamp()
        {
            var assembly = Assembly.GetEntryAssembly(); 

            var stream = assembly.GetManifestResourceStream("NamespaceGoesHere.BuildTimeStamp.txt");

            using (var reader = new StreamReader(stream))
            {
                return reader.ReadToEnd();
            }
        }
    }

A opção não discutida aqui é inserir seus próprios dados no AssemblyInfo.cs, o campo "AssemblyInformationalVersion" parece apropriado - temos alguns projetos em que estávamos fazendo algo semelhante como uma etapa de construção (no entanto, não estou totalmente satisfeito com o maneira que funciona, então não quero realmente reproduzir o que temos).

Há um artigo sobre o assunto no codeproject: http://www.codeproject.com/KB/dotnet/Customizing_csproj_files.aspx

Eu precisava de uma solução universal que funcionasse com um projeto NETStandard em qualquer plataforma (iOS, Android e Windows.) Para fazer isso, decidi gerar automaticamente um arquivo CS por meio de um script do PowerShell. Aqui está o script do PowerShell:

param($outputFile="BuildDate.cs")

$buildDate = Get-Date -date (Get-Date).ToUniversalTime() -Format o
$class = 
"using System;
using System.Globalization;

namespace MyNamespace
{
    public static class BuildDate
    {
        public const string BuildDateString = `"$buildDate`";
        public static readonly DateTime BuildDateUtc = DateTime.Parse(BuildDateString, null, DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal);
    }
}"

Set-Content -Path $outputFile -Value $class

Salve o arquivo do PowerScript como GenBuildDate.ps1 e adicione-o ao seu projeto. Por fim, adicione a seguinte linha ao seu evento Pre-Build:

powershell -File $(ProjectDir)GenBuildDate.ps1 -outputFile $(ProjectDir)BuildDate.cs

Verifique se BuildDate.cs está incluído no seu projeto. Funciona como um campeão em qualquer sistema operacional!

Eu só faço:

File.GetCreationTime(GetType().Assembly.Location)

Você pode usar este projeto: https://github.com/dwcullop/BuildInfo

Ele utiliza o T4 para automatizar o registro de data e hora da construção. Existem várias versões (ramificações diferentes), incluindo uma que fornece o Git Hash da ramificação com check-out atualmente, se você gosta desse tipo de coisa.

Divulgação: escrevi o módulo.

Uma abordagem diferente, compatível com PCL, seria usar uma tarefa embutida do MSBuild para substituir o tempo de compilação em uma sequência retornada por uma propriedade no aplicativo. Estamos usando essa abordagem com êxito em um aplicativo que possui projetos Xamarin.Forms, Xamarin.Android e Xamarin.iOS.

EDITAR:

Simplificado movendo toda a lógica para o SetBuildDate.targetsarquivo e usando em Regexvez de uma sequência simples, substitua para que o arquivo possa ser modificado por cada construção sem uma "redefinição".

A definição de tarefa embutida do MSBuild (salva em um arquivo SetBuildDate.targets local no projeto Xamarin.Forms deste exemplo):

<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003' ToolsVersion="12.0">

  <UsingTask TaskName="SetBuildDate" TaskFactory="CodeTaskFactory" 
    AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.v12.0.dll">
    <ParameterGroup>
      <FilePath ParameterType="System.String" Required="true" />
    </ParameterGroup>
    <Task>
      <Code Type="Fragment" Language="cs"><![CDATA[

        DateTime now = DateTime.UtcNow;
        string buildDate = now.ToString("F");
        string replacement = string.Format("BuildDate => \"{0}\"", buildDate);
        string pattern = @"BuildDate => ""([^""]*)""";
        string content = File.ReadAllText(FilePath);
        System.Text.RegularExpressions.Regex rgx = new System.Text.RegularExpressions.Regex(pattern);
        content = rgx.Replace(content, replacement);
        File.WriteAllText(FilePath, content);
        File.SetLastWriteTimeUtc(FilePath, now);

   ]]></Code>
    </Task>
  </UsingTask>

</Project>

Chamando a tarefa embutida acima no arquivo Xamarin.Forms csproj no destino BeforeBuild:

  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
       Other similar extension points exist, see Microsoft.Common.targets.  -->
  <Import Project="SetBuildDate.targets" />
  <Target Name="BeforeBuild">
    <SetBuildDate FilePath="$(MSBuildProjectDirectory)\BuildMetadata.cs" />
  </Target>

A FilePathpropriedade é configurada para um BuildMetadata.csarquivo no projeto Xamarin.Forms que contém uma classe simples com uma propriedade string BuildDate, na qual o tempo de compilação será substituído:

public class BuildMetadata
{
    public static string BuildDate => "This can be any arbitrary string";
}

Adicione este arquivo BuildMetadata.csao projeto. Ele será modificado a cada compilação, mas de uma maneira que permita compilações repetidas (substituições repetidas), para que você possa incluí-lo ou omiti-lo no controle de origem, conforme desejado.

Você pode usar um evento de pós-construção do projeto para gravar um arquivo de texto no diretório de destino com a data e hora atuais. Você pode então ler o valor no tempo de execução. É um pouco hacky, mas deve funcionar.

Não tenho certeza, mas talvez o Build Incrementer ajude.

Uma pequena atualização sobre a resposta "New Way" de Jhon.

Você precisa criar o caminho em vez de usar a string CodeBase ao trabalhar com o ASP.NET/MVC

    var codeBase = assembly.GetName().CodeBase;
    UriBuilder uri = new UriBuilder(codeBase);
    string path = Uri.UnescapeDataString(uri.Path);

Você pode iniciar uma etapa extra no processo de criação que grava um carimbo de data em um arquivo que pode ser exibido.

Na guia de propriedades do projeto, observe a guia de eventos de construção. Existe uma opção para executar um comando de pré ou pós-compilação.

Eu usei a sugestão de Abdurrahim. No entanto, parecia dar um formato de horário estranho e também adicionou a abreviação do dia como parte da data de compilação; exemplo: dom 24/12/2017 13: 21: 05.43. Eu só precisava da data, então tive que eliminar o restante usando substring.

Depois de adicionar o echo %date% %time% > "$(ProjectDir)\Resources\BuildDate.txt"evento pré-compilação, fiz o seguinte:

string strBuildDate = YourNamespace.Properties.Resources.BuildDate;
string strTrimBuildDate = strBuildDate.Substring(4).Remove(10);

A boa notícia aqui é que funcionou.

Se esse for um aplicativo do Windows, você pode apenas usar o caminho executável do aplicativo: new System.IO.FileInfo (Application.ExecutablePath) .LastWriteTime.ToString ("aaaa.MM.dd")

Poderia ser Assembly execAssembly = Assembly.GetExecutingAssembly(); var creationTime = new FileInfo(execAssembly.Location).CreationTime; // "2019-09-08T14:29:12.2286642-04:00"