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

Wenn ich die Eigenschaften von say nachschlage C:\Windows\notepad.exe, gibt die Registerkarte Version "Dateiversion: 5.1.2600.2180" an. Ich möchte diese coolen Zahlen auch in der Version meiner DLLs haben, nicht in Version 1.0.0.0, was ein bisschen langweilig ist.

Ich habe ein paar Dinge ausprobiert, aber es scheint keine Out-of-Box-Funktionalität zu sein, oder ich suche nur an der falschen Stelle (wie üblich).

Ich arbeite hauptsächlich mit Webprojekten ....

Ich sah beide an:

1. http://www.codeproject.com/KB/dotnet/Auto_Increment_Version.aspx
2. http://www.codeproject.com/KB/dotnet/build_versioning.aspx

und ich konnte nicht glauben, dass es so üblich ist, etwas zu tun.

BEARBEITEN: Es funktioniert nicht in VS2005, soweit ich das beurteilen kann ( http://www.codeproject.com/KB/dotnet/AutoIncrementVersion.aspx ).

In Visual Studio 2008 funktioniert Folgendes.

Suchen Sie die Datei AssemblyInfo.cs und suchen Sie diese 2 Zeilen:

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

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

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

Dies führt jedoch nicht zum gewünschten Ergebnis. Sie erhalten eine Produktversion von 1.0. * Und eine Dateiversion von 1.0.0.0 . Nicht was du willst!

Wenn Sie jedoch die zweite dieser Zeilen entfernen und nur Folgendes haben:

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

Anschließend setzt der Compiler die Dateiversion auf die Produktversion und Sie erhalten das gewünschte Ergebnis einer automatisch inkrementierten Produkt- und Dateiversion, die synchron sind. ZB 1.0.3266.92689

Öffnen Sie die Datei AssemblyInfo.cs und ändern Sie sie

// 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")]

zu

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

Sie können dies in IDE tun, indem Sie zu Projekt -> Eigenschaften -> Baugruppeninformationen gehen

Auf diese Weise können Sie jedoch nur die Assembly-Version automatisch inkrementieren und erhalten die

Assembly File Version: Ein Platzhalter ("*") ist in diesem Feld nicht zulässig

Meldungsfeld, wenn Sie versuchen, ein * in das Feld für die Dateiversion einzufügen.

Öffnen Sie einfach die Datei assemblyinfo.cs und führen Sie sie manuell aus.

Eine weitere Option zum Ändern der Versionsnummern in jedem Build ist die Verwendung der Versionsaufgabe von MSBuild.Community.Tasks . Laden Sie einfach das Installationsprogramm herunter, installieren Sie es, passen Sie den folgenden Code an und fügen Sie ihn anschließend <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />in Ihre .csprojDatei ein:

<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 an Ihr Gebietsschema an. Derzeit wird die invariante Kultur nicht verwendet.

Für den dritten Build am 14. Januar 2010 wird ein VersionInfo.csmit diesem Inhalt erstellt:

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

Diese Datei muss dann zum Projekt hinzugefügt werden (über Vorhandenes Element hinzufügen ) und die Zeilen AssemblyVersionund AssemblyFileVersionmüssen entfernt werden AssemblyInfo.cs.

Die verschiedenen Algorithmen zum Ändern der Versionskomponenten sind in $(MSBuildExtensionsPath)\MSBuildCommunityTasks\MSBuild.Community.Tasks.chmund Versionseigenschaften beschrieben .

Ich habe eine Lösung gefunden, die Christen ähnelt, aber ohne von den Community-MSBuild-Aufgaben abhängig zu sein, ist dies keine Option für mich, da ich diese Aufgaben nicht für alle unsere Entwickler installieren möchte.

Ich generiere Code und kompiliere zu einer Assembly und möchte Versionsnummern automatisch erhöhen. Ich kann den Trick VS 6.0. * AssemblyVersion jedoch nicht verwenden, da er die Build-Nummern jeden Tag automatisch inkrementiert und die Kompatibilität mit Assemblies unterbricht, die eine ältere Build-Nummer verwenden. Stattdessen möchte ich eine fest codierte AssemblyVersion, aber eine automatisch inkrementierende AssemblyFileVersion. Ich habe dies erreicht, indem ich AssemblyVersion in AssemblyInfo.cs angegeben und eine VersionInfo.cs in MSBuild wie folgt generiert habe.

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

Dadurch wird eine VersionInfo.cs-Datei mit einem Assembly-Attribut für AssemblyFileVersion generiert, wobei die Version dem Schema von YY.MM.DD.TTTT mit dem Erstellungsdatum folgt. Sie müssen diese Datei in Ihr Projekt aufnehmen und damit erstellen.

Installieren Sie das Add-In Build Version Increment . Es gibt Ihnen viel mehr Kontrolle als die Option *.

Um die Versionsnummern zu erhalten, versuchen Sie es

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

Erstellen / bearbeiten Sie AssemblyInfo.cs, um die Versionsnummer festzulegen

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

Als Randnotiz ist die dritte Zahl die Anzahl der Tage seit dem 01.02.2000 und die vierte Zahl die Hälfte der Gesamtzahl der Sekunden am Tag. Wenn Sie also um Mitternacht kompilieren, sollte es Null sein.

Es gibt eine Visual Studio-Erweiterung Automatic Versions , die Visual Studio (2012, 2013, 2015) 2017 und 2019 unterstützt.

Screenshots

Das Festlegen eines * in der Versionsnummer in AssemblyInfo oder unter Projekteigenschaften, wie in den anderen Beiträgen beschrieben, funktioniert nicht mit allen Versionen von Visual Studio / .NET.

Afaik hat es in VS 2005 nicht funktioniert (aber in VS 2003 und VS 2008). Für VS 2005 können Sie Folgendes verwenden: Automatische Inkrementierung der Visual Studio 2005-Versionserstellung und Versionsnummer zur Kompilierungszeit .

Beachten Sie jedoch, dass das automatische Ändern der Versionsnummer für Assemblys mit starken Namen nicht empfohlen wird. Der Grund dafür ist, dass alle Verweise auf eine solche Assembly jedes Mal aktualisiert werden müssen, wenn die Assembly, auf die verwiesen wird, neu erstellt wird, da stark benannte Assemblyreferenzen immer auf eine bestimmte Assemblyversion verweisen. Microsoft selbst ändert die Versionsnummer der .NET Framework-Assemblys nur, wenn Änderungen an den Schnittstellen vorgenommen wurden. (NB: Ich suche immer noch nach dem Link in MSDN, wo ich das gelesen habe.)

Inkrementelle (DateTime) Informationen in die AssemblyFileVersion-Eigenschaft abrufen, die den Vorteil hat, dass keine Abhängigkeiten aufgehoben werden.

Aufbauend auf der Lösung von Boog (hat bei mir möglicherweise wegen VS2008 nicht funktioniert?) Können Sie eine Kombination aus einem Pre-Build-Ereignis verwenden, das eine Datei generiert, diese Datei (einschließlich ihrer Versionseigenschaften) hinzufügt und dann eine Methode zum Auslesen verwendet diese Werte wieder. Das ist..

Pre-Build-Event:

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 VersionInfo.cs-Datei (Unterordner Eigenschaften) in Ihr Projekt ein

Code zum Abrufen des Datums (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. Außerdem weiß ich nicht, ob es viele Force-Rebuilds erzeugt (da sich eine Datei immer ändert).

Sie könnten es beispielsweise intelligenter machen, wenn Sie die VersionInfo.cs-Datei nur alle paar Minuten / Stunden aktualisieren (indem Sie eine temporäre Datei verwenden und dann die echte VersionInfo.cs kopieren / überschreiben, wenn eine ausreichend große Änderung erkannt wird). Ich habe das einmal ziemlich erfolgreich gemacht.

Setzen Sie die Versionsnummer auf "1.0. *" Und die letzten beiden Nummern werden automatisch mit dem Datum (in Tagen ab einem bestimmten Zeitpunkt) und der Uhrzeit (die halben Sekunden ab Mitternacht) ausgefüllt.

Es befindet sich in Ihren Projekteigenschaften unter Veröffentlichen

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

Kuchen unterstützt das Patchen von AssemblyInfo-Dateien. Mit Kuchen in Händen haben Sie unendlich viele Möglichkeiten, die automatische Versionsinkrementierung zu implementieren.

Ein einfaches Beispiel für das Inkrementieren einer Version wie der C # -Compiler:

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 Assembly-Version. Es wird empfohlen, die Hauptversionsnummer zu sperren und mit Nullen zu belassen (z. B. "1.0.0.0").
• FileVersion - ist die Assembly-Dateiversion.

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

Gehen Sie zu Projekt | Eigenschaften und dann Baugruppeninformationen und dann Baugruppenversion und setzen Sie ein * in das letzte oder vorletzte Feld (Sie können die Haupt- oder Nebenkomponenten nicht automatisch inkrementieren).

Verwenden Sie die AssemblyInfo-Aufgabe aus den MSBuild-Community-Aufgaben ( http://msbuildtasks.tigris.org/). Projekt ) und integrieren Sie sie in Ihre .csproj / .vbproj-Datei.

Es gibt eine Reihe von Optionen, darunter eine, mit der die Versionsnummer an Datum und Uhrzeit gebunden werden kann.

Empfohlen.

Ab sofort für meine Bewerbung,

string ver = Application.ProductVersion;

kehrt zurück ver = 1.0.3251.27860

Der Wert 3251 ist die Anzahl der Tage seit dem 1.1.2000. Ich verwende es, um ein Erstellungsdatum der Version auf dem Begrüßungsbildschirm meiner Anwendung anzugeben. Wenn ich mit einem Benutzer zu tun habe, kann ich nach dem Erstellungsdatum fragen, das einfacher zu kommunizieren ist als eine lange Nummer.

(Ich bin eine Ein-Mann-Abteilung, die eine kleine Firma unterstützt. Dieser Ansatz funktioniert möglicherweise nicht für Sie.)

Das Ändern der AssemblyInfo funktioniert in VS2012. Es scheint seltsam, dass dies in Visual Studio nicht mehr unterstützt wird. Man könnte meinen, dies war ein grundlegender Teil des Build- / Release-Prozesses.

So erhalten Sie die Version {major}.{year}.1{date}.1{time}

Dieser ist irgendwie experimentell, aber ich mag es. Inspiriert von Jeff Atwood @ CodingHorror ( Link ).

Die resultierende Versionsnummer wird 1.2016.10709.11641(dh 2016-07-09 16:41), was ermöglicht

• armer Mann null Polsterung (mit der dummen Führung 1 s)
• fast menschlich lesbar lokal DateTime, eingebettet in die Versionsnummer
• Lassen Sie die Major-Version für wirklich wichtige Änderungen in Ruhe.

Fügen Sie Ihrem Projekt ein neues Element hinzu, wählen Sie Allgemein -> Textvorlage, benennen Sie es so CustomVersionNumberund kommentieren Sie das AssemblyVersionund AssemblyFileVersionin (falls zutreffend) ausProperties/AssemblyInfo.cs .

Wenn Sie diese Datei speichern oder das Projekt erstellen, wird eine .csDatei neu generiert, die sich als Unterelement unter der erstellten .ttDatei befindet.

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

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

1. Anwendung herunterladen

2. Fügen Sie der vorgefertigten Ereignisbefehlszeile die folgende Zeile hinzu

   C: \ temp \ IncrementFileVersion.exe $ (SolutionDir) \ Properties \ AssemblyInfo.cs

3. Erstellen Sie das Projekt

Um es einfach zu halten, gibt die App nur dann Nachrichten aus, wenn ein Fehler vorliegt. Um zu bestätigen, dass es einwandfrei funktioniert hat, müssen Sie die Dateiversion unter "Baugruppeninformationen" überprüfen.

Hinweis: Sie müssen die Lösung in Visual Studio für die Schaltfläche "Baugruppeninformationen" neu laden, um die Felder zu füllen. Ihre Ausgabedatei verfügt jedoch über die aktualisierte Version.

Für Vorschläge und Anfragen senden Sie mir bitte eine E-Mail an telson_alva@yahoo.com

In Visual Studio 2019

Es war nicht genug für mich hinzuzufügen

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

Beim Erstellen wirft es mir diesen Fehler

Die angegebene Versionszeichenfolge entspricht nicht dem erforderlichen Format

Lösung

Das Format wurde schließlich , nachdem ich Satz akzeptiert Deterministiczu Falseinproject.csproj

<Deterministic>false</Deterministic>

Bearbeiten:

Aus irgendeinem Grund Einstellung DeterministiczuFalse meiner Konfigurationsdatei geladen es vermasselt und es an verschiedenen Orten zu speichern.

Problemumgehung:

Ich habe ein Post-Build-Ereignis eingerichtet, um die Versionsnummer zu erhöhen:

Batch-Skript für Ereignisse nach dem Build

Dies nennt ein Powershell-Skript mit dem Namen " autoincrement_version.ps1übergeben als Argument" den Pfad vonAssemblyInfo.cs

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

Poweshell-Skript

Die Revisionsnummer wird mithilfe von Regex automatisch inkrementiert

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

Vielleicht können Sie für diese Aufgabe 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 rufen Sie es vom Laden des Formulars auf.
Mit diesem Code können Sie jeden Teil der Dateiinformationen in AssemblyInfo.cs aktualisieren (Sie müssen jedoch die "Standard" -Verzeichnisstruktur verwenden).

AssemblyInfoUtil . Kostenlos. Open Source.

Ich verwende diesen Ansatz https://stackoverflow.com/a/827209/3975786, indem ich die T4-Vorlage in einem "Lösungselement" platziere und sie mit "Als Link hinzufügen" in jedem Projekt verwende.

Vielleicht ist es zu spät, um hier zu antworten, aber ich hoffe, das löst das hektische Problem von jemandem.

Eine automatische Möglichkeit, die Assemblyversion aller Ihrer Projekte mithilfe des PowerShell-Skripts zu ändern. Dieser Artikel wird viele Ihrer Probleme lösen.

Jedes Mal, wenn ich einen Build mache, wird die niedrigstwertige Ziffer automatisch inkrementiert.

Ich habe keine Ahnung, wie ich die anderen aktualisieren soll, aber das sollten Sie zumindest schon sehen ...

Für alle, die Tortoise Subversion verwenden, können Sie eine Ihrer Versionsnummern mit der Versionsnummer der Subversion Ihres Quellcodes verknüpfen. Ich finde das sehr nützlich (Auditoren mögen das auch sehr!). Sie tun dies, indem Sie das Dienstprogramm WCREV in Ihrem Pre-Build aufrufen und Ihre AssemblyInfo.cs aus einer Vorlage generieren.

Wenn Ihre Vorlage AssemblyInfo.wcrev heißt und sich im normalen AssemblyInfo.cs-Verzeichnis befindet und sich tortoise im Standardinstallationsverzeichnis befindet, sieht Ihr Pre-Build-Befehl folgendermaßen aus (Hinweis: Alle in einer Zeile):

"C:\Program Files\TortoiseSVN\bin\SubWCRev.exe" "$(ProjectDir)." "$(ProjectDir)Properties\AssemblyInfo.wcrev"  "$(ProjectDir)Properties\AssemblyInfo.cs"

Die Vorlagendatei würde die Ersetzungszeichenfolge für das wcrev-Token enthalten: $ WCREV $,
z

[assembly: AssemblyFileVersion("1.0.0.$WCREV$")]

Hinweis:
Da Ihre AssemblyInfo.cs jetzt generiert wird, möchten Sie nicht, dass sie versioniert wird.