VSTA Samples

ShapeAppBasicMFC with Document Entry Point

BillL — Mon, 06 Jul 2009 19:04:50 GMT

In this sample, Melody modified the proxy to include an entry point for the CDocDrawing class (the CDocDrawing class was also modified to include events which become disassociated with ProxyGen- see this blog for related info on this bug) and the HostItemProvider to expose the CDocDrawing type. Melody also created a template for document level add-ins and used the template to create a sample add-in, ShapeAppMFCDocAddIn1.

To use this sample:

1) Remove the old proxy from the GAC by deleting or uninstalling C:\Windows\assembly\Proxy

2) Remove any VSTA v 1 add-in assemblies by deleting %MyDocuments%\ShapeAppMFC

3) Run the included setup file to register the host and updated templates (SetupShapeAppAdvancedMFC.js)

4) Build the ShapeAppAdvancedMFC.sln solution, this includes the document level sample add-in. This will register the updated proxy in the GAC and build the add-in assembly.

5) Run the sample and notice the message box and shape added from the document level add-in.

Here are the changes I made to add this functionality:

1) HostItemProvider

Unchanged code excluded

internal class HostItemProvider : IHostItemProvider

{

public HostItemProvider(ShapeApp.Proxy.Application application)

{

//SUMMIT- add drawing level HIP

//store the active drawing

this.drawing = application.ActiveDrawing;

}

public object GetHostObject(Type primaryType, string primaryCookie)

{

//Check if primaryType is supported.

else if (primaryType == typeof(ShapeApp.Proxy.CDrawingDoc))

{

//SUMMIT- add drawing level HIP

// update the drawing to ensure the current active drawing is returned

this.drawing = application.ActiveDrawing;

return this.drawing;

}

//SUMMIT- add drawing level HIP

//store the active drawing

private ShapeApp.Proxy.CDrawingDoc drawing;

}

2) Proxy and descriptor file

Descriptor file:

Proxy File:

public partial class CDrawingDocEntryPoint : global::Microsoft.VisualStudio.Tools.Applications.Runtime.IExtendedEntryPoint

{/*entry point class code*/}

3) Template

AppAddIn.designer.xml:

hostitem:baseType="ShapeApp.Proxy.CDrawingDocEntryPoint"

misc changes to vstemplate file for updated project name and description

4) Add-in

No code changes required based on updated template, here is the code from the add-in

private void AppAddIn_Startup(object sender, EventArgs e)

{

System.Windows.Forms.MessageBox.Show("Document level add-in loaded");

this.Shapes.Add(this.Application.AvailableShapes[0].Clone());

}

ShapeApp_DynamicProgrammingModel_Packaging_SeamlessNonDestructiveDebugging_CSharp Sample

Melody — Tue, 07 Apr 2009 18:18:26 GMT

Based on the SDK ShapeAppDynamicProgrammingModelCSharp sample, this updated sample demonstrates packaging VSTA DPM add-ins in the associated document including both the source code and compiled add-in. This sample also features the same Seamless Non-Destructive Debugging experience as seen in the ShapeAppMacroRecordingCSharp sample.

MyAppVB6_VSTA2_Integration

Melody — Mon, 06 Apr 2009 17:38:49 GMT

This sample demonstrates a VB6 VSTA v 2.0 integration using a VB.Net integration library. Below is from the included READ ME.doc

There are many ways to integrate VSTA v 2.0 with a VB6 application. This sample demonstrates an advanced integration option (with seamless non-destructive debugging but no macro management) which closely follows the integration code from the SDK samples.

A COM visible library, VSTA2_Integration, is referenced by the VB6 host application, MyAppVB6. The VSTA2_Integration library exposes the classes VSTARunTimeIntegration and VstaDesignTimeIntegration. The VB6 host first creates and connects to its VSTARunTimeIntegration instance passing in the object to be used as an entry point (see definition below) for add-ins through the VSTARunTimeIntegration.Connect method. Then the VB6 host creates and connects to its VSTADesignTimeIntegration instance passing in the VSTARunTimeIntegration instance through the VSTADesignTimeIntegration.Connect method.

This host object (passed in through the VSTARunTimeIntegration.Connect method) is stored in the internal VSTA2_Integration.HostItemProvider (see definition below) which is passed into the add-ins through the VSTA pipeline. Once the host object is passed through the pipeline, it is stored in the add-in in a hidden code file and accessed through “Me” or “Me.Application” (see section on templates below).

The VSTARunTimeIntegration.Connect method makes calls to load add-ins and the VSTARunTimeIntegration.Disconnect method makes calls to unload add-ins. The VB6 host calls the VSTARunTimeIntegration.Connect method on form load, and VSTARunTimeIntegration.Disconnect on form unload. This can easily be changed so that add-ins can be loaded and unloaded by selecting a button on the host.

The DesignTimeIntegration.Connect method takes in and stores the VSTARunTimeIntegration instance and prepares for IDE management. The DesignTimeIntegration.ShowIDE method displays the IDE with a new or existing VSTA project open. The DesignTimeIntegration.Disconnect method disposes of the IDE. The VB6 host calls the DesignTimeIntegration.Connect on form load and the DesignTimeIntegration.Disconnect on form unload. It is not advisable to change this. The ShowIDE method is called through a button on the VB6 host.

This sample does not use a proxy or HostTypeMapProvider, instead a “proxy shim" is included in the add-in to provide a MyAppVB6 entry point. This class is defined in the hidden AppAddIn.designer2.xx file included with the project templates.

Two sets of templates are included with this sample. The “MyAppVB6_VSTA2_Template_Robust.zip” templates allow the add-in to access the host object through “Me” or “this”. The “MyAppVB6_VSTA2_Template.zip” templates allow the add-in to access the host object through “Me.Application” or “this.Application”. For the robust templates, the hidden file AppAddIn.designer2.xx contains code which re-implements/exposes some or all of the entry point type from the VB6 host. The only benefit to this additional code is it allows the host object to be accessed more directly through “Me” or “this” instead less directly through “Me.Application” or “this.Application”. Which type of template to use is a design decision.

