Git commit karmasını .Net dll'ye yerleştirin


102

Git'i sürüm kontrolüm olarak kullanarak bir C # uygulaması oluşturuyorum.

Uygulamamı oluştururken son kaydetme karmasını yürütülebilir dosyaya otomatik olarak yerleştirmenin bir yolu var mı?

Örneğin, commit karmasını konsola yazdırmak şuna benzer:

class PrintCommitHash
{
    private String lastCommitHash = ?? // What do I put here?
    static void Main(string[] args)
    {
        // Display the version number:
        System.Console.WriteLine(lastCommitHash );
    }
}

Dağıtılmış yürütülebilir dosyamın erişilebilir git deposu olmayacağından , bunun çalışma zamanında değil , derleme zamanında yapılması gerektiğini unutmayın .

C ++ ile ilgili bir soru burada bulunabilir .

DÜZENLE

@ mattanja'nın isteği üzerine, projelerimde kullandığım git hook betiğini gönderiyorum. Kurulum:

  • Kancalar linux kabuk betikleri olup, bunlar şu şekilde yerleştirilir: path_to_project \ .git \ hooks
  • Msysgit kullanıyorsanız , hooks klasörü zaten bazı örnek komut dosyaları içerir. Git onları çağırmak için komut adından '.sample' uzantısını kaldırın.
  • Kanca komut dosyalarının adları, onları çağıran olayla eşleşir. Benim durumumda, son teslim ve birleştirme sonrası değişiklikleri yaptım .
  • Benim AssemblyInfo.cs dosyası proje yolunun (aynı seviyede altında doğrudan .git klasörüne). 23 satır içeriyor ve 24'ünü oluşturmak için git kullanıyorum.

Benim linux bombardımanı biraz paslanmış olduğundan, komut dosyası, AssemblyInfo.cs'nin ilk 23 satırını geçici bir dosyaya okur , git karmasını son satıra yansıtır ve dosyayı yeniden AssemblyInfo.cs olarak yeniden adlandırır . Eminim bunu yapmanın daha iyi yolları vardır:

