VS项目整体重命名工具

VS项目整体重命名工具

苏尼特左网站建设公司创新互联建站,苏尼特左网站设计制作，有大型网站制作公司丰富经验。已为苏尼特左数千家提供企业网站建设服务。企业网站搭建\外贸网站建设要多少钱，请找那个售后服务好的苏尼特左做网站的公司定做！

不再为项目重命名和修改命名空间而烦恼，简单几个字，但是开发加上测试大量项目，前前后后竟然跨越了1个月，汗。。。不过真正的开发时间可能2-3天的样子。

一.介绍

1.虽然说我们平常不会经常出现项目重命名的情况，但是一旦出现，修改起来还是一项比较大的工程，并且还不一定修改完整。

2.当团队发展到一定程度的时候，基本上都有了自己固定的一些WEB/Winform开发框架和通用项目模版，这样就会出现修改项目名称，命名空间等结构的情况。

3.哒哒哒哒哒哒，不说第三了。亲,没了。@_@

二.功能

1.自动重命名关联的各种文件，并且支持自定义扩展。

2.自动检测文件编码格式，处理读取不同编码格式时出现的乱码问题。(当项目内包含中文的时候)

3.自动修改sln和csproj文件中的引用关系，并且根据文件名称修改文件夹名称。

4.清理BIN目录和OBJ目录，已经项目产生的不必要的垃圾文件，可单独使用。

5.每个csproj都是执行单独修改，然后更新关联引用，并记住修改过的引用。

6.输入项目新名词的文本框加入了选词功能（文本框本身双击内容是全选的效果）。

7.自己试一下把。+_+

三.演示与截图

1.VS的观察 

更新前的VS项目解决方案

更新后的VS项目解决方案

2.系统资源管理器的观察

更新前的文件夹结构

更新后的文件夹结构

3.软件使用截图

1.打开软件显示很简单的打开解决方案的视图。

2.选择解决方案打开后，会自动加载该目下所有的csproj文件。

3.点击【软件设置】会出现其他需要修改关联的文件后缀名，你也可以直接写文件全名。

你也可以给输入新名称的文本框添加选词分隔符，以达到你所需要的自动选词效果。

#p#

 四.代码和思路

