Kann ich erhöht automatisch die Datei Build-Version, wenn Visual Studio?

https://stackoverflow.com/questions/356543

21-08-2019
|

Frage

Ich habe mich nur gefragt, wie ich kann automatisch erhöhe den Build (und Version?) Meine Dateien mit Visual Studio (2005).

Wenn ich die Eigenschaften sehen von sagen C:\Windows\notepad.exe, die Registerkarte Version gibt „Dateiversion: 5.1.2600.2180“. Ich möchte diese kühlen Zahlen in der Version bekommen meine dll auch ist, nicht Version 1.0.0.0, die wären sich ehrlich ein bisschen langweilig ist.

Ich habe versucht, ein paar Dinge, aber es scheint nicht, out-of-box-Funktionalität zu sein, oder vielleicht auch nur an der falschen Stelle suche ich (wie üblich).

Ich arbeite mit hauptsächlich Webprojekte ....

Ich sah beide:

, und ich kann es so viel Mühe nicht glauben, etwas zu tun, ist gängige Praxis.

EDIT: Es ist nicht so weit in VS2005 arbeite ich sagen kann ( http: // www. codeproject.com/KB/dotnet/AutoIncrementVersion.aspx )

Lösung

In Visual Studio 2008, die folgenden Werke.

Hier finden Sie die Datei AssemblyInfo.cs und finden diese 2 Zeilen:

[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

Sie könnten versuchen, zu ändern, dies zu:

[assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyFileVersion("1.0.*")]

Aber das wird Sie nicht das gewünschte Ergebnis, werden Sie mit einer Produktversion von 1.0 enden. * und einer Dateiversion von 1.0.0.0 . Nicht das, was Sie wollen!

Wenn Sie jedoch die zweite dieser Leitungen entfernen und nur haben:

[assembly: AssemblyVersion("1.0.*")]

Dann wird der Compiler die Dateiversion auf die Produktversion, um gleich, und Sie werden Ihr gewünschtes Ergebnis einer automatischen Erhöhung Produkt- und Dateiversion, die synchron sind zu bekommen. Z.B. 1.0.3266.92689

Andere Tipps

, um die Datei AssemblyInfo.cs öffnen und ändern

// You can specify all the values or you can default the Build and Revision Numbers 
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

[assembly: AssemblyVersion("1.0.*")]
//[assembly: AssemblyFileVersion("1.0.0.0")]

Sie können dies in IDE tun, indem sie projizieren gehen -> Eigenschaften -> Montageinformation

Dies wird jedoch nur auf Autoinkrement erlauben die Montage-Version und geben Sie die

Montag Dateiversion: Ein Platzhalter ( "*") ist in diesem Bereich nicht erlaubt

Meldungsfeld, wenn Sie versuchen, eine * in der Datei Versionsfeld platzieren.

So einfach die AssemblyInfo.cs öffnen und tut es manuell.

Eine weitere Option Versionsnummern für die Änderung in jedem Build ist die Version Aufgabe MSBuild zu verwenden .Community.Tasks . Nur ihre Installer herunterladen, installieren, dann den folgenden Code anzupassen und es nach <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" /> in Ihrer .csproj Datei einfügen:

<Import Project="$(MSBuildExtensionsPath)\MSBuildCommunityTasks\MSBuild.Community.Tasks.Targets" />
<Target Name="BeforeBuild">
    <Version VersionFile="Properties\version.txt" Major="1" Minor="0" BuildType="Automatic" StartDate="12/31/2009" RevisionType="BuildIncrement">
      <Output TaskParameter="Major" PropertyName="Major" />
      <Output TaskParameter="Minor" PropertyName="Minor" />
      <Output TaskParameter="Build" PropertyName="Build" />
      <Output TaskParameter="Revision" PropertyName="Revision" />
    </Version>
    <AssemblyInfo CodeLanguage="CS"
                  OutputFile="Properties\VersionInfo.cs"
                  AssemblyVersion="$(Major).$(Minor)"
                  AssemblyFileVersion="$(Major).$(Minor).$(Build).$(Revision)" />
</Target>

Hinweis: Passen Sie die Startdate-Eigenschaft auf Ihren Standort. Es ist derzeit nicht die invariante Kultur verwenden.

Für das dritte Build am 14. Januar 2010 das schafft eine VersionInfo.cs mit folgendem Inhalt:

[assembly: AssemblyVersion("1.0")]
[assembly: AssemblyFileVersion("1.0.14.2")]

Diese Datei dann zu dem Projekt hinzugefügt werden muss (über Vorhandenes Element hinzufügen ) und die AssemblyVersion und AssemblyFileVersion Linien von AssemblyInfo.cs entfernt werden.

Die verschiedenen Algorithmen zum Ändern der Version Komponenten werden in $(MSBuildExtensionsPath)\MSBuildCommunityTasks\MSBuild.Community.Tasks.chm beschrieben und Version Eigenschaften .

I mit einer Lösung ähnlich wie Christen kam aber ohne die Gemeinschafts MSBuild Aufgaben abhängig, das ist für mich keine Option, da will ich nicht diese Aufgaben für alle unsere Entwickler installieren.

I-Code bin zu erzeugen und zu einer Baugruppe zusammenzustellen und will Autoinkrement-Versionsnummern. Allerdings kann ich nicht den VS 6.0 verwenden. * Assembly Trick, wie es auto-Schritte bauen Zahlen jeden Tag und Pausen Kompatibilität mit Baugruppen, die eine ältere Build-Nummer verwenden. Stattdessen mag ich eine hartcodierte Assembly haben, aber eine automatische Erhöhung Assembly. Ich habe dies erreicht, indem Assembly in der AssemblyInfo.cs spezifiziert und eine VersionInfo.cs in MSBuild wie diese zu erzeugen,

  <PropertyGroup>
    <Year>$([System.DateTime]::Now.ToString("yy"))</Year>
    <Month>$([System.DateTime]::Now.ToString("MM"))</Month>
    <Date>$([System.DateTime]::Now.ToString("dd"))</Date>
    <Time>$([System.DateTime]::Now.ToString("HHmm"))</Time>
    <AssemblyFileVersionAttribute>[assembly:System.Reflection.AssemblyFileVersion("$(Year).$(Month).$(Date).$(Time)")]</AssemblyFileVersionAttribute>
  </PropertyGroup>
  <Target Name="BeforeBuild">
    <WriteLinesToFile File="Properties\VersionInfo.cs" Lines="$(AssemblyFileVersionAttribute)" Overwrite="true">
    </WriteLinesToFile>
  </Target>

Dies wird ein VersionInfo.cs Datei mit einem Assembly-Attribute für Assembly erzeugen, wo die Version des Schema YY.MM.DD.TTTT mit dem Erstellungsdatum folgt. Sie müssen diese Datei in Ihrem Projekt enthalten und bauen damit.

Installieren Sie die Version Erhöhungsschritte beim Aufbau -in hinzuzufügen. Es gibt Ihnen viel mehr Kontrolle als die * Option.

Um die Versionsnummern zu erhalten versuchen

 System.Reflection.Assembly assembly = System.Reflection.Assembly.GetExecutingAssembly();
 System.Reflection.AssemblyName assemblyName = assembly.GetName();
 Version version = assemblyName.Version;

die Versionsnummer setzen, erstellen / bearbeiten AssemblyInfo.cs

 [assembly: AssemblyVersion("1.0.*")]
 [assembly: AssemblyFileVersion("1.0.*")]

Auch als eine Randnotiz, die dritte Zahl ist die Anzahl der Tage seit 2000.02.01 und die vierte Zahl ist die Hälfte der Menge der gesamten Sekunden in dem Tag. Also, wenn Sie um Mitternacht kompilieren sollte Null sein.

Es ist eine Visual Studio-Erweiterung Automatische Versionen die 2012 Visual Studio unterstützt, 2013, 2015 und 2017.

Screen Shots

a * in der Versionsnummer in Assembly einstellen oder unter Projekteigenschaften wie in den anderen Beiträgen beschrieben nicht mit allen Versionen von Visual Studio / .NET arbeiten.

Afaik es nicht in VS 2005 (aber in VS 2003 und VS 2008) funktioniert. Für VS 2005 können Sie die folgende verwenden: Auto Increment Visual Studio 2005-Version Build und Versionsnummer auf der Kompilierung Zeit .

Aber beachten Sie, dass die Versionsnummer ändert nicht automatisch für Assemblys mit starken Namen empfohlen. Der Grund dafür ist, dass alle Hinweise auf eine solche Anordnung muss die referenzierte Assembly jedes Mal aktualisiert werden, wird aufgrund der Tatsache, dass wieder aufgebaut Assembly mit starkem Namen Referenzen sind immer ein Hinweis auf eine bestimmte Baugruppe Version. Microsoft selbst die Version ändern Anzahl der .NET Framework-Baugruppen nur dann, wenn es Änderungen in Schnittstellen. (NB:. Ich bin immer noch für den Link in MSDN suchen, wo ich das gelesen)

Um (Datetime) Informationen in die Assembly Eigenschaft erhöht wird, was den Vorteil nicht brechen alle Abhängigkeiten hat.

Aufbauend auf Boog-Lösung (nicht für mich arbeiten, vielleicht wegen VS2008?), Können Sie eine Kombination aus einem Pre-Build-Ereignisse eine Datei zu erzeugen, und fügten hinzu, dass die Datei (einschließlich ihrer Version Eigenschaften) und dann mit einer Art und Weise nutzen können lesen wieder die Werte aus. Das ist ..

Pre-Build-Ereignis:

echo [assembly:System.Reflection.AssemblyFileVersion("%date:~-4,4%.%date:~-7,2%%date:~-10,2%.%time:~0,2%%time:~3,2%.%time:~-5,2%")] > $(ProjectDir)Properties\VersionInfo.cs

Fügen Sie die resultierende Datei VersionInfo.cs (Eigenschaften Unterordner) in Ihr Projekt

-Code erhalten Datum zurück (Jahre bis Sekunden):

var version = assembly.GetName().Version;
var fileVersionString = System.Diagnostics.FileVersionInfo.GetVersionInfo(assembly.Location).FileVersion;
Version fileVersion = new Version(fileVersionString);
var buildDateTime = new DateTime(fileVersion.Major, fileVersion.Minor/100, fileVersion.Minor%100, fileVersion.Build/100, fileVersion.Build%100, fileVersion.Revision);

Nicht sehr komfortabel .. auch, ich weiß nicht, ob es eine Menge erzeugt kraft neu erstellt (da eine Datei immer ändert).

Sie könnten machen es klüger zum Beispiel, wenn Sie nur die VersionInfo.cs aktualisieren alle paar Minuten / Stunden-Datei (durch eine temporäre Datei verwenden und dann Kopieren / die wirklichen VersionInfo.cs überschrieben wird, wenn eine Änderung groß genug erkannt wird). Ich habe das mal ziemlich erfolgreich.

Stellen Sie die Versionsnummer „1.0. *“ Und es wird in den letzten zwei Ziffern mit dem Datum (in Tagen ab einem gewissen Punkt) und die Zeit (die Hälfte der Sekunden ab Mitternacht)

automatisch füllen

Es ist in Ihrer Projekteigenschaft unter Veröffentlichen

(~ http://screencast.com/t/Vj7rhqJO )

Kuchen Assembly Dateien Patchen unterstützt. Mit Kuchen in den Händen haben Sie unendlich viele Möglichkeiten, automatische Version Inkrementieren zu implementieren.

Ein einfaches Beispiel der Version wie C # Compiler Erhöhen tut:

Setup(() =>
{
    // Executed BEFORE the first task.
    var datetimeNow = DateTime.Now;
    var daysPart = (datetimeNow - new DateTime(2000, 1, 1)).Days;
    var secondsPart = (long)datetimeNow.TimeOfDay.TotalSeconds/2;
    var assemblyInfo = new AssemblyInfoSettings
    {
        Version = "3.0.0.0",
        FileVersion = string.Format("3.0.{0}.{1}", daysPart, secondsPart)
    };
    CreateAssemblyInfo("MyProject/Properties/AssemblyInfo.cs", assemblyInfo);
});

Hier:

Version - ist die Montage-Version. Am günstigsten ist es Hauptversionsnummer sperren und lassen mit Nullen verbleibenden (wie „1.0.0.0“).
Fileversion - ist Baugruppendatei Version

Beachten Sie, dass Sie nicht nur Versionen aber patchen können auch alle anderen notwendigen Informationen .

Zum Projekt | Eigenschaften und dann Montagehinweise und dann Assembly Version und legte einen * in der letzten oder der zweiten bis letzten Box (man kann nicht Autoinkrement der Haupt- oder Nebenkomponenten).

Mit der Assembly Aufgabe der MSBuild Community-Aufgaben ( http://msbuildtasks.tigris.org/ ) Projekt, und in Ihre CSPROJ / .vbproj Datei integriert werden.

Es hat eine Reihe von Optionen, einschließlich einen der Versionsnummer auf das Datum und die Uhrzeit zu binden.

Wie Sie die Version `{major}.{year}.1{date}.1{time}` bekommen

Dieses ist bei der Durchführung experimenteller, aber ich mag es. Inspiriert von Jeff Atwood @ Coding ( Link ).

Die resultierende Versionsnummer wird 1.2016.10709.11641 (Bedeutung 2016.07.09 16:41), die erlaubt

arme mans Null padding (mit dem dummen führenden 1s)
nahezu Menschen lesbaren local Datetime in die Versionsnummer eingebettet
verlassen Hauptversion allein für wirklich großen Bruch Änderungen.

Fügen Sie ein neues Element zu Ihrem Projekt, wählen Sie Allgemein -.> Textvorlagen, nennen Sie es so etwas wie CustomVersionNumber und (gegebenenfalls) einen kurzen Kommentar zum AssemblyVersion und AssemblyFileVersion in Properties/AssemblyInfo.cs out

Wenn dann diese Datei zu speichern, oder das Projekt baut, wird dies eine .cs Datei regeneriert unter der erstellten .tt Datei, die sie als Unterpunkt.

<#@ template language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>

//
// This code was generated by a tool. Any changes made manually will be lost
// the next time this code is regenerated.
//

using System.Reflection;

<#
    var date = DateTime.Now;
    int major = 1;
    int minor = date.Year;
    int build = 10000 + int.Parse(date.ToString("MMdd"));
    int revision = 10000 + int.Parse(date.ToString("HHmm"));
#>

[assembly: AssemblyVersion("<#= $"{major}.{minor}.{build}.{revision}" #>")]
[assembly: AssemblyFileVersion("<#= $"{major}.{minor}.{build}.{revision}" #>")]

Vielleicht, für diese Aufgabe, können Sie folgenden Code verwenden:

    private bool IncreaseFileVersionBuild()
    {
        if (System.Diagnostics.Debugger.IsAttached)
        {
            try
            {
                var fi = new DirectoryInfo(AppDomain.CurrentDomain.BaseDirectory).Parent.Parent.GetDirectories("Properties")[0].GetFiles("AssemblyInfo.cs")[0];
                var ve = System.Diagnostics.FileVersionInfo.GetVersionInfo(System.Reflection.Assembly.GetExecutingAssembly().Location);
                string ol = ve.FileMajorPart.ToString() + "." + ve.FileMinorPart.ToString() + "." + ve.FileBuildPart.ToString() + "." + ve.FilePrivatePart.ToString();
                string ne = ve.FileMajorPart.ToString() + "." + ve.FileMinorPart.ToString() + "." + (ve.FileBuildPart + 1).ToString() + "." + ve.FilePrivatePart.ToString();
                System.IO.File.WriteAllText(fi.FullName, System.IO.File.ReadAllText(fi.FullName).Replace("[assembly: AssemblyFileVersion(\"" + ol + "\")]", "[assembly: AssemblyFileVersion(\"" + ne + "\")]"));
                return true;
            }
            catch
            {
                return false;
            }
        }
        return false;
    }

und es von der Form Laden nennen.
Mit diesem Code können Sie in AssemblyInfo.cs einen Teil Dateiinfo aktualisieren (aber Sie müssen „Standard“ Verzeichnisstruktur verwenden).

AssemblyInfoUtil . Kostenlos. Open-Source.

Ich verwende diesen Ansatz https://stackoverflow.com/a/827209/3975786 durch die T4-Platzierung Vorlage in einem „Lösung Items“ und deren Verwendung mit „Add as-Link“ in jedem Projekt.

Vielleicht ist es zu spät, hier aber die Hoffnung zu beantworten, dass jemand hektisches Problem lösen wird.

Eine automatische Art und Weise Montageversion alle Ihre Projekte mit Powershell-Skript zu ändern. Dieser Artikel wird lösen viele Ihrer Probleme.

Jedes Mal, wenn ich ein Build es auto-Schritte die geringstwertige Ziffer.

Ich habe keine Ahnung, wie die andere zu aktualisieren, aber man sollte zumindest das schon sehen werden ...

Ich habe eine Anwendung erstellt automatisch die Dateiversion zu erhöhen.

Download Anwendung
die folgende Zeile Ereignis Befehlszeile Pre-Build

C: \ temp \ IncrementFileVersion.exe $ (SolutionDir) \ Properties \ AssemblyInfo.cs
Erstellen Sie das Projekt

Um es einfach nur die App Nachrichten aus, wenn ein Fehler auftritt, um zu bestätigen, es funktionierte gut Sie die Dateiversion in ‚Montagehinweise‘

überprüfen müssen

. Hinweis: Sie werden die Lösung in Visual Studio neu geladen werden müssen für Taste ‚Montagehinweise‘, um die Felder zu füllen, aber die Ausgabedatei wird die aktualisierte Version hat

Für Anregungen und Anfragen kontaktieren Sie mich bitte an telson_alva@yahoo.com

In Visual Studio 2019

Es war nicht genug für das Hinzufügen von mir

[assembly: AssemblyVersion("1.0.*")]

Beim Bau es wirft mir diesen Fehler

Das angegebene Version Zeichenfolge entspricht nicht das erforderliche Format

Lösung

Das Format wurde schließlich akzeptiert, nachdem ich Deterministic gesetzt in False project.csproj

<Deterministic>false</Deterministic>

Edit:

Aus irgendeinem Grund Deterministic Einstellung meiner Konfigurationsdatei laden sie False vermasselt und es an verschiedenen Orten zu speichern.

Umgehung:

ich ein Setup Postbuildereignis der Revisionsnummer zu erhöhen:

Post-Build-Event-Batch-Skript

Dies ruft ein Powershell-Skript namens autoincrement_version.ps1 als Argument übergeben, den Weg der AssemblyInfo.cs

if $(ConfigurationName) == Release (
PowerShell -ExecutionPolicy RemoteSigned $(ProjectDir)autoincrement_version.ps1 '$(ProjectDir)My Project\AssemblyInfo.cs'
)

Poweshell script

Es autoincrements die Revisionsnummer mit Regex

param( [string]$file );
  $regex_revision = '(?<=Version\("(?:\d+\.)+)(\d+)(?="\))'
  $found = (Get-Content $file) | Select-String -Pattern $regex_revision
  $revision = $found.matches[0].value
  $new_revision = [int]$revision + 1
  (Get-Content $file) -replace $regex_revision, $new_revision | Set-Content $file -Encoding UTF8

Lizenziert unter: CC-BY-SA mit Zuschreibung

Nicht verbunden mit StackOverflow

Kann ich erhöht automatisch die Datei Build-Version, wenn Visual Studio?

Wie Sie die Version {major}.{year}.1{date}.1{time} bekommen

In Visual Studio 2019

Lösung

Edit:

Umgehung:

Post-Build-Event-Batch-Skript

Poweshell script

Wie Sie die Version `{major}.{year}.1{date}.1{time}` bekommen