Kontrola wersji

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

using System;
using System.IO;
using System.Collections.Generic;
using System.Reflection;
 
namespace changeVersion
{
 class Program
 {
 static void Main(string[] args)
 {
 Console.WriteLine(
 "Version Changer ({0}) by Grzegorz Surowiec (www.grzegorzsurowiec.pl)",
 Assembly.GetExecutingAssembly().GetName().Version);
 
 if (args.Length > 1)
 {
 string filePath = args[args.Length - 1];
 if (!filePath[filePath.Length - 1].Equals(Path.DirectorySeparatorChar))
 {
 filePath += Path.DirectorySeparatorChar;
 }
 
 string fileName = filePath + @"PropertiesAssemblyInfo.cs";
 if (File.Exists(fileName))
 {
 
 VersionFinder vf = new VersionFinder(fileName);
 Version ver = null;
 Version fileVer = null;
 
 vf.GetVersionInfo(ref ver, ref fileVer);
 
 Console.WriteLine(
 "Old value:ntAssemblyVersion: {0}ntAssemblyFileVersion: {1}",
 ver.ToString(),
 fileVer.ToString());
 
 if (!ver.Equals(null) && !fileVer.Equals(null))
 {
 
 for (int i = 0; i < args.Length - 1; i++)
 {
 switch (args[i])
 {
 case "-B":
 vf.incrementBuildNumber(ref ver);
 vf.incrementBuildNumber(ref fileVer);
 break;
 
 case "-Mi":
 vf.incrementMinorNumber(ref ver);
 vf.incrementMinorNumber(ref fileVer);
 break;
 
 case "-Ma":
 vf.incrementMajorNumber(ref ver);
 vf.incrementMajorNumber(ref fileVer);
 break;
 
 case "-R":
 vf.incrementRevisionNumber(ref ver);
 vf.incrementRevisionNumber(ref fileVer);
 break;
 }
 }
 
 Console.WriteLine(
 "nNew value:ntAssemblyVersion: {0}ntAssemblyFileVersion: {1}",
 ver.ToString(),
 fileVer.ToString());
 
 vf.SaveVersion(ver, fileVer);
 }
 else
 {
 Console.WriteLine("Problem with reading AssemblyFile.");
 }
 
 }
 }
 else
 {
 string info = "uses: switchers path_to_source_dirn" +
 "switchers:nt-B: increment build number,nt-R: increment revision number,n" +
 "t-Ma: increment major number,nt-Mi: increment minor number.";
 
 Console.WriteLine(info);
 }
 
 Console.ReadLine();
 
 }
 
 }
 
 class VersionFinder
 {
 
 private List<string> p_assemblyfile;
 
 private string p_fileName;
 
 private const string _assemblyVersionTagStart = "[assembly: AssemblyVersion(\"";
 private const string _assemblyVersionTagStop = "\")]";
 private const string _assemblyFileVersionTagStart = "[assembly: AssemblyFileVersion(\"";
 private const string _assemblyFileVersionTagStop = "\")]";
 
 private int p_assemblyVersionPosition;
 private int p_assemblyFileVersionPosition;
 
 public VersionFinder(string fileName)
 {
 this.p_assemblyVersionPosition = -1;
 this.p_assemblyFileVersionPosition = -1;
 
 this.p_assemblyfile = new List<string>();
 this.p_fileName = fileName;
 
 StreamReader sr = new StreamReader(this.p_fileName);
 string line = string.Empty;
 while (line != null)
 {
 line = sr.ReadLine();
 if (line != null)
 this.p_assemblyfile.Add(line);
 }
 sr.Close();
 
 }
 
 private string findVersion(string where, string startTag, string stopTag)
 {
 int find = where.IndexOf(startTag);
 if (find == -1) return string.Empty;
 
 find += startTag.Length;
 
 where = where.Substring(find, where.Length - find);
 
 find = where.IndexOf(stopTag);
 if (find == -1) return string.Empty;
 
 return where.Substring(0, find);
 }
 
 private void findVer(string startTag, string stopTag, out int position, out string versionstring)
 {
 int pos = 0;
 position = pos;
 versionstring = string.Empty;
 
 foreach (string line in this.p_assemblyfile)
 {
 versionstring = findVersion(line, startTag, stopTag);
 if (!(line.Length > 2 && line.Substring(0, 2) == "//") && (versionstring != string.Empty))
 {
 position = pos;
 break;
 }
 pos++;
 }
 }
 
 public void GetVersionInfo(ref Version ver, ref Version fileVer)
 {
 string versionString = string.Empty;
 
 findVer(
 _assemblyVersionTagStart,
 _assemblyVersionTagStop,
 out this.p_assemblyVersionPosition,
 out versionString);
 
 ver = (versionString.Equals(string.Empty))?null:new Version(versionString);
 
 findVer(
 _assemblyFileVersionTagStart,
 _assemblyFileVersionTagStop,
 out this.p_assemblyFileVersionPosition,
 out versionString);
 
 fileVer = (versionString.Equals(string.Empty)) ? null : new Version(versionString);
 }
 
 public void incrementBuildNumber(ref Version ver)
 {
 ver = new Version(ver.Major, ver.Minor, ver.Build + 1, ver.Revision);
 }
 
 public void incrementRevisionNumber(ref Version ver)
 {
 ver = new Version(ver.Major, ver.Minor, ver.Build, ver.Revision + 1);
 }
 
 public void incrementMinorNumber(ref Version ver)
 {
 ver = new Version(ver.Major, ver.Minor + 1, ver.Build, ver.Revision);
 }
 
 public void incrementMajorNumber(ref Version ver)
 {
 ver = new Version(ver.Major + 1, ver.Minor, ver.Build, ver.Revision);
 }
 
 public void SaveVersion(Version ver, Version fileVer)
 {
 this.p_assemblyfile[p_assemblyVersionPosition] =
 string.Concat(_assemblyVersionTagStart, ver, _assemblyVersionTagStop);
 
 this.p_assemblyfile[p_assemblyFileVersionPosition] =
 string.Concat(_assemblyFileVersionTagStart, ver, _assemblyFileVersionTagStop);
 
 StreamWriter sw = new StreamWriter(this.p_fileName);
 sw.Write((string.Join("n", this.p_assemblyfile.ToArray())));
 sw.Close();
 }
 }
}</string>