Summit Software

MSDN: VSTA 2.0 Brings Power to the People

Gary — Wed, 01 Dec 2010 20:28:09 GMT

Author: Gary Depue

Published: MSDN Magazine March 2008

vbe6.dll 6.5.1053 Debug

jimg — Tue, 11 May 2010 18:33:01 GMT

This security update resolves a privately reported vulnerability in Microsoft Visual Basic for Applications. The vulnerability could allow remote code execution if a host application opens and passes a specially crafted file to the Visual Basic for Applications runtime. If a user is logged on with administrative user rights, an attacker who successfully exploited this vulnerability could take complete control of an affected system. An attacker could then install programs; view, change, or delete data; or create new accounts with full user rights. Users whose accounts are configured to have fewer user rights on the system could be less impacted than users who operate with administrative user rights.

http://www.microsoft.com/technet/security/Bulletin/MS10-031.mspx

VBAOF11.msi Debug

jimg — Tue, 11 May 2010 18:31:29 GMT

http://www.microsoft.com/technet/security/Bulletin/MS10-031.mspx

VBAOF11.msi Release

jimg — Tue, 11 May 2010 18:25:19 GMT

http://www.microsoft.com/technet/security/Bulletin/MS10-031.mspx

vbe6.dll 6.5.1053 Release

jimg — Tue, 11 May 2010 18:21:48 GMT

http://www.microsoft.com/technet/security/Bulletin/MS10-031.mspx

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.

Autodesk Revit VSTA Case Study

dschneid — Fri, 23 Jan 2009 14:47:33 GMT

A case study outlining Autodesk Revit's integration of VSTA and the benefits derived from the integration of VSTA into Revit.

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).

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.

EventSample VB for VSTA v 2

Melody — Tue, 02 Sep 2008 21:01:03 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.

I) Declaring Objects in VSTA

VSTA cannot access constructors from the host application. The constructors included in the proxy file are for internal use only. To create an object in VSTA, a public method must be available in the add-in entry point, in this case the MainApplication class, which constructs the object, then returns it. The code below shows an object class, MainObject, the MainApplication class, and an add-in. In the MainApplication class, the method NewObject is used by the add-in to create a MainObject in the add-in.

''' HOST

''' <summary>

''' Simple object used by the main application.

''' </summary>

Public Class MainObject

''' <summary>

''' Holds a message which is displayed on the main form.

''' </summary>

Private mMessage As String

Public Property Message() As String

Get

Return mMessage

End Get

Set(ByVal value As String)

mMessage = value

End Set

End Property

''' <summary>

''' Creates a new MainObject with the message passed in.

''' </summary>

Public Sub New(ByVal messageIn As String)

Message = messageIn

End Sub

End Class

''' HOST

''' <summary>

''' Main class of the application.

''' VSTA entry point.

''' </summary>

Public Class MainApplication

''' <summary>

''' Factory method used to create a new MainObject.

''' </summary>

''' <remarks>VSTA requires objects to be created on the host side

''' using a factory method instead of using the "New" operator</remarks>

Public Function NewObject(ByVal inMessage As String) As MainObject

Return New MainObject(inMessage)

End Function

End Class

''' ADD-IN

Private Sub AppAddIn_Startup(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Startup

'create a new MainObject

Dim myObject As MainObject = Me.NewObject("New MainObject for VSTA add-in")

End Sub
II) Using Forms in VSTA

Forms and other objects under System.Windows.Forms cannot be passed through the proxy layer because they are not serializable. To include a form, or any System.Windows.Forms object, make it an internal property in the main application and exclude the form’s class in the descriptor file. The code below demonstrates how to start a windows form based application. The starting point of the host application, the Program class, contains a MainApplication property. The MainApplication class contains a MyForm property which is run by the Program class.

''' HOST

''' <summary>

''' Startup object of the host application.

