Summit Software

Tools to Automate VSTA 2 Integrations: AutoProxyGen and Templates

Melody — Wed, 01 Oct 2008 19:48:00 GMT

We have new downloads up including templates and a new tool AutoProxyGen which automates ProxyGen and can be used in build events.

AutoProxyGen:
This tool automates the process of using ProxyGen and can be used as a build event. AutoProxyGen includes workarounds for ProxyGen bugs including automatically excluding structs and ensuring that items which are not marked as excluded are not excluded. AutoProxyGen includes a basic VSTA integration which can be used for further customizations, such as examining the host for custom attributes to specify entry points and excluded items and correcting the inheritance error which prevents COM hosts from exposing events.

A sample add-in demonstrating how to correct the inheritance error for COM hosts is included, other add-ins are available upon request.

Video: From ProxyGen to AutoProxyGen

Templates:
Templates to help automate VSTA v 2.0 integrations are now available. Run the included setup file to move the templates to the Visual Studio 2008 template caches (may need to restart Visual Studio for templates to work).

Proxy Project- includes all files and post build event necessary to place the proxy assembly in the GAC and rebuild the VSTA pipeline. C# only. (may want to create a new or use existing key.snk file)
Host Item Provider- Use Find&Replace to replace "YourEntryPointType" with the type of the host entry point. Includes necessary references. Item template. VB & C#
VstaRunTimeIntegration- Update the variables in the "Variables to update" section including the host entry point type, start-up class for add-ins, and the folder in %MyDocuments% to find add-ins in. Includes necessary references. Item Template. VB & C#

Sample: Watchdog to terminate orphaned VSTA process

Gary — Fri, 26 Sep 2008 18:43:00 GMT

This is an IPH sample, IPHTerminateOrphanedVSTA. It uses a global mutext to start one, and only one, simple observer thread. The observer thread continues to execute while the vsta process is alive, whether or not a project is open.. The observer thread periodically checks for existence of the hostProcess. If there is no hostProcess running, and there is an orphaned vsta.exe, the observer thread shuts down the orphan vsta process before exiting. The IPH allows opening the VSTA as a standlone IDE (observer thread is not started).

Visit Summit at PDC 2008 Booth #518

dschneid — Wed, 17 Sep 2008 16:54:00 GMT

Summit Software is pleased to announce that we will be exhibiting at PDC2008.

We invite you to visit us during your visit there and learn about VSTA 2.0 and how integration of VSTA 2.0 with your application can lead to competitive advantage.

Our team will be ready to meet with you to discuss your VSTA plans, and we would encourage you to schedule some time to disucss VSTA.

Please send an email to me, dschneid@summsoft.com, and we can schedule a 20 minute block for a meeting to disucss your needs.

We look forward to seeing you at PDC2008.

Solidworks 2009 Shipping with VSTA

dschneid — Fri, 12 Sep 2008 14:09:00 GMT

Solidworks Corporation has integrated Microsoft Visual Studio Tools for Applications (VSTA) into its Solidworks 2009 product line as a significant enhancement to the Solidworks API.

Solidworks is a 3D mechanical CAD product used by product designers and mechanical engineers worldwide. To learn more about the features and functionality of Solidworks 2009, please see the Solidworks 2009 website.

Summit is pleased that Solidworks 2009 users now have the ability to leverage VSTA for Macro Recording and additional customization.

New EventSample for VSTA v 2 (VB.Net)

Melody — Tue, 02 Sep 2008 17:43:00 GMT

Overview:

This sample is intended to expose several common tasks in VSTA, including: declaring an object, using and manipulating a form, and handling form events and event args. This sample contains a very simple object, form, application with a basic VSTA integration, and an add-in. An EventHelper is used to prevent any errors in add-in event handling.

To run the sample, extract the files, open and build the EventSample solution, then run the setup file included (double click or use the command “cscript SetupEventSample.js” from a command prompt). Next, open and build the add-in solution included in the Samples folder. Run the EventSample application, which should now automatically find and load the sample add-in included.

The EventSample application records button clicks and input from a text box in a list box. The sample add-in responds to mouse clicks on any of the buttons on the form, to adding input through the add button, clearing the display, and selecting the Open button. Event handling for the Save and Close buttons in the add-in is not implemented.

Included in this sample:

Item	Description
MainForm	Main user form and empty code class.
Program	Starting point in the host application.
MainApplication	Main application class. All application specific code is here.
MainObject	Main object used by the MainApplication class. Consists of a string.
EventArgs	Contains class definitions for custom event used by the MainApplication.
EventHelper	Class taken from ShapeApp samples to manage events from the host application and add-ins.
VstaRunTimeIntegration	Class based on the ShapeApp samples which uses the VSTA pipeline to load and manage add-ins.
HostItemProvider	Class based on the ShapeApp samples which allows add-ins to access the host object model.
HostTypeMapProvider	HTMP file generated by ProxyGen and translated into Visual Basic. Maps the types to canocial names for translation between the host and add-ins.
EventSampleProxy	Proxy file generated by ProxyGen and updated to allow generic event handling.
EventSampleProject1	A sample add-in that interacts with the events of the host application.

VSTA 2.0 RTM now available

dschneid — Wed, 27 Aug 2008 18:54:00 GMT

I am pleased to announce the Release to Manufacturing (RTM) of Microsoft Visual Studio Tools for Applications (VSTA) 2.0.

The VSTA 2.0 RTM bits are available from the following location:

http://www.summsoft.com/VSTAInfReq.aspx

If you have an account with Summit, please use your login credentials to access the VSTA 2.0 SDK.

If you have not registered with Summit, please do so to access the SDK.

We look forward to working with you during your evaluation and integration of VSTA 2.0.

If you have questions, please contact me directly at dschneid@summsoft.com.

David Schneid
General Manager
Summit Software Company

How to Update a Host’s Folder in %My Documents%

Melody — Mon, 25 Aug 2008 16:33:00 GMT

VSTA hosts use a host specific folder under %My Documents% (or %Documents for Vista) for various purposes. This is where the settings file is stored and is the default save location is for new VSTA projects for the host (unless a different location is specified under the registry entry NewProjectLocation).

Most configuration settings can be updated by deleting the host context hive under the local machine hive (see Note 1 registry location), then running vsta setup for the host. Unlike other registry settings, to update which folder is used in %My Documents% the host context hive under the local user hive (see Note 2 for registry location) must be deleted prior to running vsta setup for the host, and will be populated the next time VSTA is run for the host. This context hive must be deleted if specifying the folder under %My Documents% with either the AppName or UserFilesFolderName registry entries.

The folder under %My Documents% which will be used is determined by the UserFilesFolderName, which specifies which folder under %My Documents% will be used (see Note 3 for examples). If no UserFilesFolderName is specified the AppName is used, which specifies the title to appear in the VSTA IDE title bar. If no AppName is specified, the hostId is used.

This host specific folder under %My Documents% will also be the default save location for new projects unless a different location is specified with the NewProjectLocation entry, which specifies the absolute location of the folder which will be used (not under %My Documents%, see Note 4 for examples).

Note 1- The context registry hive under the local machine registry hive is located at: HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VSTAHost\<HostId>\9.0

Note 2- The context registry hive under the local user registry hive is located at: HKEY_CURRENT_USER\Software\Microsoft\VSTAHost\<HostId>\9.0

Note 3- The UserFilesFolderName entry specifies which folder under %My Documents% the host will use, not an absolute path.
                Example good: “ShapeAppDocuments”
                Example bad: “C:\ShapeAppDocuments”

Note 4- the NewProjectLocation entry specifies an absolute folder which will be the default save location for new VSTA projects for the host.
                Example good: “C:\ShapeAppDocuments”
                Example bad: “ShapeAppDocuments”

For more information on host registry settings, please refer to MSDN which now features VSTA v 2.0. Click here to go to the Registering a Host Application section.

This applies to VSTA 2005 (v1) and 2008 (v2), the registry hives used above are for VSTA v 2.

Proxy Versioning Options for Project Templates

Melody — Fri, 15 Aug 2008 16:35:00 GMT

A common question is how to use versioning for the proxy assembly in add-ins. There are basically three different options. (Download Sample)

1) No Versioning:

Only the name of the assembly is used in the project template and the first assembly in the GAC matching this name will be used. This is how ProjectGen references the proxy in the project template file.

Pros: Will load any proxy present.
Cons: No control over which version of the proxy is loaded. When the intended version is present, but not first in the GAC, it will not load and the project may not build.

2) Tight Versioning:

The name and version of the proxy assembly is used in the project template with the option specific version set to true.

Pros: Correct version will always load if present.
Cons: If correct version is not present, but a compatible version is, the project will not load the compatible version and build.

3) Loose Versioning:

A name and version of the proxy assembly is used in the project template with the option specific version set to false or not set.