1.文本框智能选词功能的实现。

 
 
 
 
    
  
  
  
  
  1. public delegate void AutoSelectTextBoxDoubleclick(object sender, MouseEventArgs e);  
    2. 
  
  
  
  
  2.      ///   
    3. 
  
  
  
  
  3.      /// 智能选择文本控件,亲，这个类copy走就可以使用哟  
    4. 
  
  
  
  
  4.      ///   
    5. 
  
  
  
  
  5.      public class AutoSelectTextBox : TextBox  
    6. 
  
  
  
  
  6.      {  
    7. 
  
  
  
  
  7.          const int WM_LBUTTONDBLCLK = 0x0203;  
    8. 
  
  
  
  
  8.          MouseEventArgs e;  
    9. 
  
  
  
  
  9.    
    10. 
  
  
  
  
  10.          ///   
    11. 
  
  
  
  
  11.          /// 是否启用智能选择  
    12. 
  
  
  
  
  12.          ///   
    13. 
  
  
  
  
  13.          [System.ComponentModel.Description("是否启用智能选择")]  
    14. 
  
  
  
  
  14.          public bool EnableAutoSelect  
    15. 
  
  
  
  
  15.          {  
    16. 
  
  
  
  
  16.              get;  
    17. 
  
  
  
  
  17.              set;  
    18. 
  
  
  
  
  18.          }  
    19. 
  
  
  
  
  19.    
    20. 
  
  
  
  
  20.          private List splitChar;  
    21. 
  
  
  
  
  21.    
    22. 
  
  
  
  
  22.          ///   
    23. 
  
  
  
  
  23.          /// 选择判断分隔符，默认 . 号  
    24. 
  
  
  
  
  24.          ///   
    25. 
  
  
  
  
  25.          [System.ComponentModel.Description("判断选择分隔符，默认 . 号")]  
    26. 
  
  
  
  
  26.          [System.ComponentModel.Browsable(false)]  
    27. 
  
  
  
  
  27.          public List SplitChar  
    28. 
  
  
  
  
  28.          {  
    29. 
  
  
  
  
  29.              get { return splitChar; }  
    30. 
  
  
  
  
  30.              set { splitChar = value; }  
    31. 
  
  
  
  
  31.          }  
    32. 
  
  
  
  
  32.    
    33. 
  
  
  
  
  33.          ///   
    34. 
  
  
  
  
  34.          /// 智能选择文本框双击事件  
    35. 
  
  
  
  
  35.          ///   
    36. 
  
  
  
  
  36.          public event AutoSelectTextBoxDoubleclick AutoSelectTextMouseDoubleclick;  
    37. 
  
  
  
  
  37.    
    38. 
  
  
  
  
  38.          protected override void WndProc(ref Message m)  
    39. 
  
  
  
  
  39.          {  
    40. 
  
  
  
  
  40.    
    41. 
  
  
  
  
  41.              if (EnableAutoSelect && m.Msg == WM_LBUTTONDBLCLK)  
    42. 
  
  
  
  
  42.              {  
    43. 
  
  
  
  
  43.                  Point p = this.PointToClient(MousePosition);  
    44. 
  
  
  
  
  44.                  e = new MouseEventArgs(MouseButtons.Left, 2, p.X, p.Y, 0);  
    45. 
  
  
  
  
  45.                  if (AutoSelectTextMouseDoubleclick != null)  
    46. 
  
  
  
  
  46.                  {  
    47. 
  
  
  
  
  47.                      AutoSelectTextMouseDoubleclick(this, e);  
    48. 
  
  
  
  
  48.                  }  
    49. 
  
  
  
  
  49.                  else 
    50. 
  
  
  
  
  50.                  {  
    51. 
  
  
  
  
  51.                      MouseDoubleClickAutoSelect(e);  
    52. 
  
  
  
  
  52.                  }  
    53. 
  
  
  
  
  53.                  return;  
    54. 
  
  
  
  
  54.    
    55. 
  
  
  
  
  55.              }  
    56. 
  
  
  
  
  56.              else 
    57. 
  
  
  
  
  57.              {  
    58. 
  
  
  
  
  58.                  base.WndProc(ref m);  
    59. 
  
  
  
  
  59.              }  
    60. 
  
  
  
  
  60.          }  
    61. 
  
  
  
  
  61.    
    62. 
  
  
  
  
  62.          ///   
    63. 
  
  
  
  
  63.          /// 智能选择实现  
    64. 
  
  
  
  
  64.          ///   
    65. 
  
  
  
  
  65.          private void MouseDoubleClickAutoSelect(MouseEventArgs e)  
    66. 
  
  
  
  
  66.          {  
    67. 
  
  
  
  
  67.              if (this.Text != "")  
    68. 
  
  
  
  
  68.              {  
    69. 
  
  
  
  
  69.                  int pint = this.GetCharIndexFromPosition(e.Location);  
    70. 
  
  
  
  
  70.                  int len = this.Text.Length;  
    71. 
  
  
  
  
  71.                  int left = pint, right = pint;  
    72. 
  
  
  
  
  72.    
    73. 
  
  
  
  
  73.                  while (left >= 0)  
    74. 
  
  
  
  
  74.                  {  
    75. 
  
  
  
  
  75.                      char lchar = this.Text[left];  
    76. 
  
  
  
  
  76.                      if (CheckSpiltChar(lchar))  
    77. 
  
  
  
  
  77.                      {  
    78. 
  
  
  
  
  78.                          break;  
    79. 
  
  
  
  
  79.                      }  
    80. 
  
  
  
  
  80.                      left--;  
    81. 
  
  
  
  
  81.                  }  
    82. 
  
  
  
  
  82.                  while (right <= len - 1)  
    83. 
  
  
  
  
  83.                  {  
    84. 
  
  
  
  
  84.                      char rchar = this.Text[right];  
    85. 
  
  
  
  
  85.                      if (CheckSpiltChar(rchar))  
    86. 
  
  
  
  
  86.                      {  
    87. 
  
  
  
  
  87.                          break;  
    88. 
  
  
  
  
  88.                      }  
    89. 
  
  
  
  
  89.                      right++;  
    90. 
  
  
  
  
  90.                  }  
    91. 
  
  
  
  
  91.                  //必须有字符可选  
    92. 
  
  
  
  
  92.                  if (right - (left + 1) > 0)  
    93. 
  
  
  
  
  93.                  {  
    94. 
  
  
  
  
  94.                      this.Select(left + 1, right - (left + 1));  
    95. 
  
  
  
  
  95.                  }  
    96. 
  
  
  
  
  96.              }  
    97. 
  
  
  
  
  97.    
    98. 
  
  
  
  
  98.          }  
    99. 
  
  
  
  
  99.    
    100. 
  
  
  
  
  100.    
    101. 
  
  
  
  
  101.    
    102. 
  
  
  
  
  102.          ///   
    103. 
  
  
  
  
  103.          /// 检查  
    104. 
  
  
  
  
  104.          ///   
    105. 
  
  
  
  
  105.          ///   
    106. 
  
  
  
  
  106.          ///   
    107. 
  
  
  
  
  107.          private bool CheckSpiltChar(char source)  
    108. 
  
  
  
  
  108.          {  
    109. 
  
  
  
  
  109.              if (SplitChar != null)  
    110. 
  
  
  
  
  110.              {  
    111. 
  
  
  
  
  111.                  foreach (char c in SplitChar)  
    112. 
  
  
  
  
  112.                  {  
    113. 
  
  
  
  
  113.                      if (char.Equals(source, c))  
    114. 
  
  
  
  
  114.                      {  
    115. 
  
  
  
  
  115.                          return true;  
    116. 
  
  
  
  
  116.                      }  
    117. 
  
  
  
  
  117.                  }  
    118. 
  
  
  
  
  118.                  return false;  
    119. 
  
  
  
  
  119.              }  
    120. 
  
  
  
  
  120.              else 
    121. 
  
  
  
  
  121.              {  
    122. 
  
  
  
  
  122.                  return char.Equals(source, '.');  
    123. 
  
  
  
  
  123.              }  
    124. 
  
  
  
  
  124.          }  
    125. 
  
  
  
  
  125.    
    126. 
  
  
  
  
  126.      } 
    127.

