Ustawianie numerów wersji AssemblyInfo z konfiguracją MSI wersja

Question

Używam projektu instalacji do publikowania moich projektów. Chcę, aby wersja każdego projektu była taka sama jak wersja instalacyjna.

Chcę zmienić moją właściwość wersji instalacji w Visual Studio, a po zbudowaniu, czy możliwe jest aktualizowanie wszystkich wersji projektu z tej właściwości?

Answer 1

Projekty mają montażowe numery wersji & plików: (nie wersje instalacyjne edytowany zapytanie odpowiednio)

Odpowiedź 1:

Jeśli chcesz, aby projekty instalacji numer wersji określonej Zgromadzenie & Numery wersji pliku należy wykonać przy użyciu skryptu/exe, który zostanie uruchomiony przez kompilację.

Ten artykuł na How To Update Assembly Version Number Automatically pokazuje połowę rozwiązanie ...

Z badań robiłem to nie jest możliwe korzystanie z instalowana w PreBuildEvent. Nie jest poleceniem $ instalowana na to: http://msdn.microsoft.com/en-us/library/42x5kfw4(v=vs.80).aspx

konieczności zmiany PreBuildEvent każdy budowę jak pokazano w this comment w artykule kod projektu używając komendy -set: nie jest idealny.

Rozwiązanie, którego potrzebujemy, to PreBuildEvent, aby wywołać AssemblyInfoUtil.exe i zlecić odczytanie "ProductVersion" z pliku projektu vdproj. A następnie zaktualizuj numery wersji zespołu.

Mam zmodyfikowany kod z artykułu, aby pokazać, jak odczytać wersję produktu z Setup.vdproj i to w jaki sposób może być wywoływana z PreBuildEvent:

AssemblyInfoUtil.exe -setup:"C:\Program Files\MyProject1\Setup1\Setup1.vdproj" -ass:"C:\Program Files\MyProject1\AssemblyInfo.cs" 

Jest to zmodyfikowany kod :

using System; 
using System.IO; 
using System.Text; 