To use this sample:
   1)   Extract the sample to C:\VSTA. If a different location is used the GeneratePIA files will need to be altered.
   2)   Run the included setup file Setup_MyAppVB6_VSTA2.js. This registers the host with VSTA and extracts the project templates.
   3)   Open and build the VSTA2_Integration solution. Building this will register the library in the GAC.
   4)   Open the MyAppVB6 solution and build the MyAppVB6.exe.
   5)   Run the GeneratePIA.bat file to generate a PIA for the MyAppVB6.exe created above.
   6)   Open and build the sample add-ins included.
   7)   Run the host from the exe, a sample add-in, or the VSTA2_Integration solution.
   8)   Select ShowIDE to launch the IDE.
   9)   Add code to the start-up method of the macro project and set a break point.
   10) Begin debugging to hit the break point set above.

To use this sample to integrate VSTA v 2 into your VB6 host, you will need to:
   1) Update your host to reference and use the VSTA2_Integration library.
   2) Generate a PIA for your host. This must be regenerated every time the exe is recreated because VB6 reassigns GUID’s with each build.
   3) Register your host with VSTA by adding registry values (see SDK)
   4) Update the project templates. The minimum update required includes:
          a. HostID- in the xxproj files update the HostID
          b. Debug location- in the xxproj files update the DebugInfoExeName with the location of your host’s exe.
          c. Reference- in the xxproj files update the reference to MyAppVB6.dll with your host’s PIA.
          d. Entry point-
                    i. the types in AppAddIn.designer2.xx files
                    ii. basetype node in the AppAddIn.designer.xml file with the EntryPoint type used in the AppAddIn.designer2.xx file.
          *once all project template updates are complete re-zip the template using no subfolders.
   5) Move the updated project templates to the ProjectTemplatesLocation used to register your host with VSTA.
   6) Run vsta setup for the host.

Definitions:

Entry Point-
An entry point is a type that is instantiated when the host application loads an add-in. The entry point also contains methods that can be called by the host application to initialize the add-in. Typically, the entry point is a host type that lives at the top of the object model hierarchy, such as an Application class that represents the host application, or a Document class that represents a document in the application.
An entry point is also the base class for a host item in the add-in developer's project. A host item is a class that provides a starting point for add-in developers to write their code, and is the class that add-in developers use to obtain all other objects that they use to automate the host application.

HostItemProvider-
A host item provider is a class that exposes host objects to add-ins. This class implements the IHostItemProvider interface in the host application. This interface defines a single method, GetHostObject. This method returns an instance of a type in the object model of the host application that corresponds to an entry point in the add-in.
When the host application loads an add-in, each entry point in the add-in calls the GetHostObject method to obtain an instance of its corresponding type in the host application. Each time the add-in calls a member of the entry point, the member uses this object to call into the corresponding member of the object in the host application.

*KNOWN ISSUES
1) VB6 event hook-ups can be lost through garbage collection as well as creating or showing a System.Windows.Forms object when the event is triggered. We are working with Microsoft to resolve this issue. For more information see the thread “VB6 event hookups dissappearing after X iterations, then throwing RCW error on event disconnect” on the MSDN Visual Basic Interop and Upgrade forum.

This issue was resolved by keeping a local instance of the source of the event. For details refer to the thread mentioned above or the blog Saving DTE and other COM Event Hook-ups.

2) After performing actions in the IDE such as building the host application’s exe will stay up after the host is closed. We are working to resolve this issue and will post an update on www.Summsoft.com when a workaround is available.

In Process Host Demo Sample

Melody — Wed, 11 Mar 2009 17:40:18 GMT

This IPH sample is designed to work with the included modified ShapeAppMacroRecordingCSharp sample. This modified sample uses the “ShapeAppCSharp-AppLevel IPH” template instead of the “ShapeAppCSharp-AppLevel” template included with the SDK.

To use this sample:

1) Extract the files to C:\ShapeAppSamplesCSharp (any location may be used).

2) Run the included setup file “SetupShapeAppMacroRecordingCSharp.js”, this will register the IPH and project templates.

3) Open and build the “ShapeAppMacroRecordingCSharp IPH.sln” solution. This will register the proxy and IPH in the GAC.

4) Remove any existing macro projects from %MyDocuments%\ShapeAppCSharp, this will force the sample to create a new macro project based on the IPH enabled project template.

5) Save a copy of the CurrentSettings.vssettings file under %MyDocuments%\ShapeAppCSharp\Settings. This step is optional, the IPH does return most the IDE settings to the previous state, but you may want to return to all of the previous settings.

6) Run the host and launch the IDE. Use the custom toolbar to add a macro, build the macro project, and switch to the host and run the macro; add code to the startup method and debug.

To use this IPH with your host:

1) Register the IPH under the VSTAHostConfig\%HostID%.
[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VSTAHostConfig\%HostID%\2.0\VSTA\InProcHost\{6E7D6667-7F30-4058-8F83-E5772B831217}]
"FullClassName"="IPH_Demo.IPH_Demo"
"Assembly"="IPH_Demo, Version=1.0.0.0, Culture=neutral, PublicKeyToken=4b82402396be3cb2"

2) Update a project or project template to use the IPH by specifying the GUID as below in the xxproj file.
<InProcHost>{6E7D6667-7F30-4058-8F83-E5772B831217}</InProcHost>

3) Register the IPH in the GAC- building the solution should register it.

