Saat ini saya memiliki aplikasi yang menampilkan nomor build di jendela judulnya. Itu bagus dan bagus kecuali itu tidak ada artinya bagi sebagian besar pengguna, yang ingin tahu apakah mereka memiliki versi terbaru - mereka cenderung menyebutnya sebagai "Kamis lalu" daripada versi 1.0.8.4321.

Rencananya adalah meletakkan tanggal pembuatan di sana sebagai gantinya - Jadi "App dibangun pada 21/10/2009" misalnya.

Saya kesulitan menemukan cara terprogram untuk menarik tanggal pembuatan sebagai string teks untuk digunakan seperti ini.

Untuk nomor build, saya menggunakan:

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

setelah mendefinisikan bagaimana itu muncul.

Saya ingin sesuatu seperti itu untuk tanggal kompilasi (dan waktu, untuk poin bonus).

Pointer di sini sangat dihargai (permisi pun jika perlu), atau solusi yang lebih rapi ...

Jeff Atwood memiliki beberapa hal untuk dikatakan tentang masalah ini dalam Menentukan Build Date dengan cara yang sulit .

Metode yang paling dapat diandalkan ternyata mengambil cap waktu tautan dari header PE yang tertanam dalam file yang dapat dieksekusi - beberapa kode C # (oleh Joe Spivey) untuk itu dari komentar di artikel 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;
}

Contoh penggunaan:

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

UPDATE: Metode ini bekerja untuk .Net Core 1.0, tetapi berhenti bekerja setelah .Net Core 1.1 rilis (memberikan tahun acak dalam kisaran 1900-2020)

Tambahkan di bawah ini untuk baris perintah acara pra-bangun:

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

Tambahkan file ini sebagai sumber daya, sekarang Anda memiliki string 'BuildDate' di sumber daya Anda.

Untuk membuat sumber daya, lihat Cara membuat dan menggunakan sumber daya di .NET .

Jalan

Seperti yang ditunjukkan oleh @ c00000fd dalam komentar . Microsoft mengubah ini. Dan sementara banyak orang tidak menggunakan versi terbaru dari kompiler mereka, saya curiga perubahan ini membuat pendekatan ini menjadi buruk. Dan walaupun ini adalah latihan yang menyenangkan, saya akan merekomendasikan orang-orang untuk menanamkan tanggal pembuatan ke dalam biner mereka melalui cara lain yang diperlukan jika penting untuk melacak tanggal pembuatan dari biner itu sendiri.

Ini dapat dilakukan dengan beberapa pembuatan kode sepele yang mungkin merupakan langkah pertama dalam skrip build Anda. Itu, dan fakta bahwa alat ALM / Build / DevOps banyak membantu dengan ini dan harus lebih disukai daripada yang lain.

Saya meninggalkan sisa jawaban ini di sini hanya untuk tujuan historis.

Cara baru

Saya berubah pikiran tentang ini, dan saat ini menggunakan trik ini untuk mendapatkan tanggal pembuatan yang benar.

#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

Cara lama

Nah, bagaimana Anda menghasilkan angka membangun? Visual Studio (atau kompiler C #) benar-benar memberikan angka pembuatan dan revisi otomatis jika Anda mengubah atribut AssemblyVersion ke mis.1.0.*

Apa yang akan terjadi adalah bahwa bangunannya akan sama dengan jumlah hari sejak 1 Januari 2000 waktu setempat, dan untuk revisi sama dengan jumlah detik sejak tengah malam waktu setempat, dibagi 2.

lihat Konten Komunitas, Nomor Pembuatan dan Revisi Otomatis

mis. 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)

Tambahkan di bawah ini untuk baris perintah acara pra-bangun:

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

Tambahkan file ini sebagai sumber daya, sekarang Anda memiliki string 'BuildDate' di sumber daya Anda.

Setelah memasukkan file ke Resource (sebagai file teks publik), saya mengaksesnya melalui

string strCompTime = Properties.Resources.BuildDate;

Untuk membuat sumber daya, lihat Cara membuat dan menggunakan sumber daya di .NET .

Salah satu pendekatan yang saya kagum belum ada yang disebutkan adalah menggunakan T4 Text Templates untuk pembuatan kode.

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

Pro:

• Independen lokal
• Memungkinkan lebih dari sekedar waktu kompilasi

Cons:

• Hanya berlaku untuk perpustakaan tempat Anda mengontrol sumber
• Diperlukan mengkonfigurasi proyek Anda (dan membangun server, jika itu tidak mengambilnya) untuk menjalankan template dalam langkah pra-membangun . (Lihat juga T4 tanpa VS ).

Mengenai teknik menarik info tanggal / versi build dari byte header PE assembly, Microsoft telah mengubah parameter build default yang dimulai dengan Visual Studio 15.4. Default baru mencakup kompilasi deterministik, yang membuat stempel waktu yang valid dan nomor versi yang ditambahkan secara otomatis menjadi bagian dari masa lalu. Bidang cap waktu masih ada tetapi diisi dengan nilai permanen yang merupakan hash dari sesuatu atau lainnya, tetapi tidak ada indikasi waktu pembuatan.