''' </summary>Public Class Program

<STAThread()> _

Shared Sub Main()

'prepare to use forms

Application.EnableVisualStyles()

Application.SetCompatibleTextRenderingDefault(False)

'create the application

Dim thisApplication As MainApplication = New MainApplication()

'run the form

Application.Run(thisApplication.MyForm)

End Sub

End Class

''' HOST

''' <summary>

''' Main class of the application.

''' VSTA entry point.

''' </summary>

Public Class MainApplication

''' <summary>

''' Form used internally only.

''' </summary>

Private mMyForm As MainForm

Friend ReadOnly Property MyForm() As MainForm

Get

Return mMyForm

End Get

End Property

End Class

III) Manipulating a form in VSTA

With the form set as an internal property in the MainApplication class, VSTA cannot directly interact with the form or its controls. To interact with these, the AddInEntryPoint (in this case the MainApplication class) must contain public methods which handle these interactions. The code below shows the MainApplication’s addTextToListBox method which takes in a string and adds it to the list box lstDisplay contained on the form. The add-in calls this method and the string passed in from the add-in is displayed in the list box on the form.

''' HOST

''' <summary>

''' Main class of the host application.

''' VSTA entry point.

''' </summary>

Public Class MainApplication

Public Sub addTextToListBox(ByVal message As String)

'display the message in the list box

MyForm.lstDisplay.Items.Add(message)

End Sub

End Class

''' ADD-IN

Private Sub AppAddIn_Startup(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Startup

'add a message to the list box

addTextToListBox("Message from VSTA add-in")

End Sub
IV) Form Events in VSTA

In order for an add-in to catch an event on a form, the host application must catch the event and fire a public event that VSTA can see. In the code below, the constructor of the MainApplication calls the method HookUpEvents which associates a method in the host application, DisplayClear, with an event generated by the form, a button click. The method in the host application hooked up to this form event, DisplayClear, fires the public event, DisplayClearedEvent, which VSTA can see. The add-in hooks up a method, AddIn_DisplayClear, with the event and displays a line of text on the form.

Note: When firing events accessible from VSTA it is important to use the host application (or object within the host application) as the sender, by specifying “me” (“this” in C#). Using the original sender will not work.

''' HOST

''' <summary>

''' Main class of the host application.

''' VSTA entry point.

''' </summary>

Public Class MainApplication

''' <summary>

''' Prepares the host application to run.

''' Sets up the list of objects and the form.

''' Hooks up form events to methods that will raise VSTA visible events.

''' </summary>

Public Sub New()

'instantiate the form and lis tof messages

mMyForm = New MainForm

mMyObjects = New List(Of MainObject)

'hook up the event handling to the form

HookUpEvents()

End Sub

''' <summary>

''' Event raised when the display is cleared

''' </summary>

Public Event DisplayClearedEvent As EventHandler

''' <summary>

''' Associates form events with methods that will raise

''' VSTA visible events.

''' </summary>

Private Sub HookUpEvents()

'Event handling for the form, not exposed to VSTA

' VSTA accessable events are raised in the methods hooked into

AddHandler MyForm.cmdClear.Click, AddressOf RaiseDisplayClear

End Sub

''' <summary>

''' Raises the DisplayClearedEvent visible to VSTA

''' </summary>

''' <remarks>Notice the event delegate passed to the EventHelper is EventNameEvent not EventName.

''' This is due to VB syntax.</remarks>

Private Sub RaiseDisplayClear()

EventHelper.Invoke(DisplayClearedEventEvent, Me, EventArgs.Empty)

End Sub

End Class

''' ADD-IN