Note: This IPH greatly simplifies the IDE to demonstrate the customizations which are possible. These simplifications include removing the standard and debug toolbars as well as closing all windows including the errors pane. These modifications are made to demonstrate the possibilities, not to actually suggest you should limit the IDE to this extent- without these toolbars and windows it is very difficult to work in the IDE

Video for this sample

***Updated 4/2/09 for bug fix. Call to ClostAllWindows moved to beginning of SimplifyIDE method to avoid a "Ghost pane" on first IDE launch. For more information this, see this VSX forum post.

ShapeAppBasicCSharp AddInDiscoveryAlternative

Melody — Tue, 27 Jan 2009 19:18:00 GMT

This sample is a modified version of the SDK ShapeAppBasicCSharp sample demonstrating a different add-ins discovery scenario. No add-ins are loaded automatically, instead the default add-in location (%MyDocs%\ShapeAppCSharp\AppAddIns) is searched and any add-ins found are added to a list. This list of discovered add-ins is displayed on a form which the user can load or unload the add-ins from. The user may also use this form to discover add-ins from other locations.

Three add-ins are included with this sample- two use the default post build event which copies the add-in assemblies to the default search location, the other uses a modified post build event to copy the add-in assembly to an alternate location (%MyDocs%\ShapeAppCSharp\AppAddIns).

To use this sample, run the included setup file then open and build ShapeAppBasicCSharp.sln. This will take care of registering the ShapeAppCSharp host with VSTA, registering the proxy, and building/moving the add-ins.

ShapeAppBasicCSharpGenericCollectionIndexAdapter Sample

Gary — Mon, 26 Jan 2009 21:28:14 GMT

Continuing from our previous ShapeAppBasicCSharpGenericCollectionAdapter sample, we will demonstrate how to pass a System.Collections.Generic.IList<ShapeAppCSharp. Document > instance, as a ‘by reference’ parameter, from an AddIn to ShapeAppBasicCSharp host application. This is accomplished by extending the VSTA pipeline with generic list adapters and converters that provide Host application with a (cross-AppDomain) reference to a generic collection passed from a VSTA AddIn. The host application will, in-turn, populate the AddIn collection parameter with host-side Document objects (as RemoteObject instances).

To illustrate, here's an add-in example calling this[typeof(Document), doctypedocs];:

private void AppAddIn_Startup(object sender, EventArgs e)

{

IList<Document> doctypedocs = new List<Document>();

int count = this[typeof(Document), doctypedocs];

testdoc = doctypedocs[0];

string dwgName2 = doctypedocs[0].Drawings[0].Name;

}

Our design goal is for the Add-in author to pass a generic collection parameter to the host application and receive it back populated with host elements. In this case, we’re using the generic collection ( System.Collections.Generic.IList<Document>) as the parameter passed to the host.

ShapeAppBasicCSharpGenericCollectionAdapter sample hooks VSTA pipeline to pass custom type: IList

Gary — Mon, 19 Jan 2009 21:33:16 GMT

Based on The MS VSTA architects' blog post, this sample (created from ShapeAppBasicCSharp) uses custom adapters in the VSTA pipeline, to pass generic collections of documents to the add-in:

IList<Document> documents = this.GetDocuments();

The sample is fairly straightforward and comes with a walk-through document supplement (ShapeAppBasicCSharpGenericCollectionAdapter.doc) to help you understand, install, and run the sample and to point out interesting parts in the sample.

Simple C# Sample HelloWorld_VSTA2

Melody — Wed, 07 Jan 2009 15:49:21 GMT

This is a very simple "Hello World" style applicaiton written in C# with a basic VSTA v 2 integration.

From the READ ME.txt file:

To Use This Sample:
1) Extract the zip file in C:\VSTA\Summit Software\Samples- if a different location is used the templates must be updated with the locatoin of HelloWorld_VSTA2.exe
2) Run the included setup file
3) Build the host- this will install the proxy in the GAC
4) Build the sample add-ins
5) Run the host- note "Hello: From VSTA" appears from both sample add-ins

Basic Integration Steps using tools from Summsoft.com
1) Compile host
2) Create Proxy
        Run host through AutoProxyGen- input file included
        Specify EntryPont
        Create Proxy project (from project template) adding proxy file created with AutoProxyGen
3) Register host
        Add registry entries- registration file included
        Run VSTA setup to complete registration
4) Create ProjectTemplate with ProjectGen- input file included
5) Modify host to discover and load add-ins
        Add VstaRunTimeIntegration from item template- update type and add-in location
        Add HostItemProvider from item template- update type
        Add HostTypeMapProvider created by AutoProxyGen

For BasicIntegrations without using tools from Summsoft.com refer to the SDK

UpgradeHelper Sample

Melody — Thu, 04 Dec 2008 19:51:48 GMT

To support VSTA v 1 projects in VSTA v 2 you need to create and register an UpgradeHelper. This helper is triggered when a VSTA v 1 project is opened in the VSTA v 2 IDE. If VSTA v 1 is installed, VSTA v 1 projects will still open normally in the VSTA v 1 IDE when doubled clicked. Projects must be opened through the VSTA v 2 IDE to trigger the UpgradeHelper and once upgraded will open in the VSTA v 2 IDE when double clicked.

A couple of notes about using an UpgradeHelper:

1) You must use two unique HostID’s in order to use an UpgradeHelper. Using the same HostID for VSTA v 1 and VSTA v 2 will cause the UpgradeHelper not to be triggered. Related topic: How to Update a Host’s Folder in %My Documents%.

2) In the RemovedReferences section use only the name of the reference to removed- including any other information like the version or public key token will result in the reference not being removed.

3) Only valid projects will trigger the UpgradeHelper. Projects missing the AppAddIn.designer.cs file from the list of compilable files will not trigger the UpgradeHelper.