namespace AssemblyInfoUtil 
{ 
    class AssemblyInfoUtil 
    { 
    private static int incParamNum = 0;  
    private static string fileName = ""; 
    private static string setupfileName = "";  
    private static string versionStr = null;  
    private static bool isVB = false; 
    [STAThread] 
    static void Main(string[] args) 
    { 
     for (int i = 0; i < args.Length; i++) { 
      if (args[i].StartsWith("-setup:")) { 
      string s = args[i].Substring("-setup:".Length); 
      setupfileName = int.Parse(s); 
      } 
      else if (args[i].StartsWith("-ass:")) { 
      fileName = args[i].Substring("-ass:".Length); 
      } 
     } 

     //Jeremy Thompson showing how to detect "ProductVersion" = "8:1.0.0" in vdproj 
     string setupproj = System.IO.File.ReadAllText(setupfileName); 
     int startPosOfProductVersion = setupproj.IndexOf("\"ProductVersion\" = \"") +20; 
     int endPosOfProductVersion = setupproj.IndexOf(Environment.NewLine, startPosOfProductVersion) - startPosOfProductVersion; 
     string versionStr = setupproj.Substring(startPosOfProductVersion, endPosOfProductVersion); 
     versionStr = versionStr.Replace("\"", string.Empty).Replace("8:",string.Empty); 

     if (Path.GetExtension(fileName).ToLower() == ".vb") 
     isVB = true; 

     if (fileName == "") { 
     System.Console.WriteLine("Usage: AssemblyInfoUtil 
      <path to :Setup.vdproj file> and <path to AssemblyInfo.cs or AssemblyInfo.vb file> [options]"); 
     System.Console.WriteLine("Options: "); 
     System.Console.WriteLine(" -setup:Setup.vdproj file path"); 
     System.Console.WriteLine(" -ass:Assembly file path"); 
     return; 
     } 

     if (!File.Exists(fileName)) { 
     System.Console.WriteLine 
      ("Error: Can not find file \"" + fileName + "\""); 
     return; 
     } 

     System.Console.Write("Processing \"" + fileName + "\"..."); 
     StreamReader reader = new StreamReader(fileName); 
      StreamWriter writer = new StreamWriter(fileName + ".out"); 
     String line; 

     while ((line = reader.ReadLine()) != null) { 
     line = ProcessLine(line); 
     writer.WriteLine(line); 
     } 
     reader.Close(); 
     writer.Close(); 

     File.Delete(fileName); 
     File.Move(fileName + ".out", fileName); 
     System.Console.WriteLine("Done!"); 
    } 

    private static string ProcessLine(string line) { 
     if (isVB) { 
     line = ProcessLinePart(line, "<Assembly: AssemblyVersion(\""); 
     line = ProcessLinePart(line, "<Assembly: AssemblyFileVersion(\""); 
     } 
     else { 
     line = ProcessLinePart(line, "[assembly: AssemblyVersion(\""); 
     line = ProcessLinePart(line, "[assembly: AssemblyFileVersion(\""); 
     } 
     return line; 
    } 

    private static string ProcessLinePart(string line, string part) { 
     int spos = line.IndexOf(part); 
     if (spos >= 0) { 
     spos += part.Length; 
     int epos = line.IndexOf('"', spos); 
     string oldVersion = line.Substring(spos, epos - spos); 
     string newVersion = ""; 
     bool performChange = false; 

     if (incParamNum > 0) { 
      string[] nums = oldVersion.Split('.'); 
      if (nums.Length >= incParamNum && nums[incParamNum - 1] != "*") { 
      Int64 val = Int64.Parse(nums[incParamNum - 1]); 
      val++; 
      nums[incParamNum - 1] = val.ToString(); 
      newVersion = nums[0]; 
      for (int i = 1; i < nums.Length; i++) { 
       newVersion += "." + nums[i]; 
      } 
      performChange = true; 
      } 
     } 

     else if (versionStr != null) { 
      newVersion = versionStr; 
      performChange = true; 
     } 

     if (performChange) { 
      StringBuilder str = new StringBuilder(line); 
      str.Remove(spos, epos - spos); 
      str.Insert(spos, newVersion); 
      line = str.ToString(); 
     } 
     } 
     return line; 
    } 
    } 
} 

---

Odpowiedź 2:

Moim sposobem myślenia jest lepsze wykorzystanie klasy Shared Assembly Info niż pojedynczych plików klasy AssemblyInfo.

Aby to zaimplementować, utwórz plik w folderze rozwiązania o nazwie SharedAssemblyInfo.cs, a następnie dodaj łącze w każdym projekcie do SharedAssemblyInfo.cs. Możesz także przenieść połączone pliki SharedAssemblyInfo.cs do folderu Właściwości, aby znajdowały się obok obiektu AssemblyInfo.cs, który jest specyficzny dla każdego projektu w roztworze, jak pokazano poniżej.

Oto przykładowy plik SharedAssemblyInfo.cs:

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

// General Information about an assembly is controlled through the following 
// set of attributes. Change these attribute values to modify the information 
// associated with an assembly. 
[assembly: AssemblyCompany("Saint Bart Technologies")] 
[assembly: AssemblyProduct("Demo")] 
[assembly: AssemblyCopyright("Copyright ? Saint Bart 2013")] 
[assembly: AssemblyTrademark("")] 

// Make it easy to distinguish Debug and Release (i.e. Retail) builds; 
// for example, through the file properties window. 
#if DEBUG 
[assembly: AssemblyConfiguration("Debug")] 
[assembly: AssemblyDescription("Flavor=Debug")] // a.k.a. "Comments" 
#else 
[assembly: AssemblyConfiguration("Retail")] 
[assembly: AssemblyDescription("Flavor=Retail")] // a.k.a. "Comments" 
#endif 

[assembly: CLSCompliant(true)] 

// Setting ComVisible to false makes the types in this assembly not visible 
// to COM components. If you need to access a type in this assembly from 
// COM, set the ComVisible attribute to true on that type. 
[assembly: ComVisible(false)] 

// Note that the assembly version does not get incremented for every build 
// to avoid problems with assembly binding (or requiring a policy or 
// <bindingRedirect> in the config file). 
// 
// The AssemblyFileVersionAttribute is incremented with every build in order 
// to distinguish one build from another. AssemblyFileVersion is specified 
// in AssemblyVersionInfo.cs so that it can be easily incremented by the 
// automated build process. 
[assembly: AssemblyVersion("1.0.0.0")] 

// By default, the "Product version" shown in the file properties window is 
// the same as the value specified for AssemblyFileVersionAttribute. 
// Set AssemblyInformationalVersionAttribute to be the same as 
// AssemblyVersionAttribute so that the "Product version" in the file 
// properties window matches the version displayed in the GAC shell extension. 
[assembly: AssemblyInformationalVersion("1.0.0.0")] // a.k.a. "Product version" 

Oto przykładowy plik AssemblyInfo.cs:

// Note: Shared assembly information is specified in SharedAssemblyInfo.cs 
using System.Reflection; 
using System.Runtime.CompilerServices; 
using System.Runtime.InteropServices; 
// General Information about an assembly is controlled through the following 
// set of attributes. Change these attribute values to modify the information 
// associated with an assembly. 
[assembly: AssemblyTitle("WindowsFormsApplication2")] 
// The following GUID is for the ID of the typelib if this project is exposed to COM 
[assembly: Guid("ffded14d-6c95-440b-a45d-e1f502476539")] 

Więc za każdym razem chcesz zmienić wszystkie projekty Informacje o montażu możesz zrobić w jednym miejscu. Zakładam, że chcesz ustawić wersję Instalatora MSI taką samą, jak numer wersji zespołu, jeden krok ręczny.

---

Odpowiedź 3:

rozważyć włączenie do korzystania MSBuild ma wszystkie te rodzaje świadczeń, ale nie jestem pewien, czy masz czas, aby go podnieść teraz.

---

Odpowiedź 4:

zespoły mogą automatycznego przyrostu ich liczby zbudować używając następującej składni w AssemblyInfo.cs gwiazdka:

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

Jest to dobra metoda, ponieważ punktem śledzenia numeru kompilacji jest , aby móc rozpoznawać różne kompilacje. Posiadanie wstępnie zbudowanych zmieniających się numerów kompilacji pokonuje ten cel, ponieważ kompilacja jeszcze się nie wydarzyła.

---

Odpowiedź 5:

Drugi CodeProject odpowiedź tutaj zakłada chcesz zaktualizować ProductVersion, ProductCode, PackageCode w konfiguracji pliku MSI Projektu. Nie interpretować swoje pytanie w ten sposób i według tego wątku istnieją problemy: pre-build event to change setup project's ProductVersion doesn't take effect until after the build

Odpowiedź 6 (nowy):

Istnieje kilka wtyczek do TFS Buduj zestaw „Montaż Info”: https://marketplace.visualstudio.com/items?itemName=bleddynrichards.Assembly-Info-Task https://marketplace.visualstudio.com/items?itemName=bool.update-assembly-info https://marketplace.visualstudio.com/items?itemName=ggarbuglia.setassemblyversion-task

Answer 2

ja nie wiem, czy to rozwiąże problem doskonale, ale można realizować wspólną klasę ze wszystkimi informacjami configmanagment jak:

public class VersionInfo{ 
    public const string cProductVersion = "1.0.0" 
    //other version info 
} 

Po można zaktualizować wszystkie swoje AssemblyInfo.cs z nowej klasy :

[assembly: AssemblyVersion(VersionInfo.cProductVersion)] 

Mam nadzieję, że to pomoże.