Private Sub AppAddIn_Startup(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Startup

AddHandler DisplayClearedEvent, AddressOf AddIn_DisplayClear

End Sub

'manually added event handling

Private Sub AddIn_DisplayClear()

addTextToListBox("Add-in saw display clear")

End Sub

'event handling added through the drop down menus

Private Sub AppAddIn_DisplayClearedEvent(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.DisplayClearedEvent

addTextToListBox("Add-in saw display clear (twice)")

End Sub

V) Using EventArgs in VSTA

Like forms, EventArgs based on the System.Windows.Forms class cannot be passed between the host application and add-ins because they are not serializable. One work around for this is to use custom event args. The custom event args should have serializable public properties to hold information from the event args based on System.Windows.Forms. Below is the ButtonClickEventArgs class is used in place of System.Windows.Forms.MouseEventArgs to pass information about button clicks on the form to the add-ins.

''' HOST

''' <summary>

''' Custom event args to hold button click information

''' to expose to VSTA.

''' </summary>

''' <remarks>This wrapper class is used to pass information instead of

''' passing the MouseEventArgs directly because System.Windows.Forms is

''' not serializable therefore cannot be passed.</remarks>

Public Class ButtonClickEventArgs

Inherits EventArgs

''' <summary>

''' Name of the button which was clicked

''' </summary>

Public ReadOnly Property ButtonName() As String

Get

Return mButtonName

End Get

End Property

Private mButtonName As String

''' <summary>

''' Which mouse button was used- right or left.

''' </summary>

Public ReadOnly Property MouseButton() As String

Get

Return mMouseButton

End Get

End Property

Private mMouseButton As String

''' <summary>

''' Creates a new ButtonClickEventArgs storing which button was clicked

''' and which mouse button was used.

''' </summary>

Public Sub New(ByVal sender As Object, ByVal e As System.Windows.Forms.MouseEventArgs)

'determine which button was clicked and with which mouse button

Dim Button As System.Windows.Forms.Button = CType(sender, System.Windows.Forms.Button)

mButtonName = Button.Name

mMouseButton = e.Button.ToString()

End Sub

End Class

''' HOST

''' <summary>

''' An event handler type for button clicks.

''' </summary>

Public Delegate Sub ButtonClickEventHandler(ByVal sender As Object, ByVal e As ButtonClickEventArgs)

''' HOST

''' <summary>

''' Main class of the host application.

''' VSTA entry point.

''' </summary>

Public Class MainApplication

''' <summary>

''' Prepares the host application to run.

''' Sets up the list of objects and the form.

''' Hooks up form events to methods that will raise VSTA visible events.

''' </summary>

Public Sub New()

'instantiate the form and lis tof messages

mMyForm = New MainForm

mMyObjects = New List(Of MainObject)

'hook up the event handling to the form

HookUpEvents()

End Sub

''' <summary>

''' Event raised when any button is selected

''' </summary>

''' <remarks>Exposed to VSTA and not used by the host</remarks>

Public Event ButtonClickEvent As ButtonClickEventHandler

''' <summary>

''' Associates form events with methods that will raise

''' VSTA visible events.

''' </summary>

Private Sub HookUpEvents()

'Event handling for all buttons- any button click raises

'the ButtonClickEvent which is exposed to VSTA and called

'in RecordClick

AddHandler MyForm.cmdOpen.Click, AddressOf RecordClick

End Sub

''' <summary>

''' Records any button clicks in the display.

''' </summary>

''' <remarks>Raises the ButtonClickEvent which is

''' visible to VSTA.</remarks>

Private Sub RecordClick(ByVal sender As Object, ByVal e As EventArgs)

'raise the event exposed to VSTA for any button click

EventHelper.Invoke(ButtonClickEventEvent, Me, _

New ButtonClickEventArgs(sender, CType(e, _

System.Windows.Forms.MouseEventArgs)))

End Sub

End Class

''' ADD-IN

Private Sub AppAddIn_Startup(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Startup

AddHandler ButtonClickEvent, AddressOf AddIn_ButtonClick

End Sub

Private Sub AddIn_ButtonClick(ByVal sender As Object, ByVal e As ButtonClickEventArgs)

'determine which button was pressed

Dim buttonName As String = e.ButtonName

'determine the mouse button that was used

Dim mouseButton As String = e.MouseButton

'display a message that shows the add-in found the above info

addTextToListBox("VSTA add-in caught button click" & vbNewLine & _

"Button: " & buttonName & vbNewLine & _

"Mouse Button: " & mouseButton)

End Sub

ShapeAppBasicMFC with ObjectModelAgent sample

Gary — Tue, 02 Sep 2008 16:14:08 GMT

This ShapeAppBasicMFC sample, adapted from the VSTA 2.0 SDK, is altered to demonstrate the COM ObjectModelAgent. The COM ObjectModelAgent component allows the host application to simply pass an instance of its COM object model to VSTA for automation, rather than generating a managed proxy for the entire surface of the existing, COM object model. The VSTA add-in/macro project will include a reference to the object model types, via an interop assembly (or PIA), to provide full intellisense for the object model at design time.

For further information, see ShapeAppBasicMFCWithOMAgent.doc in zip file.

ShapeAppMFC with Multi-Macro Storage

Gary — Tue, 02 Sep 2008 16:04:07 GMT

Macro storage and deployment investigation sample

· Demonstrates a clean way to create, load, save and unload VSTA projects, and built assemblies, from/to a single .VCF (VSTA Cab file) compressed file store located in any user-accessible folder on the local hard drive.

· Native C++, VSTA-enabled, sample host application that programmatically :

1. Creates, loads, unloads, and saves VSTA projects and related addin assembly (save/load both debug and release addin assemblies as needed) using the file described in #2.

2. Uses a single file (with .drwmacros extension) for persistence of a single VSTA project and its addins .

3. Shows the VSTA IDE with current project loaded for editing

4. Removes VSTA IDE Menu items: File | New project, File | Open Project, File | Close Project, File | Save All

Out of process debugging (VBA-style debugging) of a loaded Macro project

Proxy Versioning for Templates Sample

Melody — Fri, 15 Aug 2008 17:19:44 GMT

This sample illustrates how to use Tight Versioning to specify which version of the proxy a project template should use.

Goal: load add-ins which use a proxy from a previous OM after changing the OM.

OM version changes (using same VSTA version):

Example- ShapeAppBasicCSharp from VSTA v 2

Object Model Changes

Version 2.1	Version 2.2
SDK Sample from VSTA v 2	SDK Sample from VSTA v 2 with new method added: Application.ActiveDrawingHasShapes

Instructions to run sample:

1) Build the Versioning Sample\ShapeAppCSharp v 2.1 sample.

2) Run the Versioning Sample\ShapeAppCSharp v 2.1 setup file.