4) To be sure that the correct version of a reference is added, you may want to use the full GAC information for the reference since you cannot specify SpecificVersion=true. Related topic: Proxy Versioning Options for Project Templates. Example: "ShapeAppCSharpProxy, Version=2.0.0.0, Culture=neutral, PublicKeyToken=3c3c0c46dd27dbcf, processorArchitecture=MSIL"

5) VSTA v 1 projects cannot be opened programmatically through VSTA v 2. Using dte.Solution.AddFromFile or dte.Solution.Open will throw an error if the project has not been previously upgraded. We are looking for a workaround for this (add a comment if you know of one please).

The UpgradeHelper is triggered at the end of the normal Visual Studio conversion wizard.

The VSTA registries required for the UpgradeHelper are a little tricky- you may want to base yours off the included example

[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VSTAHostConfig\ShapeAppCSharpV2\2.0]

@=""

"AppName"="ShapeAppCSharp"

"ProjectTemplatesLocation"="C:\\ShapeAppSamples\\ShapeAppMacroRecordingCSharp\\Templates"

"VSTAVersion"="9.0"

"UpgradeFrom"="ShapeAppCSharp"

"UpgradeHelper"="{10B201D5-F806-4385-8DED-7E785DD66946}"

[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VSTAHostConfig\ShapeAppCSharpV2\2.0\VSTA]

[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VSTAHostConfig\ShapeAppCSharpV2\2.0\VSTA\UpgradeHelper]

[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VSTAHostConfig\ShapeAppCSharpV2\2.0\VSTA\UpgradeHelper\{10B201D5-F806-4385-8DED-7E785DD66946}]

"Assembly"="ShapeAppCSharp_UpgradeHelper, Version=1.0.0.0, Culture=neutral, PublicKeyToken=27e4196f25ea49b1"

"Class"="ShapeAppCSharp_UpgradeHelper.ShapeAppCSharp_UpgradeHelper"

To use this sample:

1) Remove the ShapeAppCSharp folder from %MyDocuments%

2) Remove the ShapeAppCSharp registry hives from the config and context registry hives

3) Remove all ShapeAppCSharpProxies registered in the GAC

4) Open and build the ShapeAppAdvancedCSharp sample- this registers ShapeAppCSharpProxy Version = 1.0.0.0.

5) Run the setup file SetupShapeAppAdvancedCSharp.js (templates use proxy v 1)

6) Move the folders contained in the MyDocs folder to %MyDocuments%- this includes macro projects and sample add-in assemblies

7) Open and build the modified sample add-in for ShapeAppAdvancedCSharp (optional but you may want to see what the add-in does)

8) Run the ShapeAppAdvancedCSharp sample, launch the IDE and build the macro project to confirm the macro startup method runs.

9) Open and build the ShapeAppCSharp_UpgradeHelper. This will register the upgrade helper in the GAC, it will be registered with the host in step 11 below.

10) Open and build the ShapeAppMacroRecording sample- this registers ShapeAppCSharpProxy Version = 2.0.0.0.

11) Run the modified setup file SetupShapeAppMacroRecordingCSharp_v2.js. This uses the HostID ShapeAppCSharp_v2, registers the UpgradeHelper and registers templates which use proxy v 2.

12) The macro and sample add-in assembly should have been moved in step 6 above.

13) Open and build the modified sample add-in for ShapeAppMacroRecordingCSharp (optional but you may want to see what the add-in does)

14) Run the ShapeAppMacroRecordingCSharp sample,

a. launch the IDE (as normal for VSTA v 2) and build the macro project to confirm the macro startup method runs.

b. Launch the IDE for the VSTA v 1 macro project,

i. follow the prompts to navigate to the project and open it (C:\Documents and Settings\Administrator\My Documents\ShapeAppCSharp\Macros.sln)

ii. build the macro project to confirm the macro startup method runs.

The Code:

namespace ShapeAppCSharp_UpgradeHelper