解释：该自动完成选词功能需要重写文本框的消息机制，其中 WM_LBUTTONDBLCLK = 0x0203 为鼠标双击消息，然后重写WndProc该事件。
为什么我重新写双击消息，而不是用文本框本身的双击事件，是因为本身的双击事件会处理一些其他内容，并且会出现先选中全部内容然后再自动选词的闪烁问题，
有兴趣的同学可以试一下就知道了。

2.老调重弹自动识别文件编码问题，大部分的解决方案都不太理想，基本都是读取文件2-4位，判断字节大小，来决定文件编码类型。
这样的思路只是其中之一，当我郁闷至极的时候突然想到ITextSharp控件（重量级语言高亮编辑器），找到源码，发现了一块编码自动识别的功能。

下面代码是ITextSharp控件中文件编码识别的源码，这个我发现比百度和google出来的效果好很多，基本上无识别错误情况，基本100%识别正确。
但是带来的后果是要检查一段内容前面很大一段内容，用性能换编码识别精度。

 
 
 
 
    
  
  
  
  
  1. public static StreamReader OpenStream(Stream fs, Encoding defaultEncoding)  
    2. 
  
  
  
  
  2.          {  
    3. 
  
  
  
  
  3.              if (fs == null)  
    4. 
  
  
  
  
  4.                  throw new ArgumentNullException("fs");  
    5. 
  
  
  
  
  5.    
    6. 
  
  
  
  
  6.              if (fs.Length >= 2)  
    7. 
  
  
  
  
  7.              {  
    8. 
  
  
  
  
  8.                  // the autodetection of StreamReader is not capable of detecting the difference  
    9. 
  
  
  
  
  9.                  // between ISO-8859-1 and UTF-8 without BOM.  
    10. 
  
  
  
  
  10.                  int firstByte = fs.ReadByte();  
    11. 
  
  
  
  
  11.                  int secondByte = fs.ReadByte();  
    12. 
  
  
  
  
  12.                  switch ((firstByte << 8) | secondByte)  
    13. 
  
  
  
  
  13.                  {  
    14. 
  
  
  
  
  14.                      case 0x0000: // either UTF-32 Big Endian or a binary file; use StreamReader  
    15. 
  
  
  
  
  15.                      case 0xfffe: // Unicode BOM (UTF-16 LE or UTF-32 LE)  
    16. 
  
  
  
  
  16.                      case 0xfeff: // UTF-16 BE BOM  
    17. 
  
  
  
  
  17.                      case 0xefbb: // start of UTF-8 BOM  
    18. 
  
  
  
  
  18.                          // StreamReader autodetection works  
    19. 
  
  
  
  
  19.                          fs.Position = 0;  
    20. 
  
  
  
  
  20.                          return new StreamReader(fs);  
    21. 
  
  
  
  
  21.                      default:  
    22. 
  
  
  
  
  22.                          return AutoDetect(fs, (byte)firstByte, (byte)secondByte, defaultEncoding);  
    23. 
  
  
  
  
  23.                  }  
    24. 
  
  
  
  
  24.              }  
    25. 
  
  
  
  
  25.              else 
    26. 
  
  
  
  
  26.              {  
    27. 
  
  
  
  
  27.                  if (defaultEncoding != null)  
    28. 
  
  
  
  
  28.                  {  
    29. 
  
  
  
  
  29.                      return new StreamReader(fs, defaultEncoding);  
    30. 
  
  
  
  
  30.                  }  
    31. 
  
  
  
  
  31.                  else 
    32. 
  
  
  
  
  32.                  {  
    33. 
  
  
  
  
  33.                      return new StreamReader(fs);  
    34. 
  
  
  
  
  34.                  }  
    35. 
  
  
  
  
  35.              }  
    36. 
  
  
  
  
  36.          }  
    37. 
  
  
  
  
  37.    
    38. 
  
  
  
  
  38.          static StreamReader AutoDetect(Stream fs, byte firstByte, byte secondByte, Encoding defaultEncoding)  
    39. 
  
  
  
  
  39.          {  
    40. 
  
  
  
  
  40.              int max = (int)Math.Min(fs.Length, 500000); // look at max. 500 KB  
    41. 
  
  
  
  
  41.              const int ASCII = 0;  
    42. 
  
  
  
  
  42.              const int Error = 1;  
    43. 
  
  
  
  
  43.              const int UTF8 = 2;  
    44. 
  
  
  
  
  44.              const int UTF8Sequence = 3;  
    45. 
  
  
  
  
  45.              int state = ASCII;  
    46. 
  
  
  
  
  46.              int sequenceLength = 0;  
    47. 
  
  
  
  
  47.              byte b;  
    48. 
  
  
  
  
  48.              for (int i = 0; i < max; i++)  
    49. 
  
  
  
  
  49.              {  
    50. 
  
  
  
  
  50.                  if (i == 0)  
    51. 
  
  
  
  
  51.                  {  
    52. 
  
  
  
  
  52.                      b = firstByte;  
    53. 
  
  
  
  
  53.                  }  
    54. 
  
  
  
  
  54.                  else if (i == 1)  
    55. 
  
  
  
  
  55.                  {  
    56. 
  
  
  
  
  56.                      b = secondByte;  
    57. 
  
  
  
  
  57.                  }  
    58. 
  
  
  
  
  58.                  else 
    59. 
  
  
  
  
  59.                  {  
    60. 
  
  
  
  
  60.                      b = (byte)fs.ReadByte();  
    61. 
  
  
  
  
  61.                  }  
    62. 
  
  
  
  
  62.                  if (b < 0x80)  
    63. 
  
  
  
  
  63.                  {  
    64. 
  
  
  
  
  64.                      // normal ASCII character  
    65. 
  
  
  
  
  65.                      if (state == UTF8Sequence)  
    66. 
  
  
  
  
  66.                      {  
    67. 
  
  
  
  
  67.                          state = Error;  
    68. 
  
  
  
  
  68.                          break;  
    69. 
  
  
  
  
  69.                      }  
    70. 
  
  
  
  
  70.                  }  
    71. 
  
  
  
  
  71.                  else if (b < 0xc0)  
    72. 
  
  
  
  
  72.                  {  
    73. 
  
  
  
  
  73.                      // 10xxxxxx : continues UTF8 byte sequence  
    74. 
  
  
  
  
  74.                      if (state == UTF8Sequence)  
    75. 
  
  
  
  
  75.                      {  
    76. 
  
  
  
  
  76.                          --sequenceLength;  
    77. 
  
  
  
  
  77.                          if (sequenceLength < 0)  
    78. 
  
  
  
  
  78.                          {  
    79. 
  
  
  
  
  79.                              state = Error;  
    80. 
  
  
  
  
  80.                              break;  
    81. 
  
  
  
  
  81.                          }  
    82. 
  
  
  
  
  82.                          else if (sequenceLength == 0)  
    83. 
  
  
  
  
  83.                          {  
    84. 
  
  
  
  
  84.                              state = UTF8;  
    85. 
  
  
  
  
  85.                          }  
    86. 
  
  
  
  
  86.                      }  
    87. 
  
  
  
  
  87.                      else 
    88. 
  
  
  
  
  88.                      {  
    89. 
  
  
  
  
  89.                          state = Error;  
    90. 
  
  
  
  
  90.                          break;  
    91. 
  
  
  
  
  91.                      }  
    92. 
  
  
  
  
  92.                  }  
    93. 
  
  
  
  
  93.                  else if (b >= 0xc2 && b < 0xf5)  
    94. 
  
  
  
  
  94.                  {  
    95. 
  
  
  
  
  95.                      // beginning of byte sequence  
    96. 
  
  
  
  
  96.                      if (state == UTF8 || state == ASCII)  
    97. 
  
  
  
  
  97.                      {  
    98. 
  
  
  
  
  98.                          state = UTF8Sequence;  
    99. 
  
  
  
  
  99.                          if (b < 0xe0)  
    100. 
  
  
  
  
  100.                          {  
    101. 
  
  
  
  
  101.                              sequenceLength = 1; // one more byte following  
    102. 
  
  
  
  
  102.                          }  
    103. 
  
  
  
  
  103.                          else if (b < 0xf0)  
    104. 
  
  
  
  
  104.                          {  
    105. 
  
  
  
  
  105.                              sequenceLength = 2; // two more bytes following  
    106. 
  
  
  
  
  106.                          }  
    107. 
  
  
  
  
  107.                          else 
    108. 
  
  
  
  
  108.                          {  
    109. 
  
  
  
  
  109.                              sequenceLength = 3; // three more bytes following  
    110. 
  
  
  
  
  110.                          }  
    111. 
  
  
  
  
  111.                      }  
    112. 
  
  
  
  
  112.                      else 
    113. 
  
  
  
  
  113.                      {  
    114. 
  
  
  
  
  114.                          state = Error;  
    115. 
  
  
  
  
  115.                          break;  
    116. 
  
  
  
  
  116.                      }  
    117. 
  
  
  
  
  117.                  }  
    118. 
  
  
  
  
  118.                  else 
    119. 
  
  
  
  
  119.                  {  
    120. 
  
  
  
  
  120.                      // 0xc0, 0xc1, 0xf5 to 0xff are invalid in UTF-8 (see RFC 3629)  
    121. 
  
  
  
  
  121.                      state = Error;  
    122. 
  
  
  
  
  122.                      break;  
    123. 
  
  
  
  
  123.                  }  
    124. 
  
  
  
  
  124.              }  
    125. 
  
  
  
  
  125.              fs.Position = 0;  
    126. 
  
  
  
  
  126.              switch (state)  
    127. 
  
  
  
  
  127.              {  
    128. 
  
  
  
  
  128.                  case ASCII:  
    129. 
  
  
  
  
  129.                  case Error:  
    130. 
  
  
  
  
  130.                      // when the file seems to be ASCII or non-UTF8,  
    131. 
  
  
  
  
  131.                      // we read it using the user-specified encoding so it is saved again  
    132. 
  
  
  
  
  132.                      // using that encoding.  
    133. 
  
  
  
  
  133.                      if (IsUnicode(defaultEncoding))  
    134. 
  
  
  
  
  134.                      {  
    135. 
  
  
  
  
  135.                          // the file is not Unicode, so don't read it using Unicode even if the  
    136. 
  
  
  
  
  136.                          // user has choosen Unicode as the default encoding.  
    137. 
  
  
  
  
  137.    
    138. 
  
  
  
  
  138.                          // If we don't do this, SD will end up always adding a Byte Order Mark  
    139. 
  
  
  
  
  139.                          // to ASCII files.  
    140. 
  
  
  
  
  140.                          defaultEncoding = Encoding.Default; // use system encoding instead  
    141. 
  
  
  
  
  141.                      }  
    142. 
  
  
  
  
  142.                      return new StreamReader(fs, defaultEncoding);  
    143. 
  
  
  
  
  143.                  default:  
    144. 
  
  
  
  
  144.                      return new StreamReader(fs);  
    145. 
  
  
  
  
  145.              }  
    146. 
  
  
  
  
  146.          } 
    147.