3) Build the Versioning Sample\ShapeAppCSharp v 2.1 sample add-in. Add-in hooks into the document created event, creates a document and adds a shape.

4) Run the Versioning Sample\ShapeAppCSharp v 2.1 sample host- verify that the add-in loaded and correctly executed.

5) Build the Versioning Sample\ShapeAppBasicCSharp v 2.2sample.

6) Run the Versioning Sample\ShapeAppBasicCSharp v 2.2 setup file.

7) Build the Versioning Sample\ShapeAppBasicCSharp v 2.2 sample add-in. Add-in hooks into the document created event, creates a document and adds a shape if none are present in the current drawing.

8) Run the Versioning Sample\ShapeAppBasicCSharp v 2.2- verify that both v2.1 and v2.2 add-ins load and correctly execute.

9) Run the Versioning Sample \ShapeAppCSharp v 2.1 sample host- verify that the v2.1 loads and executes correctly; however, the v2.2 add-ins will load but not execute because it uses an OM feature not supported by the v2.1 host.

In the Versioning Sample\MyDocuments folder the AppAddins folder contains the assemblies for the v2.1 and v2.2 add-ins. The AppAddins folder can be placed in %MyDocuments%\ShapeAppCSharp_Versioning instead of building the sample add-ins.
Instructions to Implement:

1) Version the host exe. (see doc in zip file for screenshots)

2) Version the proxy assemblies. (see doc in zip file for screenshots)

3) In the project templates, use version specific proxy references. (see doc in zip file for screenshots)

4) So that add-ins will run the current exe, use a registry instead of literal location to specify the host exe. (see doc in zip file for screenshots)

5) Installation:

To run and build add-ins, the version of the proxy that the add-in uses must be installed on the end users machine.