Beberapa latar belakang rinci di sini

Bagi mereka yang memprioritaskan cap waktu yang berguna di atas kompilasi deterministik, ada cara untuk mengganti default baru. Anda dapat menyertakan tag dalam file .csproj dari kumpulan yang diminati sebagai berikut:

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

Pembaruan: Saya mendukung solusi template teks T4 yang dijelaskan dalam jawaban lain di sini. Saya menggunakannya untuk menyelesaikan masalah saya dengan bersih tanpa kehilangan manfaat dari kompilasi deterministik. Satu peringatan tentang hal itu adalah bahwa Visual Studio hanya menjalankan kompiler T4 ketika file .tt disimpan, bukan pada waktu membangun. Ini bisa menjadi canggung jika Anda mengecualikan hasil .cs dari kontrol sumber (karena Anda mengharapkannya dihasilkan) dan pengembang lain memeriksa kode. Tanpa resetting, mereka tidak akan memiliki file .cs. Ada paket di nuget (saya pikir disebut AutoT4) yang membuat bagian kompilasi T4 dari setiap build. Saya belum menghadapi solusi untuk ini selama penyebaran produksi, tetapi saya mengharapkan sesuatu yang serupa untuk memperbaikinya.

Saya hanya pemula C # jadi mungkin jawaban saya terdengar konyol - Saya menampilkan tanggal pembuatan dari tanggal file yang dapat dieksekusi terakhir ditulis ke:

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

Saya mencoba menggunakan metode File.GetCreationTime tetapi mendapat hasil aneh: tanggal dari perintah adalah 2012-05-29, tetapi tanggal dari Window Explorer menunjukkan 2012-05-23. Setelah mencari perbedaan ini, saya menemukan bahwa file itu mungkin dibuat pada 2012-05-23 (seperti yang ditunjukkan oleh Windows Explorer), tetapi disalin ke folder saat ini pada 2012-05-29 (seperti yang ditunjukkan oleh perintah File.GetCreationTime) - jadi untuk berada di sisi aman saya menggunakan perintah File.GetLastWriteTime.

Zalek

Banyak jawaban bagus di sini tapi saya merasa saya bisa menambahkan sendiri karena kesederhanaan, kinerja (membandingkan dengan solusi terkait sumber daya) lintas platform (bekerja dengan Net Core juga) dan menghindari alat pihak ke-3. Cukup tambahkan target msbuild ini ke 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>

dan sekarang Anda miliki Builtin.CompileTimeatau new DateTime(Builtin.CompileTime, DateTimeKind.Utc)jika Anda membutuhkannya.

ReSharper tidak akan menyukainya. Anda dapat mengabaikannya atau menambahkan kelas parsial ke proyek juga, tetapi tetap berhasil.

Untuk proyek .NET Core, saya mengadaptasi jawaban Postlagerkarte untuk memperbarui bidang Hak Cipta perakitan dengan tanggal pembuatan.

Edit csproj secara langsung

Berikut ini dapat ditambahkan langsung ke yang pertama PropertyGroupdi csproj:

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

Alternatif: Properti Proyek Visual Studio

Atau tempelkan ekspresi bagian dalam langsung ke bidang Hak Cipta di bagian Paket properti proyek di Visual Studio:

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

Ini bisa sedikit membingungkan, karena Visual Studio akan mengevaluasi ekspresi dan menampilkan nilai saat ini di jendela, tetapi juga akan memperbarui file proyek dengan tepat di belakang layar.

Solusi-lebar melalui Directory.Build.props

Anda dapat memasukkan <Copyright>elemen di atas ke dalam Directory.Build.propsfile di root solusi Anda, dan menerapkannya secara otomatis ke semua proyek dalam direktori, dengan asumsi setiap proyek tidak memberikan nilai Hak Cipta sendiri.

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

Directory.Build.props: Sesuaikan bangunan Anda

Keluaran

Contoh ekspresi akan memberi Anda hak cipta seperti ini:

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

Pengambilan

Anda dapat melihat informasi hak cipta dari properti file di Windows, atau ambil saat runtime:

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

Console.WriteLine(version.LegalCopyright);

Metode di atas dapat di-tweak untuk rakitan yang sudah dimuat dalam proses dengan menggunakan gambar file dalam memori (bukan membaca ulang dari penyimpanan):

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

Bagi siapa pun yang perlu mendapatkan waktu kompilasi di 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);
            }
        }
    }

Bagi siapa pun yang perlu mendapatkan waktu kompilasi di 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;
    }

CATATAN: Dalam semua kasus Anda berjalan di kotak pasir, sehingga Anda hanya akan bisa mendapatkan waktu kompilasi rakitan yang Anda gunakan dengan aplikasi Anda. (yaitu ini tidak akan bekerja pada apa pun di GAC).

Pada 2018 beberapa solusi di atas tidak berfungsi lagi atau tidak bekerja dengan .NET Core.