Pros: Correct version will load if present. If correct version is not present the first assembly with a matching name in the GAC will load.
Cons: No control over which version is loaded if the correct version is not present.

Here’s some examples which illustrate the differences in versioning.

Assumption- three proxies are in the GAC corresponding to three different versions of the same host:

ShapeAppCSharp Version 1.0.0.0 from VSTA v 1 SDK sample. Using Host v 1.0.0.0.
ShapeAppCSharp Version 2.0.0.0 from VSTA v 2 SDK sample with version of proxy assembly changed to 2.0.0.0. Using Host v 2.0.0.0.
ShapeAppCSharp Version 2.1.0.0 from VSTA v 2 SDK sample with a method added to the Application class (Application.DrawingHasShapes) and the version of the proxy assembly changed to 2.1.0.0. Using Host v 2.1.0.0. The proxy v 2.1.0.0 is compatible v 2.0.0.0 projects.

Test 1: Open a VSTA v 2 project for Host v 2.1.0.0 using the method added (Application.DrawingHasShapes) with the above assemblies in the GAC.

No Versioning- Fail. Project will load the ShapeAppCSharp Version 1.0.0.0 project and not build because this assembly is for the v 1.0.0.0 host which uses VSTA v 1.

Tight Versioning- Pass. Project will load the correct proxy.

Loose Versioning- Pass. Project will load the correct proxy. *Note: if the host which loads this add-in is v 2.0.0.0 the add-in will fail during execution because the method added to v 2.1.0.0 is not present in the host.

Test 2: Open a VSTA v 2 project for Host v 2.0.0.0 with only the v 2.1.0.0 assemblies in the GAC.

No Versioning- Pass. Only proxy present will load and the project will build because the v 2.1.0.0 proxy is compatible with v 2.0.0.0 projects. *Note: if the v1 proxy was still in the GAC this may fail.

Tight Versioning- Fail. The specific version of the proxy is not present, so no proxy assembly will be loaded. *Note by setting the Specific Reference attribute to false in the properties window (in the Project Explorer) the project will change to Loose Versioning and pass.

Loose Versioning- Pass. The compatible v 2.0.0.0 will load. *Note: if the v1 proxy was still in the GAC this may fail.

We offer a sample which shows how to implement Tight Versioning- click here.

Updating Project References Programmatically

Melody — Wed, 13 Aug 2008 19:10:00 GMT

A host, or helper application, can programmatically update a reference in a project. One instance where this is useful is when you want to ensure that a specific version of a proxy reference is used.

Below is an updated version of the OpenMacroProject from the ShapeAppMacroRecordingCSharp sample which updates the reference in the project to use second version of the ShapeAppCSharpProxy. The proj file is updated prior to loading to avoid any messages indicating that the project file has been updated and needs to be reloaded.

private void OpenMacroProject()
{
    // See if the project is already loaded.
    foreach (EnvDTE.Project currProject in this.dte.Solution.Projects)
    {
        string projPath = currProject.FileName;
        if (String.Compare(projPath,
                           VstaDesignTimeIntegration.MacroProjectFilePath,
                           StringComparison.OrdinalIgnoreCase) == 0)
        {

            this.macroProject = currProject;

            // Set the post build-event to install the Macro AddIn assembly into the
            // user's Documents folder i.e. "...\Documents\ShapeAppCSharp\MacroAddIns"
            this.macroProject.Properties.Item("PostBuildEvent").Value =
                "cscript \"$(ProjectDir)InstallAddIn.js\" \"$(TargetPath)\" \"ShapeAppCSharp\\MacroAddIns\"";

            RegisterAsDebugHost();
            return;
        }
    }

    //SUMMIT- update the reference
    {
        //namespace for the project file
        XNamespace ns = "http://schemas.microsoft.com/developer/msbuild/2003";

        //load the proj file
        XDocument projDoc = XDocument.Load(VstaDesignTimeIntegration.MacroProjectFilePath);

        //get the node with the reference to update
        var oldRef = (from refs in projDoc.DescendantNodes()
                 where refs.ToString().StartsWith("<Reference") &&
                 refs.ToString().Contains("ShapeAppCSharpProxy")
                 select refs).First();

        //create the new version specific reference
        XElement updRef = new XElement(ns + "Reference",
            new XAttribute("Include", "ShapeAppCSharpProxy, Version=2.0.0.0"),
            new XElement(ns + "SpecificVersion", "true"));

        //update the node
        oldRef code.ReplaceWith(updRef);

        //save the document
        projDoc.Save(VstaDesignTimeIntegration.MacroProjectFilePath);
    }

    // Load the project as it is not currently loaded
    this.macroProject = this.dte.Solution.AddFromFile(
        VstaDesignTimeIntegration.MacroProjectFilePath, true);
    RegisterAsDebugHost();
}