Required Proxy Assembly to build and run add-ins	Add-in v 2.1	Add-in v 2.2	Add-ins v 2.1 & 2.2
Host v 2.1	Proxy 2.1	Proxy 2.2*	Proxy 2.1 & 2.2*
Host v 2.2	Proxy 2.1	Proxy 2.2	Proxy 2.1 & 2.2

Examples:

· For users who have the 2.1 and/or the 2.2 version of the host, to build and run only v 2.1 add-ins only the v 2.1 proxy is required.

· For users who have the 2.1 and/or 2.2 version of the host, to build and run only v 2.2 add-ins only the v 2.2 proxy is required.*

· For users who have the 2.1 and/or 2.2 version of the host, to build and run both v 2.1 and v 2.2. add-ins, both the v 2.1 and v 2.2. proxies are required.*

*Note: The host v 2.1 can load and execute v 2.2 add-ins, unless the v 2.2 add-in uses OM features that were not present in v 2.1. For example, the v2.1 host loading a v2.2 add-in calling Application.ActiveDrawingHasShapes will fail.

ShapeAppCSharp v 2 Office Add-ins using XML

Melody — Tue, 17 Jun 2008 17:32:08 GMT

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.

Both add-ins can be used without having any version of Office installed. To open the Word document created by the SaveInWord add-in you will need Word 2007; however, the document.xml file where the data is stored can be viewed without Word. For the SaveInExcel add-in you can use Excel 2003 or 2007 (or an Xml viewer) to view the document because the data is stored in an Xml document using excel schema. Both add-ins are application level and hook into the document closing event.

To use these add-ins:

1) Download the zip file containing both add-ins and the Open Xml Format SDK and extract the files.

2) Ensure a VSTA v 2 ShapeAppCSharp sample is built and registered.

3) For the SaveToWord add-in, install the Open Xml Format SDK then build the add-in.

4) For the SaveToExcel add-in, build the add-in.

5) Run the basic or macro recording ShapeAppCSharp sample.

6) Add shapes to the 1^st drawing.

7) Close the document- answer yes to the message boxes prompting to save in Word and Excel.

To create these add-ins I used the following 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?”

Summit Software

MSDN: VSTA 2.0 Brings Power to the People

vbe6.dll 6.5.1053 Debug

VBAOF11.msi Debug

VBAOF11.msi Release

vbe6.dll 6.5.1053 Release

ShapeAppBasicMFC with Document Entry Point

ShapeApp_DynamicProgrammingModel_Packaging_SeamlessNonDestructiveDebugging_CSharp Sample

MyAppVB6_VSTA2_Integration

In Process Host Demo Sample

ShapeAppBasicCSharp AddInDiscoveryAlternative

ShapeAppBasicCSharpGenericCollectionIndexAdapter Sample

Autodesk Revit VSTA Case Study

ShapeAppBasicCSharpGenericCollectionAdapter sample hooks VSTA pipeline to pass custom type: IList

Simple C# Sample HelloWorld_VSTA2

UpgradeHelper Sample

Two Applications Share a HostID Sample

Modified Sample: One Application use two HostIDs

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

VSTA Integration templates

AutoProxyGen v 2.0.0.2

Overview

ProxyGen

Quick Guide

VSTA in AutoProxyGen

Using AutoProxyGen as a Build Event

ProxyGen bugs fixed by AutoProxyGen

Tips

ShapeAppMacroRecordingCSharp With IPHTerminateOrphanedVSTA observer thread

EventSample VB for VSTA v 2

Overview:

I) Declaring Objects in VSTA

End Sub II) Using Forms in VSTA

III) Manipulating a form in VSTA

End Sub IV) Form Events in VSTA

V) Using EventArgs in VSTA

ShapeAppBasicMFC with ObjectModelAgent sample

ShapeAppMFC with Multi-Macro Storage

Proxy Versioning for Templates Sample

ShapeAppCSharp v 2 Office Add-ins using XML

End Sub
II) Using Forms in VSTA

End Sub
IV) Form Events in VSTA