Saya menggunakan pendekatan berikut yang sederhana dan berfungsi untuk proyek .NET Core 2.0 saya.

Tambahkan berikut ini ke .csproj Anda di dalam PropertyGroup:

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

Ini mendefinisikan PropertyFunction yang bisa Anda akses di perintah pre build Anda.

Pra-bangun Anda terlihat seperti ini

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

Setel properti BuildTimeStamp.txt ke sumber daya Tertanam.

Sekarang Anda dapat membaca cap waktu seperti ini

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

Opsi yang tidak dibahas di sini adalah untuk memasukkan data Anda sendiri ke AssemblyInfo.cs, bidang "AssemblyInformationalVersion" tampaknya tepat - kami memiliki beberapa proyek di mana kami melakukan sesuatu yang mirip dengan langkah pembangunan (namun saya tidak sepenuhnya senang dengan cara yang berhasil jadi tidak benar-benar ingin mereproduksi apa yang kita punya).

Ada artikel tentang subjek di codeproject: http://www.codeproject.com/KB/dotnet/Customizing_csproj_files.aspx

Saya membutuhkan solusi universal yang bekerja dengan proyek NETStandard di platform apa pun (iOS, Android, dan Windows.) Untuk mencapai ini, saya memutuskan untuk secara otomatis menghasilkan file CS melalui skrip PowerShell. Berikut ini skrip 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

Simpan file PowerScript sebagai GenBuildDate.ps1 dan tambahkan proyek Anda. Terakhir, tambahkan baris berikut ke acara Pra-Bangun Anda:

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

Pastikan BuildDate.cs termasuk dalam proyek Anda. Bekerja seperti juara di OS apa pun!

Saya hanya melakukan:

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

Anda dapat menggunakan proyek ini: https://github.com/dwcullop/BuildInfo

Ini memanfaatkan T4 untuk mengotomatiskan timestamp tanggal pembuatan. Ada beberapa versi (cabang berbeda) termasuk satu yang memberi Anda Git Hash dari cabang yang sedang diperiksa, jika Anda menyukai hal-hal semacam itu.

Pengungkapan: Saya menulis modul.

Pendekatan lain yang ramah PCL adalah menggunakan tugas inline MSBuild untuk mengganti waktu pembuatan menjadi string yang dikembalikan oleh properti di aplikasi. Kami menggunakan pendekatan ini dengan sukses di aplikasi yang memiliki proyek Xamarin.Forms, Xamarin.Android, dan Xamarin.iOS.

EDIT:

Disederhanakan dengan memindahkan semua logika ke dalam SetBuildDate.targetsfile, dan menggunakan Regexalih-alih mengganti string sederhana sehingga file dapat dimodifikasi oleh setiap build tanpa "reset".

Definisi tugas inline MSBuild (disimpan dalam file SetBuildDate.targets lokal untuk proyek Xamarin.Forms untuk contoh ini):

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

Menjalankan tugas inline di atas dalam file camarx Xamarin.Forms di target 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>

The FilePathproperti diatur ke BuildMetadata.csfile dalam proyek Xamarin.Forms yang berisi kelas sederhana dengan properti string BuildDate, di mana waktu membangun akan diganti:

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

Tambahkan file ini BuildMetadata.cske proyek. Ini akan dimodifikasi oleh setiap build, tetapi dengan cara yang memungkinkan build berulang (replacements berulang), jadi Anda dapat memasukkan atau menghilangkannya dalam kontrol sumber seperti yang diinginkan.

Anda bisa menggunakan acara post-build proyek untuk menulis file teks ke direktori target Anda dengan datetime saat ini. Anda kemudian bisa membaca nilainya pada saat run-time. Agak aneh, tetapi harus berhasil.

Saya tidak yakin, tapi mungkin Build Incrementer membantu.

Pembaruan kecil pada jawaban "Cara Baru" dari Jhon.

Anda perlu membangun jalur alih-alih menggunakan string CodeBase saat bekerja dengan ASP.NET/MVC

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

Anda bisa meluncurkan langkah ekstra dalam proses pembuatan yang menulis cap tanggal ke file yang kemudian dapat ditampilkan.

Pada tab properti projek lihat pada tab build event. Ada opsi untuk menjalankan perintah build pre atau post.

Saya menggunakan saran Gus Dur. Namun, sepertinya memberikan format waktu yang aneh dan juga menambahkan singkatan untuk hari itu sebagai bagian dari tanggal pembuatan; contoh: Minggu 12/24/2017 13: 21: 05.43. Saya hanya perlu tanggal saja jadi saya harus menghilangkan sisanya menggunakan substring.

Setelah menambahkan echo %date% %time% > "$(ProjectDir)\Resources\BuildDate.txt"ke acara pra-bangun, saya hanya melakukan hal berikut:

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

Kabar baiknya di sini adalah bahwa itu berhasil.

Jika ini adalah aplikasi windows, Anda bisa menggunakan jalur eksekusi aplikasi: new System.IO.FileInfo (Application.ExecutablePath) .LastWriteTime.ToString ("yyyy.MM.dd")

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