{

public class ShapeAppCSharp_UpgradeHelper : IVstaUpgradeHelper

{

#region IVstaUpgradeHelper Members

List<AddedReference> IVstaUpgradeHelper.AddedReferences

{

get

{

//SUGGESTION: use the full GAC information for tight versioning

List<AddedReference> addedReferencesList = new List<AddedReference>();

addedReferencesList.Add(new AddedManagedReference("ShapeAppCSharpProxy, Version=2.0.0.0, Culture=neutral, PublicKeyToken=3c3c0c46dd27dbcf, processorArchitecture=MSIL"));

return addedReferencesList;

}

string IVstaUpgradeHelper.DebugInfoCommandLine

{

get{return ""; }

}

string IVstaUpgradeHelper.DebugInfoExeName

{

get { return "#HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\ShapeAppCSharp_v2\\InstallPath#\\ShapeAppCSharp.exe"; }

}

string IVstaUpgradeHelper.IconImageList

{

get{return ""; }

}

Guid IVstaUpgradeHelper.InProcessHostGuid

{

get

{

Guid newG = new Guid();

return newG;

}

List<RemovedReference> IVstaUpgradeHelper.RemovedReferences

{

get

{

//NOTE: use only the reference name, not the version or any other information

// or the reference will not be removed.

List<RemovedReference> removedReferencesList = new List<RemovedReference>();

removedReferencesList.Add(new RemovedReference("ShapeAppCSharpProxy"));

return removedReferencesList;

}

string IVstaUpgradeHelper.TemplatesPath

{

get {return ""; }

}

UpdatedBaseType IVstaUpgradeHelper.UpdateBaseType(string oldBaseType)

{

string newBaseType = null;

string newBaseInterfaceType = null;

if (oldBaseType == "Microsoft.VisualStudio.Tools.Applications.Samples.ShapeApp.Application")

{

newBaseType = "Microsoft.VisualStudio.Tools.Applications.Samples.ShapeApp.ApplicationEntryPoint";

newBaseInterfaceType = "Microsoft.VisualStudio.Tools.Applications.Runtime.IEntryPoint";

}

return new UpdatedBaseType(newBaseType, newBaseInterfaceType);

}

#endregion

}

Two Applications Share a HostID Sample

Melody — Tue, 18 Nov 2008 21:29:51 GMT

This sample demonstrates how two applications can share one host ID.

There are two applications which share a common base type library: Applicatoin_A and Application_B share the SharedLib library. Application_B is based on Application_A with additional methods.

Each application has its own entry point type, Applicatoin_A .ApplicationA and Applicatoin_B.ApplicationB, and the shared base type library has an entry point type SharedLib.SharedApplication. Both applications have a HostItemProvider which can return the entry point for its application or the SharedLib.SharedApplication.

There are three proxies- one for only the shared library, then one for each application including the shared library.

Each proxy exposes one entry point and is exposed to VSTA add-ins through its own template.

Template	Proxy	EntryPoint
SharedApplication_Template	ApplicationSharedProxy	SharedApplication
ApplicationA_Template	ApplicationAProxy	ApplicationA
ApplicatoinB_Template	ApplicationBProxy	ApplicationB

To use the sample,

1. Extract the sample to C:\VSTA (if using a different location the registry file will need to be updated for the ProjectTemplatesLocation and add-ins will not run).
2. Run the included registration file Application_AB HostConfig Hive.reg.
3. Run vsta setup for Application_AB. This will register the included templates.
4. Open and build the Application_A.sln, Application_B.sln, and SharedLib.sln solutions.
5. Run the Application_A and Application_B samples, both will launch macro projects.
6. For both macro projects, add the code below to the startup method, set a breakpoint and start debugging. Both macros will hit the break point and can continue execution.
this.AddMessage(this.MakeSharedType(100, "message from macro X"));

Application_A can load and run add-ins written for the entry points ApplicationA and SharedApplication, but not ApplicationB add-ins.
Application_B can load and run add-ins written for the entry points ApplicationB and SharedApplication, but not Application_A add-ins.

Application_A and Application_B can both debug at the same time (using different macro projects) using the same HostID. Application_A uses a macro project based on the ApplicationA_Template. Application_B uses a macro project based on the ApplicationB_Template.

Results:

Ø It is possible to use the same hostID for different applications and debug them concurrently

Ø It is possible for an application to load and run add-ins, so long as the add-in is compatible with the host (the HostItemProvider must return the entry point type of the add-in).

Modified Sample: One Application use two HostIDs

Using the above sample where two applications share one hostID, modifications can easily be made so that each application may use its own hostID or one application can use two hostIDs. These modifications are intended to demonstrate the flexibility of using multiple hostId’s with one or more applications.

To use two different hostID’s for one application
1. Complete the steps above to setup the sample.
2. Add the hostID for Application_B- run the included registration file “Application_B HostConfig Hive.reg”.
3. Run vsta setup for Applicatoin_B. This will register the included templates.
4. Change which macro project Appliation_B uses to the Application_B_HostID_B_Template project by:
i. Uncomment the below line in Application_B.Program.Main “Two applications using one hostID's section” region:
//app.VstaDTE_HostIdB.ShowIde(true); //HostID Application_B

ii. Comment the below line in Application_B.Program.Main “One application using two hostID's section” region:
app.VstaDTE.ShowIde(true); //HostID Application_AB

5. Build the Application_B_AddIn_HostID_B_1 project under SampleAddIns
6. Build and run the Application_A and Application_B samples.

Application_B can still load and run add-ins based on the old template ApplicationB_Template and the shared template SharedApplication_Template (hostID’s do not come into play here, only entry points).

Application_A and Application_B can both debug at the same time using different HostID’s

Application_B can debug using macro projects for either hostID so long as the project loaded is based on a template for the HostID used in RegisterAsDebugHost and EnsureIDE.

Application_B can only debug under one hostID at a time- it cannot RegisterAsDebugHost for two HostID’s concurrently

Results:

Ø It is possible to use two hostIDs for one application but only one can be registered for debugging at a time

Ø It is not possible to open a project based on a template registered under one hostID in the IDE of another hostID, the IDE is hostID specific.

Ø It is possible for an application to load and run add-ins for different HostIDs, so long as the add-in is compatible with the host regardless of the HostID (the HostItemProvider must return the entry point type of the add-in).

AutoProxyGen Video: From ProxyGen to AutoProxyGen

Melody — Wed, 15 Oct 2008 18:29:06 GMT

Due to compression for msn videos the text and code in the From ProxyGen to AutoProxyGen video may be difficult to read. The attached download is the same video uploaded; however, with less compression so the text and code are easier to read

EventSample VB v2.1 – Exposing Generic Events in Entry Point classes

Melody — Wed, 08 Oct 2008 19:51:28 GMT

At this time there is no direct way to expose an EventHandler<T> in the host to VSTA add-ins. This sample uses a workaround which involves using non-generic event handling between the host and proxy, and generic event handling between the proxy and add-in. This is accomplished by raising the non-generic events in the host and adding methods to the proxy to translate the events and event args. The host and proxy must be modified; however, the host item provider and host type map provider do not require any alterations.

This workaround only works for generic events raised by the entry point class the add-in is based on. There is a separate workaround for generic events raised by other classes which is more involved.

This sample is a modified version of the Event Sample VB v 2. To run this sample, extract the zip file and run the included setup file SetupEventSample VB v 2.1.js. Build the solution to move the proxy to the GAC and build the included sample add-in to load the assembly. Both events hooked into the by the add-in will be triggered by entering a message into the input box and selecting “Add”.

The proxy and add-ins use tight versioning, the proxy assembly is marked as version 2.1 and the project templates included use this assembly as version specific. To use the included AutoProxyGen Input.xml file to regenerate the main proxy file, update the file locations (the proxy included will work so this is not necessary). Only one modification was done to the auto-generated proxy file, in the entry point class and it’s base the non-generic events were changed from public to private so that only the generic events are visible to add-ins.

Workaround Components:

Host

1) Define custom event args.

2) Define an EventHandler<T> in the EntryPoint class using the custom event args (must be the entry point the add-in will be based on).

3) Define a delegate using the custom event args. This will be used to communicate between the host and proxy.

4) Define an event based on the delegate defined in 3 above. This will be used to communicate between the host and proxy.

