Introduction
Updated to v1.3 on 31-July-2007: See updated source, notes in article and Revision history for details. There are already a couple of good Visual Studio solution and project zipping tools available:
- ProjectZip 1.6: Zip up the source code for your latest CodeProject article
- ZipStudio: A versatile Visual Studio add-in to zip up Visual Studio solutions and projects
The code described in this article provides a simplified version of these add-ins. Specifically, SolutionZipper has a single-click-does-everything interface, which is what automation is all about: saving time. There are no dialogs that present file lists, file names to be chosen or user options to select. SolutionZipper does the following in a single step:
- Saves all unsaved project files
- Cleans all available solution configurations (Debug, Release, etc.)
- Cleans all Deployment Projects
- Zips all files in the entire solution:
- The ZIP file is uniquely named SolutionName_YYYYMMDD-HHMMSS.zip
- The path for all files are solution directory relative
- The ZIP file is placed at the same level as the solution directory
When these operations are completed, a confirmation dialog is displayed:
The ZIP file can be used to share projects and is in the proper form for CodeProject submissions (of course). If you are not using a source code control system, SolutionZipper is useful for quickly backing up a snapshot of a solution at major development milestones.
Add-in implementation
The standard VS Add-in Wizard was used to create the project. See How to: Create an Add-in for details. In order to get a custom icon on the menu item,
follow the instructions in How to: Display a Custom Icon on the Add-in Button carefully. Also note that the icon must be exactly 16x16 pixels to be displayed. ICSharpCode.SharpZipLib.dll is used for the ZIP implementation and can be downloaded here.
Automation
The automation actions are implemented in the IDTExtensibility2.Exec function.
public void Exec(string commandName,
vsCommandExecOption executeOption,
ref object varIn, ref object varOut, ref bool handled)
{
handled = false;
if(executeOption ==
vsCommandExecOption.vsCommandExecOptionDoDefault)
{
if(commandName ==
"SolutionZipper.Connect.SolutionZipper")
{
const string ADDIN_NAME = "SolutionZipper";
_Solution sol = _applicationObject.Solution;
handled = true;
if (string.IsNullOrEmpty(sol.FullName)) return;
string solpath = Path.GetDirectoryName(sol.FullName);
string extDir = null;
EnvDTE.StatusBar statusbar = _applicationObject.StatusBar;
statusbar.Text = ADDIN_NAME + ": Save All Files...";
_applicationObject.ExecuteCommand("File.SaveAll", "");
statusbar.Text = ADDIN_NAME + ": Cleaning all configurations...";
SolutionBuild2 sb = (SolutionBuild2)sol.SolutionBuild;
SolutionConfiguration curr_conf = sb.ActiveConfiguration;
foreach (SolutionConfiguration s in sb.SolutionConfigurations)
{
s.Activate();
sb.Clean(true); }
curr_conf.Activate();
statusbar.Text = ADDIN_NAME + ": Handle deployment projects...";
foreach (Project p in sol.Projects)
{
try
{
if (p.UniqueName.IndexOf(".vdproj",
0, StringComparison.CurrentCultureIgnoreCase) != -1)
{
string vddir = Path.GetDirectoryName(p.FullName);
DeleteDirContents(Path.Combine(vddir, "Release"));
DeleteDirContents(Path.Combine(vddir, "Debug"));
}
}
catch (NullReferenceException)
{
string wdprojfile =
Path.Combine(Path.Combine(solpath, p.Name),
p.Name + ".wdproj");
if (File.Exists(wdprojfile))
{
string wddir = Path.Combine(solpath, p.Name);
DeleteDirContents(Path.Combine(wddir, "Release"));
DeleteDirContents(Path.Combine(wddir, "Debug"));
}
}
catch (Exception ex)
{
MessageBox.Show(string.Format(
"An Error has occurred:\n{0}\n\nZip " +
"file not created.",
ex.Message), ADDIN_NAME,
MessageBoxButtons.OK, MessageBoxIcon.Error);
statusbar.Clear();
return;
}
}
ExtProjectMap fmap = null;
statusbar.Text = ADDIN_NAME + ": Handle external projects...";
foreach (Project p in sol.Projects)
{
try
{
string uname = p.UniqueName;
}
catch (NullReferenceException)
{
continue;
}
if (!string.IsNullOrEmpty(p.FileName)
&& Path.IsPathRooted(p.FileName) &&
p.FileName.IndexOf(solpath) == -1)
{
if (extDir == null)
{
extDir = Path.Combine(solpath, "szExternalProjects");
if (!Directory.Exists(extDir))
{
try
{
Directory.CreateDirectory(extDir);
}
catch (Exception ex)
{
MessageBox.Show(string.Format(
"Failed to create temporary " +
"directory:\n{0}\nError: " +
"{1}\n\nZip file not created.",
extDir, ex.Message), ADDIN_NAME,
MessageBoxButtons.OK,
MessageBoxIcon.Error);
statusbar.Clear();
return;
}
}
fmap = new ExtProjectMap(extDir);
}
string srcPath = Path.GetDirectoryName(p.FullName);
string dstPath =
Path.Combine(extDir, Path.GetFileName(srcPath));
try
{
xDirectory.Copy(srcPath, dstPath);
}
catch (Exception ex)
{
MessageBox.Show(string.Format(
"Failed to copy:\n\nSource: " +
"{0}\nDestination: {1}\n\nError: {2}\n\nZip " +
"file not created.",
srcPath, dstPath, ex.Message),
ADDIN_NAME, MessageBoxButtons.OK,
MessageBoxIcon.Error);
DeleteDirContents(extDir);
statusbar.Clear();
return;
}
fmap.Add(Path.GetFileName(srcPath) +
"\\" + Path.GetFileName(p.UniqueName),srcPath);
}
}
statusbar.Text = ADDIN_NAME + ": Creating Zip file...";
DateTime dt = DateTime.Now;
string sname = Path.GetFileName(sol.FileName);
string zipname =
string.Format("{0}_{1:D2}{2:D2}{3:D2}-{4:D2}{5:D2}{6:D2}.zip",
sname.Substring(0, sname.Length - 4),
dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, dt.Second);
string zippath =
Path.Combine(Path.GetDirectoryName(solpath),zipname);
ZipDirectoryHierarchy zs = new ZipDirectoryHierarchy();
zs.ZipIt(solpath, zippath);
if (extDir != null)
{
statusbar.Text = ADDIN_NAME + ": Project clean-up...";
DeleteDirContents(extDir);
}
statusbar.Clear();
MessageBox.Show(string.Format(
"Successfully created:\n\n{0}\n\n{1}",
zippath,zs.StatusString),
ADDIN_NAME, MessageBoxButtons.OK,
MessageBoxIcon.Information);
return;
}
}
}
This code is pretty self-explanatory.
Notes
- In addition to its
Text property, EnvDTE.StatusBar also has a Progress method that allows control of the VS progress bar
- The
_DTE.ExecuteCommand method allows you to execute any VS command or macro. The command name can be found in the Tools>Options>Environment>Keyboard dialog, which has a nice search feature:
- All available solution configurations are cleaned. Unfortunately, VS does not provide a way to clean Deployment Projects. This is handled by searching through all projects and finding those that have
".vdproj" in the UniqueName property. The contents of the Release and Debug directories are then deleted.
- v1.1 update notes:
- Projects that do not reside in the solution directory are cleaned and then copied to the current solution in a temporary directory,
szExternalProjects. After the ZIP file is created, the temporary directory is removed. See Revision history for more details.
- Note that the
DeleteDirContents method now removes the entire directory tree recursively, including the directory itself.
- v1.2 update notes:
- Added improved error handling. See Revision history for more details.
- Added support for Web Deployment projects. See Revision history for more details. Other than cleaning these projects when they exist in the solution directory, the changes mostly protect SolutionZipper from crashing due to the incomplete
Project instance they create.
- The
ExtProjectMap class creates a ExternalProjectsMap.txt file and adds an entry for each external project added to the temporary directory. This documentation allows for easier reconstruction of the solution from the extracted ZIP. Here is an example:
SolutionZipper: External projects in this directory.
Project : Original Path
---------------------- : -------------
extProject\extProject.csproj: C:\Projects\SolutionZipper\
extProject\extProject
extSetup\extSetup.vdproj : C:\Projects\SolutionZipper\
extProject\extSetup
- The
IDTExtensibility2.QueryStatus function was modified so that the SolutionZipper Tools menu item would only be available when a saved solution is loaded into the IDE.
public void QueryStatus(string commandName,
vsCommandStatusTextWanted neededText,
ref vsCommandStatus status, ref object commandText)
{
if(neededText ==
vsCommandStatusTextWanted.vsCommandStatusTextWantedNone)
{
if(commandName == "SolutionZipper.Connect.SolutionZipper")
{
status = (vsCommandStatus
)vsCommandStatus.vsCommandStatusSupported;
if (!string.IsNullOrEmpty(
_applicationObject.Solution.FullName))
status |= vsCommandStatus.vsCommandStatusEnabled;
return;
}
}
}
ZipDirectoryHierarchy
Since there are usually other non-project files somewhere in the solution, it is preferable to simply zip up the entire solution directory hierarchy. The ZipDirectoryHierarchy class uses the SharpZipLib to do this. The path entries in the ZIP file will be relative, i.e. not begin with \, and will start at the solution directory.
internal class ZipDirectoryHierarchy
{
private int DirCount = 0;
private int FileCount = 0;
private long ByteCount = 0;
private void ZipOne(ZipOutputStream s,
Crc32 crc, string basedir, string file)
{
if (Path.GetExtension(file) == ".ncb")
return; FileInfo fi = new FileInfo(file);
if ((fi.Attributes & FileAttributes.Hidden) != 0)
return; FileStream fs = File.OpenRead(file);
byte[] buffer = new byte[fs.Length];
fs.Read(buffer, 0, buffer.Length);
String relpath = file.Substring(basedir.Length + 1);
ZipEntry entry = new ZipEntry(relpath);
entry.DateTime = DateTime.Now;
entry.Size = fs.Length;
this.FileCount++;
this.ByteCount += entry.Size;
fs.Close();
crc.Reset();
crc.Update(buffer);
entry.Crc = crc.Value;
s.PutNextEntry(entry);
s.Write(buffer, 0, buffer.Length);
}
private void ZipDirectory(ZipOutputStream s,
Crc32 crc, string basedir, string dirpath)
{
string[] filenames = Directory.GetFiles(dirpath);
if (filenames.Length > 0)
{
this.DirCount++;
foreach (string file in filenames)
{
ZipOne(s, crc, basedir, file);
}
}
string[] dirs = Directory.GetDirectories(dirpath);
foreach (string dir in dirs)
{
DirectoryInfo di = new DirectoryInfo(dir);
if ((di.Attributes & FileAttributes.Hidden) == 0)
ZipDirectory(s, crc, basedir, dir);
}
}
public void ZipIt(string dirpath, string zipname)
{
Crc32 crc = new Crc32();
ZipOutputStream s = new ZipOutputStream(File.Create(zipname));
s.SetLevel(6); string basepath = Path.GetDirectoryName(dirpath);
ZipDirectory(s, crc, basepath , dirpath);
s.Finish();
s.Close();
}
public string StatusString
{
get
{
return string.Format(
"{0,-6}\tKB " +
"(uncompressed)\n{1,-6}\tFiles\n{2,-6}\tDirectories",
ByteCount / 1024, FileCount, DirCount);
}
}
}
Compatibility
I have only been able to test SolutionZipper on a limited number of environments and project types.
- VS 2005: C# and Deployment projects are OK. It has not been tested on any other project types -- but it should work.
- VS 2003: In addition to the Add-in installation differences between VS2003 and VS2005, SolutionZipper.dll is a .NET 2.0 assembly, so it will not work with older IDEs. It shouldn't be difficult to port Connect.cs back to VS 2003 though.
- VS C# Express Edition: Does not work. Express Editions do not support Add-ins.
Conclusion
Please let me know if you have problems with SolutionZipper. I will provide bug fix updates as necessary and will consider including suggested enhancements in the future. Enjoy!
- v1.3: 31-July-2007
- Fixed a bug that was causing SZ to fail during the "Handle external projects" phase.
- Ignore VC++ Intellisense Database files, i.e. *.ncb.
- Ignore hidden files and folders.
- v1.2: 17-Sep-2006
- Fixed a bug in
DeleteDirContents that was causing SolutionZipper to fail if the directory did not exist.
- Added error messages for when failures occur. One typical situation is when a project contains a file that is currently in use by another process. The inability to access that file will cause an error. For example, the following error will occur when trying to zip a web project when the ASP.NET development server is running:
This is solved by stopping the development server and running SolutionZipper again.
- Added an external project map file, ExternalProjectsMap.txt, to the szExternalProjects directory. This file shows the original full directory path for each project in that directory. See details here.
- Added limited support for web deployment projects. "Limited" means that the web deployment project must reside within the solution directory. This is because these project types only provide the
Name property in the Project instance, so it is impossible to know the actual project directory. What's interesting is that other Project properties, like UniqueName, contain instances of an Exception. I've used this to keep SolutionZipper from failing when this project type is encountered.
- v1.1: 09-Sep-2006
- SolutionZipper v1.0 did not take into account that Visual Studio allows solutions to contain projects that reside outside of the solution directory. There were two possible solutions for this:
- Include the external projects in the ZIP file with "project" level relative directories at the same level as the solution directory.
- Copy the external projects into a temporary solution directory and remove the temporary directory after the ZIP file is created. All projects are maintained under the single solution directory.
I decided to take the second approach because the external projects in #1 would likely be extracted to the wrong location. In either case then, the external projects would have to be manually copied back to their original location. However, solution #2 avoids possible confusion. External C# and deployment projects were added to the SolutionZipper solution source for testing.
- The
DeleteDirContents method now removes the entire directory tree recursively, including the directory itself.
- Recursive directory copy code is from xDirectory.Copy() - Copy Folder, SubFolders and Files (unmodified).
- v1.0: 05-Sep-2006