ITextSharp文件识别基本思路：

1.传入需要读取文件流，并且传入一个你认为合适的编码方式，当然你可以传入NULL。

2.读取文件前面2个字节（这个是大部分解析编码需要做的事情），读取进来的字节向左移8位,然后与第二个字节进行 | 运算，主要用途是检测StreamReader是否在iso - 8859 - 1和utf - 8之间的编码范围，并且不包含BOM。

忘记了C#这些运算的可以看看，http://www.cnblogs.com/NatureSex/archive/2011/04/21/2023768.html

3.当位移出来的结果等于0x0000,0xfffe,0xfeff,0xefbb时，是StreamReader可以进行自动读取范围内的。如果不在范围内时再进行读取偏移检测，具体怎么检测的，这个有点难度，本人也只是看懂了一点点，主要是系统编码知识欠缺。

五.下载

下载地址：VS重命名工具   喜欢的朋友记得推荐一下哟

源码就不放了，文件没有混淆也没有加密，自己反编译统统都有。

原文链接：http://www.cnblogs.com/NatureSex/archive/2013/03/21/2971596.html

当前名称：VS项目整体重命名工具
URL链接：http://www.shufengxianlan.com/qtweb/news34/488684.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

标签优化知识

行业网站建设

免备案空间腾讯云　　 　网站制作　　 　水泥基自流平　　 　网站开发　　 　响应式网站建设　　 　简阳机房托管　　 　小谭网创广告　　 　鸿艺文化　　 　鼎尚理发店　　 　虚拟主机购买　　 　成都做网站　　 　成都广告公司　　 　网上商城管理系统　　 　成都画册快印　　 　成都网站设计公司　　 　重庆教育培训网站建设　　 　云虚拟主机　　 　德阳电信机房　　 　瑞杰企业管理　　 　网站建设方案