5) Anytime the EventHandler<T> is raised, raise the event based on the delegate, this event will trigger the EventHandler<T> in the proxy/add-in.

Proxy

6) Create the proxy as normal. This will define in the proxy:

a. The custom event args from 1.

b. The delegate using the custom event args from 3.

c. The event based on the delegate from 4 in both the class and the entry point class.

This will skip:

a. The EventHandler<T> (all generics are skipped).

ProxyGen.exe Warning: 21040 : The following event type MainApplication contains generic type information and will not be parsed: cEventT.

7) Re-implement the custom EventArgs in the proxy while keeping the auto-generated custom EventArgs. Do this by using a different name for the re-implemented custom event args, or nesting them in a class.

8) Expand the partially defined entry point class in the proxy (suggest to do this is a separate code file) adding:

a. A private event EventHandler<T> for the custom event args for internal use by the proxy. Do not define the add and remove methods for this event.

b. A flag for the private event defined above initialized to false.

c. The EventHandler<T> defined in the host skipped by ProxyGen using the re-implemented event args deined in 7 above. Define the add and remove methods for this event. In the Add method, hook the value passed in to the private event defined in 8a above. Then, if the flag defined in 8b is false, hook the auto-generated generic event handler defined in the main proxy file to a new method to be defined in the expanded entry point class (defined below) and set the flag to true. In the remove method, remove the value from the private event defined in 8a above.

d. Add a method which satisfies the signature for the generic event handling, using the original event args. In this method, translate the original event args to the re-implemented event args. Use the re-implemented event args to raise the private event defined in 3a.

9) Expand the partially defined class in the proxy adding the EventHandler<T> (suggest to do this in the same separate code file).

Code sample Host:

'1) Define the custom event args

Public Class cEventArgs

Inherits System.EventArgs

Private _myObject As MainObject

Public Property MyObject() As MainObject

Get

Return _myObject

End Get

Set(ByVal value As MainObject)

_myObject = value

End Set

End Property

Public Sub New(ByVal nObject As MainObject)

_myObject = nObject

End Sub

End Class

'3) Define a delegate using the custom event args.

' This will be used to communicate between the host and proxy.

Public Delegate Sub cEventHandler(ByVal sender As Object, ByVal e As cEventArgs)

Public Class MainApplication

'2) Define an EventHandler<T> in the EntryPoint class using the custom event args

Public Event cEventT As EventHandler(Of cEventArgs)

'4) Define an event based on the delegate defined above.

' This will be used to communicate between the host and proxy.

Public Event cEventX As cEventHandler

' 5) Anytime the EventHandler<T> is raised, raise the event based on the delegate.

' This event will trigger the EventHandler<T> in the proxy/add-in.

Public Sub HookUpEvents()

AddHandler Me.cEventT, AddressOf RaiseGenericEventForVSTA_cEventT

End Sub

Private Sub RaiseGenericEventForVSTA_cEventT(ByVal sender As Object, ByVal e As cEventArgs)

RaiseEvent cEventX(Me, e)

End Sub

End Class

Code sample Auto-generated Proxy (attributes and delayed event hookups removed):

namespace EventSample