#!/bin/sh
cmt=$(git rev-list --max-count=1 HEAD)
head -23 AssemblyInfo.cs > AssemblyInfo.cs.tmp
echo [assembly: AssemblyFileVersion\(\"$cmt\"\)] >> AssemblyInfo.cs.tmp
mv AssemblyInfo.cs.tmp AssemblyInfo.cs

Bu yardımcı olur umarım.

Yanıtlar:


64

Sürümleri izlemek için git'te etiketleri kullanıyoruz.

git tag -a v13.3.1 -m "version 13.3.1"

Hash ile sürümü git'ten şu adresten alabilirsiniz:

git describe --long

Derleme işlemimiz git karmasını AssemblyInfo.cs dosyasının AssemblyInformationalVersion özniteliğine koyar:

[assembly: AssemblyInformationalVersion("13.3.1.74-g5224f3b")]

Derledikten sonra, sürümü Windows gezgininden görüntüleyebilirsiniz:

görüntü açıklamasını buraya girin

Ayrıca şu yolla programlı olarak da edinebilirsiniz:

var build = ((AssemblyInformationalVersionAttribute)Assembly
  .GetAssembly(typeof(YOURTYPE))
  .GetCustomAttributes(typeof(AssemblyInformationalVersionAttribute), false)[0])
  .InformationalVersion;

Burada YOURTYPE, AssemblyInformationalVersion özniteliğine sahip Meclis'teki herhangi bir Türdür.


14
Merhaba, bir ay önce sormak istedim ama yorum yapacak kadar sayım yoktu. "Derleme sürecimiz git karmasını AssemblyInfo.cs'nin AssemblyInformationalVersion özniteliğine koyar" dediğinizde, tam olarak neler oluyor? Sadece görsel stüdyo yapımı mı yapıyorsunuz, yoksa NAnt veya başka bir araç gibi mi kullanıyorsunuz?
John Jesus

3
Yapımızı otomatikleştirmek için yakut (tırmık) kullanıyoruz. Tırmık oluşturma görevlerimizden biri, çözümdeki tüm projelerde kullanılan CommonAssemblyInfo.cs dosyasını günceller. Görev, albacore - github.com/derickbailey/Albacore kullanarak CommonAssemblyInfo.cs dosyasını oluşturur. Görev kümelerinin oluşturduğu AssemblyInfo değerlerinden biri AssemblyInformationalVersion'dır.
Handcraftsman

3
@John Jesus - Lazy Badger'ın önerdiği gibi, kaydetme / birleştirme vb.'den sonra AssemblyInfo.cs'yi değiştirmek için git kancalarını da kullanabilirsiniz (bu benim yaptığım şeydi). Bkz kernel.org/pub/software/scm/git/docs/githooks.html
bavaza

Bilginize, Albacore yeni bir merkez organizasyonuna taşındı: github.com/Albacore/albacore
kornman00

5
Aşağıdaki proje https://github.com/jeromerg/NGitVersion , GlobalAssemblyInfo.*C # ve C ++ projeleri için derleme zamanında dosyalar oluşturmak için eksiksiz bir çözüm sunar : Varsayılan olarak, oluşturulan derleme sürümü şunları içerir: commit hash, yerel değişiklikleri gösteren bir bayrak ve bir havuz kökünden geçerli kaydetmeye kadar olan işlem miktarını sayan artış.
jeromerg

78

Bir gömebilirsiniz version.txt yürütülebilir içine dosya ve ardından okunan version.txt yürütülebilir dışında. Version.txt dosyasını oluşturmak için şunu kullanın:git describe --long

İşte adımlar:

Git'i çağırmak için bir Yapı Etkinliği kullanın

  • Projeye sağ tıklayın ve Özellikler'i seçin

  • Derleme Olaylarında, içeren Pre-Build olayını ekleyin (alıntılara dikkat edin):

    "C: \ Program Files \ Git \ bin \ git.exe" açıklamak --long> "$ (ProjectDir) \ version.txt"

    Bu, proje dizininizde bir version.txt dosyası oluşturacaktır .

Version.txt dosyasını yürütülebilir dosyaya yerleştirin

  • Projeye sağ tıklayın ve Mevcut Öğeyi Ekle'yi seçin
  • Version.txt dosyasını ekleyin (Tüm Dosyaları görmenizi sağlamak için dosya seçici filtresini değiştirin)
  • Version.txt eklendikten sonra , Çözüm Gezgini'nde üzerine sağ tıklayın ve Özellikler'i seçin.
  • Derleme Eylemini Katıştırılmış Kaynak olarak değiştirin
  • Her Zaman Kopyalamak için Çıktı Dizinine Kopyayı Değiştir
  • Ekle version.txt sizin için .gitignore dosyası

Gömülü metin dosyası sürüm dizesini okuyun

Gömülü metin dosyası sürüm dizesini okumak için bazı örnek kodlar:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Reflection;

namespace TryGitDescribe
{
    class Program
    {
        static void Main(string[] args)
        {
            string gitVersion= String.Empty;
            using (Stream stream = Assembly.GetExecutingAssembly()
                    .GetManifestResourceStream("TryGitDescribe." + "version.txt"))
            using (StreamReader reader = new StreamReader(stream))
            {
                gitVersion= reader.ReadToEnd();
            }

            Console.WriteLine("Version: {0}", gitVersion);
            Console.WriteLine("Hit any key to continue");
            Console.ReadKey();
        }
    }
}

9
Bu yaklaşım oldukça iyi çalışıyor. Yine de "git rev-parse --short HEAD" kullandım.
Brian Reiter

3
Ah iyi. "Git define" kullandım çünkü bir etiketiniz olduğunda (benim için) gerçekten ilginç; sürüm bilgisi etiketi artı etiket uygulandıktan sonra kaydetme sayısını içerir; Daha önce hiç SCM'de böyle bir şey görmemiştim.
John Jesus

7
git describe --dirtyGeliştiriciler kirli bir çalışma ağacıyla çalışırken bir bayrak ekleyen kullanıyorum .
paulmelnikow

2
@ TamásSzelei proje ad alanı TryGitDescribe'dır. Version.txt dosyası çalıştırılabilir / derleme yapısına gömüldükten sonra, onu çıkarmak için ad alanını başına eklemeniz gerekir.
John Jesus

2
Eksiksiz çözüm için teşekkür ederiz. Benim durumumda GetEntryAssemblymontaj alırdım. Her durumda GetName().Name, adı kodlamadan kaçınmak için arayabilirsiniz .
astrowalker

52

GÜNCELLEME:

Bu soruyu yanıtladığımdan beri işler değişti. Microsoft.NET.SdkBazı şartlar yerine getirildiği takdirde, iyi Nuget paket meta verilerine olduğu kadar hem montaj bilgilendirme versiyon karma taahhüt şimdi eklemek için destek içerir (bir sdk tarzı projesini kullanıyor olması gerekir anlamına gelir):

  1. <SourceRevisionId>Mülkiyet tanımlanmalıdır. Bu, aşağıdaki gibi bir hedef eklenerek yapılabilir:
<Target Name="InitializeSourceControlInformation" BeforeTargets="AddSourceRevisionToInformationalVersion">
    <Exec 
      Command="git describe --long --always --dirty --exclude=* --abbrev=8"
      ConsoleToMSBuild="True"
      IgnoreExitCode="False"
      >
      <Output PropertyName="SourceRevisionId" TaskParameter="ConsoleOutput"/>
    </Exec>
  </Target>

Bu hedef SourceRevisionId, kısaltılmış (8 karakter) karma olarak ayarlanacak bir komutu yürütür . BeforeTargets, bunun derleme bilgi sürümü oluşturulmadan önce çalıştırılmasına neden olur.

  1. Hashet paketi meta verilerine dahil etmek için <RepositoryUrl>, ayrıca tanımlanmalıdır.

  2. <SourceControlInformationFeatureSupported>özellik olmalıdır true, bu, nuget paketi görevinin SourceRevisionId'yi de almasına neden olur.

Bu yeni teknik daha temiz ve en tutarlı olduğu için, insanları MSBuildGitHash paketini kullanmaktan uzaklaştırırdım.

ORİJİNAL:

Bunu sizin için halledecek, projenize dahil edebileceğiniz basit bir nuget paketi oluşturdum: https://www.nuget.org/packages/MSBuildGitHash/

Bu nuget paketi "saf" bir MSBuild çözümü uygular. Bir nuget paketine bağlı kalmayı tercih etmezseniz, bu Hedefleri csproj dosyanıza kopyalayabilirsiniz ve git karmasını özel bir derleme özniteliği olarak içermelidir:

<Target Name="GetGitHash" BeforeTargets="WriteGitHash" Condition="'$(BuildHash)' == ''">
  <PropertyGroup>
    <!-- temp file for the git version (lives in "obj" folder)-->
    <VerFile>$(IntermediateOutputPath)gitver</VerFile>
  </PropertyGroup>

  <!-- write the hash to the temp file.-->
  <Exec Command="git -C $(ProjectDir) describe --long --always --dirty &gt; $(VerFile)" />

  <!-- read the version into the GitVersion itemGroup-->
  <ReadLinesFromFile File="$(VerFile)">
    <Output TaskParameter="Lines" ItemName="GitVersion" />
  </ReadLinesFromFile>
  <!-- Set the BuildHash property to contain the GitVersion, if it wasn't already set.-->
  <PropertyGroup>
    <BuildHash>@(GitVersion)</BuildHash>
  </PropertyGroup>    
</Target>

<Target Name="WriteGitHash" BeforeTargets="CoreCompile">
  <!-- names the obj/.../CustomAssemblyInfo.cs file -->
  <PropertyGroup>
    <CustomAssemblyInfoFile>$(IntermediateOutputPath)CustomAssemblyInfo.cs</CustomAssemblyInfoFile>
  </PropertyGroup>
  <!-- includes the CustomAssemblyInfo for compilation into your project -->
  <ItemGroup>
    <Compile Include="$(CustomAssemblyInfoFile)" />
  </ItemGroup>
  <!-- defines the AssemblyMetadata attribute that will be written -->
  <ItemGroup>
    <AssemblyAttributes Include="AssemblyMetadata">
      <_Parameter1>GitHash</_Parameter1>
      <_Parameter2>$(BuildHash)</_Parameter2>
    </AssemblyAttributes>
  </ItemGroup>
  <!-- writes the attribute to the customAssemblyInfo file -->
  <WriteCodeFragment Language="C#" OutputFile="$(CustomAssemblyInfoFile)" AssemblyAttributes="@(AssemblyAttributes)" />
</Target>

Burada iki hedef var. İlki, "GetGitHash", git karmasını BuildHash adlı bir MSBuild özelliğine yükler, bunu yalnızca BuildHash önceden tanımlanmamışsa yapar. Bu, isterseniz komut satırından MSBuild'e iletmenize olanak tanır. Bunu MSBuild'e şu şekilde iletebilirsiniz:

MSBuild.exe myproj.csproj /p:BuildHash=MYHASHVAL

İkinci hedef olan "WriteGitHash", karma değerini "CustomAssemblyInfo.cs" adlı geçici "obj" klasöründeki bir dosyaya yazar. Bu dosya şuna benzeyen bir satır içerecektir:

[assembly: AssemblyMetadata("GitHash", "MYHASHVAL")]

Bu CustomAssemblyInfo.cs dosyası derlemenizde derleneceğinden AssemblyMetadata, çalışma zamanında aramak için yansımayı kullanabilirsiniz . Aşağıdaki kod, AssemblyInfosınıf aynı derlemeye dahil edildiğinde bunun nasıl yapılabileceğini gösterir .

using System.Linq;
using System.Reflection;

public static class AssemblyInfo
{
    /// <summary> Gets the git hash value from the assembly
    /// or null if it cannot be found. </summary>
    public static string GetGitHash()
    {
        var asm = typeof(AssemblyInfo).Assembly;
        var attrs = asm.GetCustomAttributes<AssemblyMetadataAttribute>();
        return attrs.FirstOrDefault(a => a.Key == "GitHash")?.Value;
    }
}

Bu tasarımın bazı faydaları, proje klasörünüzdeki herhangi bir dosyaya dokunmaması, tüm değiştirilmiş dosyaların "obj" klasörü altında olmasıdır. Projeniz ayrıca Visual Studio içinden veya komut satırından aynı şekilde derlenir. Ayrıca projeniz için kolayca özelleştirilebilir ve csproj dosyanızla birlikte kaynak tarafından kontrol edilir.


2
Bu mükemmel çalıştı. Nuget paketini kurdum ve git karmasını kullanarak Assembly.GetExecutingAssembly(), ardından derlemeyi inceleyerek çıkardım CustomAttributes .
Gavin H

1
Sorum bu olsaydı, bu cevabı kabul ederdim. Harika şeyler.
Drew Noakes

1
@GavinH, nasıl aldın GitHash? Bu değerin var olduğunu görebiliyorum, ancak ada göre özel özniteliği elde etmenin saf bir yöntemi var mı? Görünüşe göre burada uzun bir sorgu yazmam gerekiyor CustomAttributes, teşekkürler.
Okan Koçyiğit

1
@ocanal evet - ne yazık ki bunu yapmanın CustomAttributes. Örneğin, hash dizesini çıkarmak için kullandığım işlev: pastebin.com/nVKGLhJC
Gavin H

2
@danmiser "UseMerge / SingleAssemblyName" ne olduğu hakkında hiçbir fikrim yok, bu yüzden size yardımcı olamam. Github.com/MarkPflug/MSBuildGitHash adresinde bir sorun oluşturun ve buna bir göz atabilirim (bu bir söz değil).
MarkPflug

14

Bunu yapmanın başka bir yolu, NetRevisionTool'u bazı On-Board Visual Studio sihri ile kullanmaktır. Bunu burada Visual Studio 2013 Professional Edition için göstereceğim, ancak bu diğer sürümlerle de çalışacak.

İlk önce NetRevisionTool'u indirin. NetRevisionTool.exe dosyasını PATH'inize dahil edin veya deponuza teslim edin ve bir görsel stüdyo ön-oluşturma ve bir derleme sonrası eylem oluşturup AssemblyInfo.cs dosyanızı değiştirin.

Git-hash'inizi AssemblyInformationVersion'a ekleyecek bir örnek şu olabilir: Proje ayarlarınızda:

görüntü açıklamasını buraya girin

Projenizin AssemblyInfo.cs dosyasında satırı değiştirir / eklersiniz:

[derleme: AssemblyInformationalVersion ("1.1. {dmin: 2015}. {chash: 6} {!} - {şube}")]

gösterilen ekran görüntüsünde External / bin klasöründeki NetRevisionTool.exe dosyasını kontrol ettim

Oluşturduktan sonra, ikili dosyanıza sağ tıklar ve özelliklere giderseniz, aşağıdaki gibi bir şey görmeniz gerekir:

görüntü açıklamasını buraya girin

Umarım bu dışarıdaki birine yardımcı olur


Benim için commit karması her zaman 00000 olarak bitiyor. Bunun, taahhüt edilmemiş değişikliklerim olduğu için olduğunu düşündüm ama yine de aynı. Herhangi bir fikrin neden?
Viktor

3
Sorun, NetRevision'ın git yürütülebilir dosyamı bulamamasıydı. Nedeni, SourceTree kullanıyoruz ve git bununla birlikte geliyor. Çözüm, git.exe ve libiconv-2.dll'yi% USERPROFILE% \ AppData \ Local \ Atlassian \ SourceTree \ git_local \ bin'den NetRevision.exe'yi içeren klasöre kopyalamaktı. Olayları da şu şekilde değiştirmem gerekiyordu: Pre-build event: cd $ (ProjectDir) Libraries NetRevisionTool.exe / patch $ (ProjectDir) Post-build event: cd $ (ProjectDir) Libraries NetRevisionTool.exe / restore $ (ProjectDir)
Viktor

Gelecekte referans olması için, proje repo URL'si bir süre önce github.com/ygoe/NetRevisionTool olarak değiştirildi . Daha fazla bilgi sınıflandırılmamış.software/apps/netrevisiontool adresinde de mevcuttur .
ygoe

14

Bence bu soru, adım adım eksiksiz bir cevap vermeye değer. Buradaki strateji, bir şablon dosyasını alan ve git etiketi + commit sayısı bilgisini içeren bir AssemblyInfo.cs dosyası oluşturan ön-oluşturma olaylarından bir powershell betiği çalıştırmaktır.

Adım 1: Project \ Properties klasöründe, orijinal AssemblyInfo.cs dosyanızı temel alan ancak şunları içeren bir AssemblyInfo_template.cs dosyası oluşturun:

[assembly: AssemblyVersion("$FILEVERSION$")]
[assembly: AssemblyFileVersion("$FILEVERSION$")]
[assembly: AssemblyInformationalVersion("$INFOVERSION$")]

Adım 2: Kaynağı: InjectGitVersion.ps1 adlı bir powershell komut dosyası oluşturun:

# InjectGitVersion.ps1
#
# Set the version in the projects AssemblyInfo.cs file
#


# Get version info from Git. example 1.2.3-45-g6789abc
$gitVersion = git describe --long --always;

# Parse Git version info into semantic pieces
$gitVersion -match '(.*)-(\d+)-[g](\w+)$';
$gitTag = $Matches[1];
$gitCount = $Matches[2];
$gitSHA1 = $Matches[3];

# Define file variables
$assemblyFile = $args[0] + "\Properties\AssemblyInfo.cs";
$templateFile =  $args[0] + "\Properties\AssemblyInfo_template.cs";

# Read template file, overwrite place holders with git version info
$newAssemblyContent = Get-Content $templateFile |
    %{$_ -replace '\$FILEVERSION\$', ($gitTag + "." + $gitCount) } |
    %{$_ -replace '\$INFOVERSION\$', ($gitTag + "." + $gitCount + "-" + $gitSHA1) };

# Write AssemblyInfo.cs file only if there are changes
If (-not (Test-Path $assemblyFile) -or ((Compare-Object (Get-Content $assemblyFile) $newAssemblyContent))) {
    echo "Injecting Git Version Info to AssemblyInfo.cs"
    $newAssemblyContent > $assemblyFile;       
}

Adım 3: InjectGitVersion.ps1 dosyasını bir BuildScripts klasöründeki çözüm dizininize kaydedin

Adım 4: Aşağıdaki satırı projenin Pre-Build olaylarına ekleyin

powershell -ExecutionPolicy ByPass -File  $(SolutionDir)\BuildScripts\InjectGitVersion.ps1 $(ProjectDir)

Adım 5: Projenizi oluşturun.

Adım 6: İsteğe bağlı olarak, git ignore dosyanıza AssemblyInfo.cs ekleyin


Git etiketlerinizi 1.2.3 gibi dosya sürümleriyle uyumlu yapmayı unutmayın. Daha karmaşık etiketleriniz varsa, yalnızca uyumlu kısımları ayrıştırmanız gerekecek
Atilio Jobson

2
Bir şablon kullanmak ve gerçek bir şablon kullanmak yerine, yerinde AssemblyInfo.csdeğişiklik yapabilir AssemblyInfo.cs, derleyebilir ve ardından AssemblyInfo.csson kaydedilen sürüme sıfırlama yapabilir . Dolayısıyla, depoda her zaman AssemblyInfo.cs, $..$yalnızca yapım zamanı ile ikame edilmiş olacaktı .
Kuba Wyrostek

Bu harika çalıştı. git describe --match "v[0-9]*" --long --always --dirtyBelirli etiketleri (sürüm numarası içerenler) filtrelemek ve çalışma ağacının temiz olup olmadığını belirtmek için kullanmayı bıraktım .
packoman

$gitVersion -match '[v](.*)-(\d+)-[g](.+)$';
RegEx'inizi

4

MSBuild için .NET Revizyon Görevi ve Visual Studio 2019 ile çalışmak artık çok kolay .

NuGet paketini Sınıflandırılmamış.NetRevisionTask'ı kurun , ardından AssemblyInfo.csdosyada olmasını istediğiniz bilgileri GitHub belgelerinde açıklandığı gibi yapılandırın .

Yalnızca son işlemenin karmasını istiyorsanız (uzunluk = 8):

[assembly: AssemblyInformationalVersion("1.0-{chash:8}")]

Projenizi / çözümünüzü oluşturun ve şuna benzer bir şeye sahip olacaksınız:

görüntü açıklamasını buraya girin


Bir NET.core uygulamasında biçimini yapılandırmak için eklemek PropertyGroupiçin .csproj README görülen benzeri dosyanın github.com/ygoe/NetRevisionTask/blob/master/README.md
sc911

3

Diğer cevap zaten git bitinden bahsettiği için, SHA'ya sahip olduğunuzda, AssemblyInfo.csprojenizin dosyasını bir ön-derleme kancasında oluşturmayı düşünebilirsiniz .

Bunu yapmanın bir yolu, AssemblyInfo.cs.tmplSHA'nız için $$ GITSHA $$ gibi bir yer tutucu içeren bir şablon dosyası oluşturmaktır , ör.

[assembly: AssemblyDescription("$$GITSHA$$")]

Ön derleme kancanız daha sonra bu yer tutucuyu değiştirmeli ve C # derleyicisinin alması için AssemblyInfo.cs dosyasını çıkarmalıdır.

Bunun SVN için SubWCRev kullanılarak nasıl yapılabileceğini görmek için bu yanıta bakın . Git için benzer bir şey yapmak zor olmamalı.

Diğer yollar, belirtildiği gibi bir "yapma aşaması" olabilir, yani benzer bir şey yapan bir MSBuild görevi yazın. Yine başka bir yol, DLL'yi bir şekilde işlemek olabilir (ildasm + ilasm say), ancak yukarıda bahsedilen seçeneklerin muhtemelen en kolayı olduğunu düşünüyorum.


@Wint hayır, oluşturulan AssemblyInfo.cs dosyasını git'e eklemeyin.
Yaparsanız,

3

Tam otomatik ve esnek bir yöntem için ödeme https://github.com/Fody/Stamp . Bunu Git projelerimiz için başarıyla kullandık (ve SVN projeleri için bu sürümü )

Güncelleme: Bu, Stamp.Fody artık korunmadığından geçerliliğini yitirmiştir.


1
Stamp.Fody'nin github sayfasında "Bu proje artık korunmuyor." yazıyor. Projeme dahil olmak üzere bir CA0052 ve CA0055
sc911

2

Tüm assemblyinfo dosyalarını commit hash ile güncellemek için bir powershell tek satırlık kullanabilirsiniz.

$hash = git describe --long --always;gci **/AssemblyInfo.* -recurse | foreach { $content = (gc $_) -replace "\[assembly: Guid?.*", "$&`n[assembly: AssemblyMetadata(`"commithash`", `"$hash`")]" | sc $_ }

1
  1. Umarım derleme zamanında harici programları nasıl çağıracağınızı ve çıktıyı nasıl keseceğinizi biliyorsunuzdur.
  2. Umarım git'in çalışma dizininde versiyonsuz dosyaları nasıl yoksayacağınızı biliyorsunuzdur.

@ Learath2'de belirtildiği gibi, çıktısı git rev-parse HEADsize düz karma verecektir.

Git-deposunda etiketleri kullanırsanız (ve etiketleri kullanırsanız, daha açıklayıcı ve okunaklı değil mi git rev-parse), çıktı şuradan alınabilir git describe(ayrıca daha sonra başarıyla kullanılır git checkout)

Rev-parse | tarifini çağırabilirsiniz:

  • bazıları sahne yapar
  • işlem sonrası kancada
  • leke filtresinde, leke / temiz filtreleri uygulama yolunu seçerseniz

0

Kabul edilen cevabın ve küçük bir ilavenin bir kombinasyonunu kullanıyorum. Oluşturmadan önce şablonları yeniden çalıştırmak için AutoT4 uzantısını ( https://marketplace.visualstudio.com/items?itemName=BennorMcCarthy.AutoT4 ) kurdum .

GIT'den sürüm almak

Ben git -C $(ProjectDir) describe --long --always > "$(ProjectDir)git_version.txt"proje özelliklerinde benim öncesi build olay. Gitignore'a git_version.txt ve VersionInfo.cs eklemek oldukça iyi bir fikirdir.

meta verilere sürüm yerleştirme

Projeme bir VersionInfo.ttşablon ekledim :

<#@ template debug="false" hostspecific="true" language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ import namespace="System.IO" #>
<#@ output extension=".cs" #>

using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

<#
if (File.Exists(Host.ResolvePath("git_version.txt")))
{
    Write("[assembly: AssemblyInformationalVersion(\""+ File.ReadAllText(Host.ResolvePath("git_version.txt")).Trim() + "\")]");
}else{
    Write("// version file not found in " + Host.ResolvePath("git_version.txt"));
}

#>

Artık git tag + hash'im "ProductVersion" içinde var.


0

Başka bir yanıta ( https://stackoverflow.com/a/44278482/4537127 ) atıfta bulunarak, AutoT4 olmadan VersionInfo.ttoluşturmak için metin şablonunu da kullandım AssemblyInformationalVersion.

(En azından C # WPF uygulamamda çalışıyor)

Sorun, Pre-build olaylarının şablon dönüştürmelerinden sonra çalıştırılmasıydı, bu nedenle klonlamadan sonra git_version.txtdosya orada değildi ve derleme başarısız oldu. Dönüşümün bir kez geçmesine izin vermek için manuel olarak oluşturulduktan sonra, dönüşümden sonra güncellendi ve her zaman bir commit geride kaldı .

.Csproj dosyasında iki ayarlama yapmak zorunda kaldım (bu en azından Visual Studio Community 2017 için geçerlidir)

1) Metin Dönüştürme Hedeflerini içe aktarın ve her derlemede çalışacak şablon dönüşümleri yapın: (Ref https://msdn.microsoft.com/en-us/library/ee847423.aspx )

<PropertyGroup>
    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">15.0</VisualStudioVersion>
    <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
    <TransformOnBuild>true</TransformOnBuild>
    <TransformOutOfDateOnly>false</TransformOutOfDateOnly>
</PropertyGroup>

ve sonra <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />

<Import Project="$(VSToolsPath)\TextTemplating\Microsoft.TextTemplating.targets" />

2) git describeÇalıştırmayı şablon dönüştürmelerinden önce yapın (böylece dönüştürüldüğünde git_version.txtorada olur VersionInfo.tt):

<Target Name="PreBuild" BeforeTargets="ExecuteTransformations">
  <Exec Command="git -C $(ProjectDir) describe --long --always --dirty &gt; $(ProjectDir)git_version.txt" />
</Target>

..Ve AssemblyInformationalVersion(Ref https://stackoverflow.com/a/7770189/4537127 ) almak için C # kodu

public string AppGitHash
{
    get
    {
        AssemblyInformationalVersionAttribute attribute = (AssemblyInformationalVersionAttribute)Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyInformationalVersionAttribute), false).FirstOrDefault();

        return attribute.InformationalVersion;
    }
}

..Ve oluşturulan dosyaları .gitignore'a ekleyin

VersionInfo.cs
git_version.txt

0

Başka bir yol da Pre-Build adımından Version.cs dosyası oluşturmaktır. Bunu, mevcut commit özetini basan küçük bir kavram kanıtı projesinde inceledim.

Bu proje https://github.com/sashoalm/GitCommitHashPrinter adresinde yüklendi .

Version.cs dosyasını oluşturan toplu iş kodu şudur:

@echo off

echo "Writing Version.cs file..."

@rem Pushd/popd are used to temporarily cd to where the BAT file is.
pushd $(ProjectDir)

@rem Verify that the command succeeds (i.e. Git is installed and we are in the repo).
git rev-parse HEAD || exit 1

@rem Syntax for storing a command's output into a variable (see https://stackoverflow.com/a/2340018/492336).
@rem 'git rev-parse HEAD' returns the commit hash.
for /f %%i in ('git rev-parse HEAD') do set commitHash=%%i

@rem Syntax for printing multiline text to a file (see https://stackoverflow.com/a/23530712/492336).
(
echo namespace GitCommitHashPrinter
echo {
echo     class Version
echo     {
echo         public static string CommitHash { get; set; } = "%commitHash%";
echo     }
echo }
)>"Version.cs"

popd    

0

Yer

<Target Name="UpdateVersion" BeforeTargets="CoreCompile">
  <Exec Command="php &quot;$(SolutionDir)build.php&quot; $(SolutionDir) &quot;$(ProjectDir)Server.csproj&quot;" />
</Target>

içinde YOUR_PROJECT_NAME.csproj

<?php

function between(string $string, string $after, string $before, int $offset = 0) : string{
    return substr($string, $pos = strpos($string, $after, $offset) + strlen($after),
        strpos($string, $before, $pos) - $pos);
}

$pipes = [];
$proc = proc_open("git rev-parse --short HEAD", [
    0 => ["pipe", "r"],
    1 => ["pipe", "w"],
    2 => ["pipe", "w"]
], $pipes, $argv[1]);

if(is_resource($proc)){
    $rev = stream_get_contents($pipes[1]);
    proc_close($proc);
}

$manifest = file_get_contents($argv[2]);
$version = between($manifest, "<Version>", "</Version>");
$ver = explode("-", $version)[0] . "-" . trim($rev);
file_put_contents($argv[2], str_replace($version, $ver, $manifest));

echo "New version generated: $ver" . PHP_EOL;
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.