To use this code to correct the side by side evaluation issue (both versions of the ShapeAppCSharp samples use the ShapeAppCSharpProxy) be sure to version the proxy assembly and add the above code.

Bit Lock During Out of Process Debugging Workaround

Melody — Mon, 04 Aug 2008 14:13:00 GMT

During out of process debugging occasionally the pdb file becomes locked and prevents builds from finishing successfully. The VstaDesignTimeIntegration.DeleteMacroPdb method, called in OnBuildBegin, is suppose to ensure that this does not happen by cycling until the bits are no longer locked, then deleting them. Unfortunately this does not always work and the project can get stuck in an unbuildable state. Keyvan Nayyeri posted a workaround to a similar issue in add-in programming (the dll file becoming locked) which can be applied to this. He suggests using a pre-build event to move/rename the locked files thus clearing the way for the updated bits to be built.

Keyvan’s workaround:
You can add following lines of code to the pre-build event command line of your project.

if exist "$(TargetPath).locked" del "$(TargetPath).locked"
if exist "$(TargetPath)" if not exist "$(TargetPath).locked" move "$(TargetPath)" "$(TargetPath).locked"

Ways to apply workaround:

Use the above pre-build event modified to move the pdb file instead of the dll.*
Use a modified version of the InstallAddIn.js file used in the post build event in the pre-build event to move the pdb bits.*
In the DeletePdb method move the locked file in the catch block (see code below).

* Keep in mind that like the post build event, the pre build event can be added programmatically.

By using this workaround, the build will no longer fail if the pdb bits become locked. However, if the bits do become locked, debugging will fail.

Related blog: ShapeAppMacroRecordingCSharp- common problems and workarounds
One issue with the DeletePdb bit method is that it catches only the IOException, not the UnauthorizedAccessException which is also thrown.

Code for #3 In the DeletePdb method move the locked file in the catch instead of cycling

private static void DeleteMacroPdb()