{

//6a) auto-generated custom event args from 1

public abstract partial class cEventArgs : global::System.MarshalByRefObject

{

public virtual global::EventSample.MainObject MyObject

{ //auto-generated not implemented code

}

//6b) auto-generated delegate using the event args from 3

public delegate void cEventHandler(object sender, global::EventSample.cEventArgs e);

//6c) auto-generated event based on the delegate from 4

public abstract partial class MainApplication : global::System.MarshalByRefObject

{

virtual public event global::EventSample.cEventHandler cEventX

{

add { throw new global::System.NotImplementedException(); }

remove { throw new global::System.NotImplementedException(); }

}

//6c) auto-generated event based on the delegate from 4

public partial class MainApplicationEntryPoint : global::Microsoft.VisualStudio.Tools.Applications.Runtime.IExtendedEntryPoint

{

public event global::EventSample.cEventHandler cEventX

{

add

{

if (this.remoteObject != null)

((EventSample.MainApplication)(this.remoteObject)).cEventX += value;

}

remove

{

if (this.remoteObject != null)

((EventSample.MainApplication)(this.remoteObject)).cEventX -= value;

}

Code sample Expanded Proxy:

//7) Re-implemnted custom event args for internal use by the proxy.

// Defined in as a nested class to avoid naming collision

public partial class EventSampleEventArgs

{

public partial class cEventArgs : System.EventArgs

{

public MainObject MyObject { get; set; }

public cEventArgs(MainObject inObject)

{

MyObject = inObject;

}

//8) Expand the partially defined entry point class

public partial class MainApplicationEntryPoint

{

//8a) Add a private EventHandler<T> for internal use

private event System.EventHandler<EventSampleEventArgs.cEventArgs> _cEventT;

//8b) Add a flag to determine if the private event has been hooked up yet

private bool cEventArgsHookedFlag = false;

//8c) Add a public EventHandler<T> skipped by ProxyGen

// In the add method, hook the value to the private EventHandler<T>

// Hook the auto-generated non-generic event handler to method which

// translates the event args and raises the private EventHandler<T>

public event System.EventHandler<EventSampleEventArgs.cEventArgs> cEventT

{

add

{

//add the add-in hookup to the private event handler

this. _cEventT += value;

//If the non-generic event isn’t hooked into yet, hook into it

if (!cEventArgsHookedFlag)

{

cEventArgsHookedFlag = true;

this.cEventX += new MessageAddedEventHandler(MainApplicationEntryPoint_ cEventX);

}

remove

{

//remove the add-in hookup from the private event handler

this. _cEventT -= value;

}

//8d) Add method with the signature for the generic event handling,

// using the auto-generated custom event args.

void MainApplicationEntryPoint_ cEventX (object sender, EventSample.MessageAddedEventArgs e)

{

//Raise the private generic event

if (this. _cEventT != null)

{

EventSampleEventArgs.MessageAddedEventArgs args = new EventSampleEventArgs.MessageAddedEventArgs(e.MyObject);

_cEventT (sender, args);

}

//9) Expand the partially defined entry point class base class

// Adding the EventHandler<T> event.

public abstract partial class MainApplication : global::System.MarshalByRefObject

{

virtual public event System.EventHandler<EventSampleEventArgs.cEventArgs> cEventT;

}

VSTA Integration templates

Melody — Mon, 29 Sep 2008 20:51:35 GMT

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- inlcude 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#

AutoProxyGen v 2.0.0.2

Melody — Mon, 29 Sep 2008 20:28:44 GMT

This download includes the executable program and source code for AutoProxyGen as well as a guide for use. To use VSTA with AutoProxyGen run the included setup file (SetupAutoProxyGen.js). A sample add-in which corrects the inheritence bug ProxyGen has with the ShapeAppBasicMFC sample is also included.

Overview

The AutoProxyGen tool is designed to automate the process of using the ProxyGen tool included with the VSTA v 2.0 SDK. AutoProxyGen inputs file locations and uses these to create and run commands through ProxyGen to ultimately produce the proxy and HostTypeMapProvider (HTMP) files. Once the files locations have been input and the host consumed, you can use AutoProxyGen to specify entry points and exclude items, then save these specification in an input file. AutoProxyGen can be incorporated in build events and includes a basic VSTA v 2 integration to allow for customizations.

ProxyGen

What is ProxyGen?

Tool included in the SDK to create the proxy and host type map provider files necessary for a VSTRA v 2.0 integration

How does ProxyGen work?

The integrator first designs an OM in their host application and builds the exe, dll, or tlb to expose.
Through the command prompt enter commands to expose the host application to ProxyGen and create a descriptor file.
Modify the xml descriptor file specifying entry points and excluded items. Other changes may be necessary.
Through the command prompt enter commands to expose the updated descriptor file and create the proxy and host type map provider files.

What are some problems with ProxyGen that AutoProxyGen fixes?

ProxyGen requires manual steps to create the descriptor file, update it, and use it to create the proxy and host type map provider files. AutoProxyGen can do all of these in a build event, through a single command, or through a GUI.

There are known bugs with ProxyGen including:
Methods, properties, and events not marked as excluded being excluded
Structs are created as classes
Inheritance issues with COM object models

AutoProxyGen includes workarounds for the first bug, items not marked as excluded are excluded, it automatically excludes structs to prevent them from being created as classes for the 2nd bug, and includes a basic VSTA integration which allows add-ins to be used to correct the inheritance issue in the 3rd bug.

Many hosts require changes to the descriptor and proxy files which must be repeated every time the host changes. AutoProxyGen includes a basic VSTA integration so add-ins may be used to automate these repetitive changes.

Quick Guide

The user enters file locations and selects "Consume Host". AutoProxyGen creates and runs the 1^st ProxyGen command which consumes the host application and creates the descriptor file. Once the descriptor file is created or the user indicates to use an existing file, the descriptor file is consumed and all types and ProxyGen messages are displayed. Once the user has finished specifying entry points and excluded items, the user selects "Create Proxy". The descriptor file is then updated with the entry points and excluded items, then the 2^nd ProxyGen command, which consumes the descriptor file and creates the proxy and HTMP files, is run.

This can be automated by selecting "Create Input File" once all file locations, entry points and excluded items are specified. Once an input file has been created it can be run by selecting "Consume Input File" or through the command prompt or build event.

Further customizations are possible through VSTA. AutoProxyGen exposes only file locations and 4 events indicating when files have been created.

Only the entry points and excluded items specified through the AutoProxyGen GUI or input file will be excluded or marked as an entry point in the proxy and HTMP files.

Steps:

1) Enter file locations.
2) Select "Consume Host".
3) Specify entry points and excluded items.
4) Select "Create Proxy".

Automate AutoProxyGen with input files:

Once step 3 above is complete, select "Create Input File".
Use the input file by selecting "Consume Input File" to automate steps 1-4 above.
Use the input file by running a command through the command prompt.
Use the input file in a build event (see section on "Using AutoProxyGen as a Build Event").

Customize AutoProxyGen with VSTA add-ins:

Register AutoProxyGen as a VSTA host by running the included setup file.
Create and build add-ins.
Run AutoProxyGen as normal (GUI or build event).

VSTA in AutoProxyGen

To allow for customizations AutoProxyGen includes a basic VSTA v 2.0 integration. The object model includes only the file locations and events triggered by files being created or updated.

The templates included use the same post build event as the ShapeAppSamples included with the VSTA v 2.0 SDK which moves the add-in assemblies to %MyDocuments%\AutoProxyGen\AppAddIns. All add-in assemblies found at this location are loaded.

To use VSTA with AutoProxyGen build the solution file (AutoProxyGen.sln) and run the included setup file (SetupAutoProxyGen.js).

Events:

BeforeConsumeHostEvent- Raised prior to executing the 1^st ProxyGen command.
DescriptorFileCreatedEvent- Raised once the descriptor file ready to be consumed. Triggered if the file is created with ProxyGen or if an existing file is used.
DescriptorFileUpdatedEvent- Raised once the descriptor file is updated with entry points and excluded items but prior to running it through ProxyGen.
ProxyfileCreatedEvent- Raised once the proxy and HTMP files have been created.

A sample add-in is included which implements a workaround for COM hosts, correcting their inheritance.

If using VSTA add-ins to work directly with the descriptor file it is strongly recommended that your use the VB.Net template because it includes intellesence for the ProxyGen schema. This feature is not available in C#.

Using AutoProxyGen as a Build Event

AutoProxyGen may be used from the command line or as a build event. An input file created by AutoProxyGen is required for this and is the only parameter. Within this input file all file locations, entry points, and excluded items are specified.

When using AutoProxyGen as a build event keep in mind that the HTMP will be created when run. If this file is contained within the host project the host will need to be re-built. A possible work around for this is to build the host twice: first using an input file with the final location for the HTMP (this will move the HTMP into the solution for the second build), the second build should use an input file without the final location for the HTMP. The HTMP only needs to be updated if a new type is being exposed to VSTA.

Example command:

AutoProxyGen /i:"C:\ShapeAppSamples\ShapeAppBasicCSharp\AutoProxyGen_Input.xml"

*Notice the input command is "/i:" immediately followed by the file location with no space.

ProxyGen bugs fixed by AutoProxyGen

All excluded methods, properties, and events (MPEs) are moved to the end of the parent type automatically to work around a ProxyGen bug which excludes additional MPEs after encountering an excluded MPE.

There is an "Exclude All Structs" option available which automatically excludes all structs, to work around a ProxyGen bug which creates classes in the proxy file for structs in the host. Once the proxy is generated with all structs included, the structs must be manually added to the proxy project. For more information on this please see the on-line VSTA 2.0 SDK (http://msdn.microsoft.com/en-us/library/cc747850.aspx).

The sample add-in included demonstrates how to correct the inheritance for COM hosts. ProxyGen does not expose events for COM objects without adding the implementation of the event interfaces.

Tips

Base types- ProxyGen does not support external base types an error that the type is not remotable. An easy workaround for this is to exclude the base type. This will allow the type to inherit MarshalByRefObject and pass through the proxy layer; however, it will not pass with its base type functionality. To expose it with this functionality explicitly implement the methods, properties, and events of the base type to expose.

ShapeAppMacroRecordingCSharp With IPHTerminateOrphanedVSTA observer thread

Gary — Wed, 10 Sep 2008 02:37:37 GMT

This IPH sample, IPHTerminateOrphanedVSTA, 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).

You should even be able to lift the code from IPH.cs and use it almost directly in your vsta projects' existing IPH:

hostProcessName = "ShapeAppCSharp";

is the only thing you'll need to change in IPH.cs to work with your host process.

To run the attached sample, follow these 5 steps. The steps assume 1. ShapeAppMacroRecordingCSharp is the host; 2. that you have already installed, run ShapeAppMacroRecordingCSharp (from VSTA 2.0 SDK Release bits) and launched the IDE at least once; And 3. that you will move out or rename the original ShapeAppMacroRecordingCSharp solution folder tree and drop this solution in its place (preserving registered name and folderpath):

1. Build IPHTerminateOrphanedVSTA project along with the ShapeAppMacroRecordingCSharp solution. This should create the assembly:

ShapeAppMacroRecordingCSharp\IPHTerminateOrphanedVSTA\IPHTerminateOrphanedVSTA\bin\Debug\IPHTerminateOrphanedVSTA.dll

and should also install it into the GAC (via InstallInGAC.bat), listing the asembly info in the VS output window:

"The Global Assembly Cache contains the following assemblies:

IPHTerminateOrphanedVSTA, Version=1.0.0.0, Culture=neutral, PublicKeyToken=5993c97a24fb6aa3, processorArchitecture=MSIL"

2. Run the IPHTerminateOrphanedVSTA.IHP.reg file (double-click on it from Windows Explorer) included in the IPHTerminateOrphanedVSTA project to add IPH to registry.

3. Explore the ShapeAppMacroRecordingCSharp\templates\CSharp\ShapeAppCSharp-AppLevel.zip, and confirm that ShapeAppCSharpAppAddInProject.csproj includes the IPH entry:

4. Update the HKEY_LOCAL_MACHINE\Software\Microsoft\VSTAHost\ShapeAppCSharp registry hive so host app will use newly registered IPH (from step 2):

Delete the 9.0 key under the ShapeAppCSharp key, HKEY_LOCAL_MACHINE\Software\Microsoft\VSTAHost\ShapeAppCSharp\9.0,

then, run vsta /hostid ShapeAppCSharp /setupfrom the command line

5. Finally, follow the instructions in IPH.cs to run ShapeAppCSharp and test the IPH:

//To debug this IPH follow this sequence:

//1. start ShapeAppMacroRecordingCSharp sample directly from .exe or select 'Debug | Start Without Debugging' in VS

//2. Show VSTA IDE (Alt + F11), should load a macro project with no IPH

// (if macro project has IPH, just remove entry <InProcHost>{2CD68381-5859-4afe-88AC-42D13CD4B335}</InProcHost> from ShapeAppMacros.csproj before 'Tools | ShowIDE' opens it).

//3. In VS, 'Debug | Attach To Process...' select vsta.exe

//4. In VSTA IDE, 'File | New Project', select CSharp template, discard open project and this IPH (IPHTerminateOrphanedVSTA.IPH.SetAdapter() should be called.

//5. From 'Task Manager', kill ShapeAppCSharp.exe and the CheckForHostObserverThread.CheckforHostProcess should drop into section where this call is made:

// System.Diagnostics.Process vstaProc = System.Diagnostics.Process.GetCurrentProcess(); so that vsta.exe can be terminated.