{

string projectPath = Path.GetDirectoryName(VstaDesignTimeIntegration.MacroProjectFilePath);

string[] pdbFiles = Directory.GetFiles(projectPath, "*.pdb", SearchOption.AllDirectories);

// Delete all PDB files for the project under \obj\.. and \bin\.. folders.

// If a file is locked, retry to delete that file after 100 milliseconds.

foreach (string pdbFile in pdbFiles)

{

bool done = false;

int retry = 0;

// Retry a maximum of 5 seconds to delete the file.

while (!done && retry <= 50)

{

try

{

File.Delete(pdbFile);

done = true;

}

catch (IOException ex)

{

File.Delete(pdbFile+"old");

File.Move(pdbFile, pdbFile + "old");

Thread.Sleep(100);

retry++;

}

catch (Exception ex)

{

File.Delete(pdbFile + "old");

File.Move(pdbFile, pdbFile + "old");

Thread.Sleep(100);

retry++;

}

Using VSTA to Create Office Documents Through XML

Melody — Tue, 17 Jun 2008 17:06:00 GMT

With the introduction of LINQ to XML and the OpenXml formatting of Office 2007 documents it is incredibly easy to use VSTA to import and export data from a host application to an Office document and vice versa. One benefit of using OpenXml (or for Excel straight xml as well) is that this can be performed without installing Office or using the office API's, which allows this processing to be done on servers as well as desktops.

A new sample is available showing how to export ShapeApp shape data into Word and Excel using VSTA v 2 and taking advantage of the easy to use LINQ to XML with Visual Basic.

To download the sample add-ins, click here. To go to the download page, click here.

From the Xml Office AddIn Instructions:

Office 2007 introduced a new storage method for Office document. The new documents are actually packages- they are zip files of xml documents. To explore one of these packages, change the extension to .zip and explore it like any other zip file, or download the package explorer tool from CodePlex to explore and edit the package without unzipping or using Office. This new document packaging format makes it very easy to import or export data between a host and an Office document.

Two add-ins for ShapeAppCSharp (VSTA v 2) are available demonstrating how to save ShapeApp data into a Word or Excel document. The SaveToWord add-in uses the Open Xml Format SDK to add data to the main document (document.xml) of the Word package (System.IO.Packaging could be used instead with minor modifications). The SaveToExcel add-in uses straight Xml instead of OpenXml to get data into Excel because it is far easier to work with straight Xml in Excel. Excel can save and open Xml documents without worrying about packaging. Visual Basic was used to write both add-ins because Visual Basic works better than C# with LINQ to XML.

From the ShapeAppCSharp_SaveToWord add-in:

'This method populates the word document with ShapeAppData

Public Sub SetMainDocumentContent(ByVal part As MainDocumentPart)

Const name As String = "Name: "

Const size As String = "Size: "

Const loc As String = "Location: "

Const color As String = "Color: "

'query the shapes in the first drawing using LINQ to XML

Dim docBodyData = From shape In Me.Document.Drawings(0).Shapes _

Select _

<w:body>

<w:p><w:r><w:t><%= name & shape.Name %></w:t></w:r></w:p>

<w:p><w:r><w:tab/></w:r><w:r><w:t>

<%= size & shape.Size.Height.ToString() & ", " & shape.Size.Width.ToString() %>

</w:t></w:r></w:p>

<w:p><w:r><w:tab/></w:r><w:r><w:t>

<%= loc & shape.Location.X.ToString() & ", " & shape.Location.Y.ToString() %>

</w:t></w:r></w:p>

<w:p><w:r><w:tab/></w:r><w:r><w:t>

<%= color & shape.Color.A.ToString() & ", " & shape.Color.R.ToString() & ", " & _

shape.Color.B.ToString() & ", " & shape.Color.G.ToString() %>

</w:t></w:r></w:p>

</w:body>

'to get the xml stuff from word- create a new doc, add dummy data as a place holder

' in the format you want to export it, then copy the xml from the document.xml part

' of the package. Remove the dummy data and insert the LINQ query.

Dim docXml = <?xml version="1.0" encoding="UTF-8" standalone="yes"?>

<w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">

<%= docBodyData %>

</w:document>

'save the xml to the main document part of the word package

Dim stream As StreamWriter = New StreamWriter(part.GetStream(FileMode.Create, FileAccess.Write))

docXml.Save(stream)

End Sub

Resources:

· Open Xml Format SDK

· The PackageExplorer tool from CodePlex. Click on the V3.0.0 RC1 link to start the download.

· The MSDN article "How to: Create an Office Open XML Package by Using the Open XML API"

· The MSN video “How Do I Create Excel Spreadsheets using LINQ to XML?”

Determining the Build Path of a Project

Melody — Fri, 13 Jun 2008 19:04:00 GMT

In seamless non-destructive debugging scenarios (macro recording and running) the host application must keep track of the latest version of the “macro” project assembly. The IDE offers the user many opportunities to change settings like the active configuration or the output path which can make it difficult for the host to find the latest version of the assembly.

To make it more complicated, when the advanced build configurations are not shown the build path is dependent on the context of the build (this mirrors Visual Studio). Specifically, if the user starts debugging with F5, the project builds to the debug configuration output path; however, if the user builds through the menu the project builds to the release output path. Very complicated.

The good news is there are a couple of events a host can hook into through DTE.BuildEvents which can be used to determine the build location. These events are the OnBuildProjConfigBegin and OnBuildProjConfigDone events (you should only need to hook into one of these). Below is code from a modified ShapeAppCSharp sample (this will work for VSTA v 1 and v 2) which catches these events and outputs the configuration and build path for the macro project.

private void EnsureIDE()

{

if (this.dte == null)

{

try

{

IDTEProvider dteProvider = (IDTEProvider)new

VSTADTEProviderClass();

this.dte = (EnvDTE.DTE)dteProvider.GetDTE("ShapeAppCSharp", 0);

System.Diagnostics.Debug.Assert(this.dte != null);

}

catch

{

// If DTEProvider does not work, try co-creating DTE instead.

object objDTE = new DTE();

this.dte = (EnvDTE.DTE)objDTE;

}

// Save a copy of the event sync locations so they don't get

// garbage collected.

this.buildEvents = dte.Events.BuildEvents;

this.solutionEvents = dte.Events.SolutionEvents;

this.dteEvents = dte.Events.DTEEvents;

this.buildEvents.OnBuildDone += new

EnvDTE._dispBuildEvents_OnBuildDoneEventHandler(BuildEvents_OnBuildDone);

this.solutionEvents.AfterClosing += new

EnvDTE._dispSolutionEvents_AfterClosingEventHandler(solutionEvents_AfterClosi

ng);

this.dteEvents.OnBeginShutdown += new

EnvDTE._dispDTEEvents_OnBeginShutdownEventHandler(dteEvents_OnBeginShutdown);

this.buildEvents.OnBuildProjConfigBegin += new

EnvDTE._dispBuildEvents_OnBuildProjConfigBeginEventHandler(buildEvents_OnBuil

dProjConfigBegin);

this.buildEvents.OnBuildProjConfigDone += new

EnvDTE._dispBuildEvents_OnBuildProjConfigDoneEventHandler(buildEvents_OnBuild

ProjConfigDone);

}

void buildEvents_OnBuildProjConfigDone(string Project, string ProjectConfig,

string Platform, string SolutionConfig, bool Success)

{

System.Diagnostics.Debug.Write("\n\n Try OnBuildProjconfigDone");

System.Diagnostics.Debug.Write("\n\t ProjectConfig " + ProjectConfig);

System.Diagnostics.Debug.Write("\n\t SolutionConfig " + SolutionConfig);

GetAssemblyPath(macroProject);

}

void buildEvents_OnBuildProjConfigBegin(string Project, string ProjectConfig,

string Platform, string SolutionConfig)

{

System.Diagnostics.Debug.Write("\n\n Try OnBuildProjConfigBegin");

System.Diagnostics.Debug.Write("\n\t ProjectConfig " + ProjectConfig);

System.Diagnostics.Debug.Write("\n\t SolutionConfig " + SolutionConfig);

GetAssemblyPath(macroProject);

}

static string GetAssemblyPath(EnvDTE.Project vsProject)

{

string fullPath = vsProject.Properties.Item("FullPath").Value.ToString();

string outputPath =

vsProject.ConfigurationManager.ActiveConfiguration.Properties.Item("OutputPat

h").Value.ToString();

string outputDir = Path.Combine(fullPath, outputPath);

string outputFileName =

vsProject.Properties.Item("OutputFileName").Value.ToString();

string assemblyPath = Path.Combine(outputDir, outputFileName);

System.Diagnostics.Debug.Write("\n\n Try #");

System.Diagnostics.Debug.Write("\n ActiveConfig: " +

vsProject.ConfigurationManager.ActiveConfiguration.ConfigurationName);

System.Diagnostics.Debug.Write("\n fullPath: " + fullPath);

System.Diagnostics.Debug.Write("\n outputPath: " + outputPath);

System.Diagnostics.Debug.Write("\n outputDir: " + outputDir);

System.Diagnostics.Debug.Write("\n outputFileName: " + outputFileName);

System.Diagnostics.Debug.Write("\n assemblyPath: " + assemblyPath);

return assemblyPath;

}

ProjectGen Gotcha: Updating the Host Item Name when using a Project Descriptor File as Input

Melody — Thu, 12 Jun 2008 15:48:00 GMT

On the third screen of ProjectGen there is an item to fill in titled “Host item name”. This item is used in two places in the project descriptor file and three places in projects based off the template:

Project template descriptor file:	Projects based off the template:
Host Item Name	Main code file
Host Item Name	Startup Class
PrimaryCookie	PrimaryCookie (MainCode.designer.xml file)

In VSTA v 1 the host does not need to be aware of any of these.

In VSTA v 2, the startup class is used when loading add-ins and the PrimaryCookie is used in DPM scenarios.

ProjectGen offers the option of using a project descriptor file as input instead of manually entering all of the information. This is where the Gotcha comes in. If you use a project template descriptor file as input for ProjecGen and change the host item name on the third screen, in the new project template descriptor file and the resulting template only the host item name will be updated. The PrimaryCookie will remain unchanged.

Workarounds:

1) Manually change the PrimaryCookie in the project template descriptor file before use as input for ProjectGen. Then use the descriptor file as input- no additional steps are required.

2) Manually change the PrimaryCookie attribute in the xml designer file for the main code file. To do this:

a. Create the template with ProjectGen

b. Extract the templates (both CSharp and VB).

c. Open the xml designer file for the main code file (MainCode.designer.xml).

d. Update the PrimaryCookie attribute of the HostItem element.

e. Save the file.

f. Zip the updated template (zip the items individually- do not zip the folder which contains them).

g. Place the template in the ProjectTemplateLocation if not already there.

h. Run setup for the host.