The Visual Basic Team : VB6_Migration/Interop

PInvoke Interop Assistant on CodePlex (Jared Parsons)

VBTeam — Fri, 20 Jun 2008 19:27:00 GMT

I'm happy to announce that the PInvoke Interop Assistant tool is now available on CodePlex. This includes the binaries, source code and the dev authored unit tests.

It is hosted on the more general CLR Interop Tools page.

http://www.codeplex.com/clrinterop

I will be actively maintaining this tool in the future and (hopefully) adding more features. There were several features we cut just before release due to QA costing that I would like to add back (including VS integration, wrapper functions).

Please post any suggestions you have for the tool on the site and we will definitely consider them.

Jared Parsons

http://blogs.msdn.com/jaredpar

Improvements to Visual Basic 6 Runtime Support on Vista, Windows Server 2008 (by Paul Yuknewicz)

VBTeam — Sat, 15 Mar 2008 23:46:31 GMT

You probably didn’t notice it, but we made some important and beneficial changes to the Support Statement for Visual Basic 6.0 on Windows Vista and Windows Server 2008 just a few weeks ago, and I want to share the good news.

First, just like Vista, the Visual Basic 6 runtime is officially supported on Windows Server 2008.

Second, we have expanded the list of ActiveX controls that are officially supported as part of Vista and Windows Server 2008.

For background, when we first announced over a year ago that the Visual Basic 6.0 applications would “just work” on Windows Vista, many of you pointed out there were a number of widely used ActiveX controls, such as comctl32.ocx and richtx32.ocx, listed as “tested but not shipping.” That basically means they aren’t supported on Vista, even though they are important pieces of many Visual Basic 6 applications. So the Visual Basic team spent the last year-plus talking with product teams all over Microsoft and offered to take over the code base for those components so we could support them. Now, we’re pleased to announce that we have added support for a number of controls and components commonly used in VB6 apps, and identified compatible upgrades for some less commonly used controls.

To summarize we hope these improvements will make you even more successful in preserving your VB6 assets. This should provide some peace of mind as you think about moving forward gradually to VB.NET, the most used MS .NET language, in VS2008 and future versions.

Best,

Paul Yuknewicz

Making PInvoke Easy

VBTeam — Fri, 14 Mar 2008 19:56:17 GMT

Jared here again.

I very excited to announce we recently released a tool I've been working on to MSDN that will greatly help with using PInvoke in managed code. The tool is called the "PInvoke Interop Assistant" and is included as part of a MSDN article on marshalling data for PInvoke and Reverse PInvoke scenarios.

Here is a link to the article and tool

Article: http://msdn2.microsoft.com/en-us/magazine/cc164193.aspx
Tool: CLRInsideOut2008_01.exe

The motivation behind this tool is writing PInvoke is a hard and often tedious task. There are many rules you must obey and many exceptions that must be taken into account. Anything beyond simple data structures gets very involved and subtle semantics of C can greatly change the needed signature. Incorrect translations often result in obscure exceptions or crashes.

In short, it's not any fun.

The tool works in several different ways to make PInvoke generation an easier process. The goal is to make generating managed code for structs, unions, enums, constants, functions, typedefs , etc ... as easy as possible. The resulting code can be generated in both VB and C#.

The GUI version of the tool operates in 3 modes.

SigImp Search: Search for a commonly used function and translate it into managed code.
SigImp Translate Snippet: Directly translate C code into managed PInvoke signatures.
SigExp: Convert managed binaries into C++ Reverse PInvoke scenarios

The first two are the parts I worked on and represent the PInvoke scenarios. The third part was written by Ladi Prosek and will be covered in a different article. We chose the names SigImp and SigExp to mirror the tblimp/tlbexp tool base since they have similar functions.

Directly translating C code into PInvoke Signatures

Most adventures in PInvoke start with a developer having a small set of C code they would like to use from a managed binary. Typically it's one or two functions with several supporting C structs. Before, all of this would be hand translated into managed code from scratch. With this tool all you must do is paste the code into the tool and it will generate the interop signature for you.

For instance assume you wanted to translate the following C code into VB.

struct S1
{
  int a;
  char[10] b;
};

float CalculateData(S1* p);

Start up the tool and switch to the "SigImp Translate Snippet" tab. Then paste the code in and then hit the Generate button.

You can also set click the "Auto Generate" box and watch the code update as you type.

This translation is not limited to built-in C types. It will also resolve most commonly used windows types such as HANDLE, DWORD all the way up to complex structs such as WIN32_FIND_DATA

Searching for a commonly used function

Often developers want to use C functions familiar to them in managed code. This can be a tedious task as well because if the signature is not already available you are back to coding from scratch. Even adding a constant value can be tricky if you don't know which header file to look in.

The tool also provides a database of many commonly used functions, structs, constants, etc ... It is essentially anything that is included from windows.h. Switch to the SigImp search tab, type the name of what you are looking for and hit generate. For example if I want to see the value for WM_PAINT just type it in.

In addition this part of the tool will also do dependency calculation. For instance if choose a method which has a parameter that is a C structure it will automatically generate the structure with the function. For instance if you choose the function FindFirstFile it will determine that the function depends on the WIN32_FIND_DATA structure. Furthermore it will notice that WIN32_FIND_DATA depends on FILETIME and generate both in addition to the method.

<System.Runtime.InteropServices.StructLayoutAttribute( _
    System.Runtime.InteropServices.LayoutKind.Sequential, _
    CharSet:=System.Runtime.InteropServices.CharSet.[Unicode])> _
Public Structure WIN32_FIND_DATAW
    '''DWORD->unsigned int
    Public dwFileAttributes As UInteger
    '''FILETIME->_FILETIME
    Public ftCreationTime As FILETIME
    '''FILETIME->_FILETIME
    Public ftLastAccessTime As FILETIME
    '''FILETIME->_FILETIME
    Public ftLastWriteTime As FILETIME
    '''DWORD->unsigned int
    Public nFileSizeHigh As UInteger
    '''DWORD->unsigned int
    Public nFileSizeLow As UInteger
    '''DWORD->unsigned int
    Public dwReserved0 As UInteger
    '''DWORD->unsigned int
    Public dwReserved1 As UInteger
    '''WCHAR[260]
    <System.Runtime.InteropServices.MarshalAsAttribute( _
        System.Runtime.InteropServices.UnmanagedType.ByValTStr, SizeConst:=260)> _
    Public cFileName As String
    '''WCHAR[14]
    <System.Runtime.InteropServices.MarshalAsAttribute( _
        System.Runtime.InteropServices.UnmanagedType.ByValTStr, SizeConst:=14)> _
    Public cAlternateFileName As String
End Structure

<System.Runtime.InteropServices.StructLayoutAttribute( _
    System.Runtime.InteropServices.LayoutKind.Sequential)> _
Public Structure FILETIME
    '''DWORD->unsigned int
    Public dwLowDateTime As UInteger
    '''DWORD->unsigned int
    Public dwHighDateTime As UInteger
End Structure

Partial Public Class NativeMethods
    '''Return Type: HANDLE->void*
    '''lpFileName: LPCWSTR->WCHAR*
    '''lpFindFileData: LPWIN32_FIND_DATAW->_WIN32_FIND_DATAW*
    <System.Runtime.InteropServices.DllImportAttribute("kernel32.dll", EntryPoint:="FindFirstFileW")> _
    Public Shared Function FindFirstFileW( _
        <System.Runtime.InteropServices.InAttribute(), _
            System.Runtime.InteropServices.MarshalAsAttribute(System.Runtime.InteropServices.UnmanagedType.LPWStr)> _
            ByVal lpFileName As String, _
        <System.Runtime.InteropServices.OutAttribute()> _
        ByRef lpFindFileData As WIN32_FIND_DATAW) As System.IntPtr
    End Function
End Class

Translating Large Code bases

The snippet translator works well for small snippets of code. If you are trying to translate a much larger code base, say several interdependent header files the small snippet dialog won't work well. To work with larger code bases you should use the command line version of the tool; sigimp.exe. It is designed to process several header files and produce a mass output.

Wrapping Up

This tool started out as a pet project of mine some time ago. I'm extremely excited that customers are now going to be able to take advantage of it and I greatly look forward to any feedback you have. I will post a couple more articles in the future detailing how this tool works under the hood.

Jared Parsons

http://blogs.msdn.com/jaredpar

InteropForms ToolKit - Visual Studio 2008 edition (Todd Apley)

VBTeam — Wed, 05 Mar 2008 17:51:00 GMT

I apologize right away that it's been a while since I've blogged about the interop forms toolkit although I've been doing my best to keep up with issues and questions on the interop forums. It seems from the mail I've received that a lot of people are having good success at extending their legacy vb6 apps in interesting ways using the toolkit. This post is a follow-up to the channel9 video that Beth posted here.

What's New - VS 2008

I wanted to use this posting to describe in more detail some of the content that I covered in that video. The main focus of the video was to describe how with the release of Visual Studio 2008, what changes should people be aware of when they are using the toolkit and what advantages there are with upgrading their development environment.

Why use Visual Studio 2008? Part of the goodness of being a tester at Microsoft is that you get to play with technologies several years before they are released. I can certainly say that if you are using VS 2005 (or before), you'll really appreciate using VS 2008 even if you don't take advantage of any of the new cool language features such as LINQ and XML literals. Specifically, you'll really notice the work done to make intellisense and performance of the editor far better than we have ever had it before. Anyway, I occasionally have to use older products (to track down bugs) and I pity the people who aren't already using 2008. Feel free to download the Express product and try it out!

With that pitch out of the way ;-), let me now go into detail about the specific items I mentioned if you want to use the interop toolkit with VS 2008. When we released the toolkit, we weren't able to fully test it out since VS 2008 was in beta, although we did get most of the core scenarios working. That being said, here are things you should be aware of:

Installation:

Side by side installation. If you have VS2005 and VS2008 installed, if you install the tookit, it won't register for VS2008. If you really need this functionality, add a post to the interop forums and I'll post up more details on how to make this work for you. However, in general, you should just uninstall VS2005 since VS2008 is able to work with both types of projects and then run the interop toolkit setup again.

Developing your .NET code:

Once you have the toolkit installed, you should be able to develop your interop usercontrol or forms project as normal. However, be aware of the following (learned from hours of doing things the hard way):

First, when you create your usercontrol project, create the project with a uniqueish name and then save the project. If you don't, you can easily run into odd problems with COM progID collisions and it makes it easier to mess up RegFree COM settings. In fact my channel9 video nearly didn't work b/c I just used the default name it gave me and I had already created a project of this name on another machine that I was trying to run the application on. Ack!
Target frameworks. When you create an interop usercontrol/forms project, the target framework will be set to 2.0 which means that you won't be able use things like LINQ in your project. To change this, just goto the compile properties tab/advanced compiler options page and change the target framework to 3.5. You may have to then add some references link system.xml to your project, although in general the VB compiler gives pretty good warnings/errors when you are missing appropriate references.
As mentioned in this post, the recommended way to develop hybrid applications is to use interop usercontrols and not not use the microsoft.interopformstools library unless you want to take advantage of some of its functionality (such as exposing application events and sharing global state). Consequently, I recommend you remove the reference to this assembly after you have created the control and when you do, compile your project -> you'll get a compile error in the activexcontrolhelpers.vb file where there are a couple of references to this assembly. Remove the entire "namespace my" section from the code and you should be fine. Of course, all good tips bear some appropriate disclaimers, so I'll do the same. My recommendation to always use interop usercontrols is valid except in these situations:

Where tabbing keyboard access between then host control and the interopcontrol is critical. There are some known oddities where tabbing doesn’t work properly in these cases. Start doing some basic prototyping and see if it works well enough for you.
Where entry of DBCS characters is needed in the interop usercontrol. There is a known bug on this which hasn’t been fixed yet.

If you run into other bugs/problems, issues, the best way to get resolution is to search the interop forums or ask your question there. If you want though, you can contact product support as the interop toolkit is supported as well.

3. Loading/Unloading of forms: If you place an interop usercontrol on a VB6 form and that form is repeatedly loaded and unloaded in your app, be forewarned that there are known issues in unloading releasing the usercontrol from memory, although it's easy in most cases to workaround. If your app has this type of behavior, what you should do is the following:

Create a public method in your usercontrol project that calls the dispose() method in your usercontrol.

In the queryunload of the form that's hosting the control (or in some other reasonable place) you call this method.

When building a usercontrol project, be aware that even though it may say it compiled and build ok, it may not have entirely worked. There is a post build step that uses rc.exe to compile icon and manifest information into the assembly and the logic for this post build step does not work on VS 2008 due to a change in where they store rc.exe. You can see the post build step logic by going to the compile properties tab/build events dialog. Basically, you just need to adjust the logic in this event to point to where rc.exe is located on your machine. Here’s an example:

"d:\wherever\rc.exe" /r "$(ProjectDir)InteropUserControl.rc"

After you change this, recompile your project, and look in the “output window” to ensure that this step isn’t failing.

Changing these settings for good:

Doing the 4 steps above isn’t really that hard and most of you probably will not develop too many of these controls, but if you find you want to automate/change the above for good, it’s not that difficult to do so. I’ll explain briefly here what you can do to change this. If you want more information, please make a request on the interop forums.

1. All the project settings are stored in various template files. You can see where the templates are stored by going to tools/options projects & solutions and seeing the “user project templates” and “user item templates” locations. If you look in those locations, you’ll find a “VB6 InteropForm Library.zip”, “VB6 UserControl.zip” file (and you’ll also find similar files in the item project template location). All you need to do in general is

a. Create a backup of this file (in case something goes wrong)

b. Unzip the file

c. Edit the appropriate .vbproj file (e.g. you can copy appropriate lines from a VS2008 project file that you use often and copy them over to the template location)

d. Rezip the file and place it in the same location (you can give it a different name if you want)

2. At this point, if you restart VS2008, and choose your new template, it should use your new settings.

Hopefully, the above made sense and should be easy for you to do, but if not, ask away on the forums.

Consuming your .NET control from VB6:

This is a biggie! Regardless of whether you use VS 2005 or VS 2008, you’ll want to be aware of this if you create usercontrol projects. There was a bug in the .net framework which prevented VB6 from syncing events on usercontrol projects. We documented a workaround in the help we shipped which explained how to work around this. However, the good news is that this bug is now fixed in .net framework 3.5 or in the 2.0 SP1 framework (which you can get here), so you can consume .net interop controls in the same way you would do any other ActiveX control in VB6. Additionally, this leads to some other scenarios that weren’t possible before (such as you can now have a vb6 usercontrol which hosts a .net usercontrol, etc…**), so please be aware of this change as the docs are now out of date. Of course, you’ll need to ensure your clients have the patched framework as well. I’d add some demo code here, but I don’t think it’s necessary. If you are used to working with controls in VB6, you already know how to make it work.

**Make sure you read my "Developing .NET code section above for some caveots with this approach that might effect you.

Also, as I mentioned in the Channel9 video, I think the slickest way of developing these usercontrol projects is (from VS in your interop project), goto your debugging properties page, choose start external program and point it at where you have vb6.exe locally. You can then simply press F5 and VB6 will launch and you can do things like setting breakpoints, etc… Just be sure to remember (as I didn’t in my demo ;-) ) that if you stop debugging from VS, you will lose any unsaved changes in VB6. Always make sure you save any changes in VB6 before you stop debugging!

Deploying your application:

The best article we have for understanding everything w.r.t. deploying interop projects can be found here. I’m confident that if you follow the guidelines there, it will help you deploy these applications in a painless way. If you have questions/concerns, look on the interop forums or post a question there (although I’ll monitor any comments to this post as well)

Also, if you search around, you’ll find a lot of interesting articles written by people doing things with the toolkit. For instance, here’s a good one on using my.settings with usercontrols.

VB6 – Live long and prosper…

Anyway, I know that many of you feel that VB6 is a dead product and although it’s starting to certainly show its age, I think there’s still a lot of life left to it. Heck, I even continue to use it in my job regularly for some internal tools we maintain. With the interop forms toolkit, it gives you the developer a straightforward way to start slowly incorporating .net functionality into your apps and learn new skills w/o losing the investment you already have made in your application logic.

Good luck!

Toddap_MS

Channel 9 Interview - Tips and Tricks with the Interop Forms Toolkit (Beth Massi)

VBTeam — Wed, 05 Mar 2008 09:23:00 GMT

Today I posted a Channel 9 interview with Todd Apley, Senior Test Lead on the VB Team, where he shows us a variety of tips and tricks with using the Interop Forms Toolkit on Visual Studio 2008. He also shows us how to deploy a hybrid application built with VB 6 and VB.NET using XCopy deployment and RegFree-COM.

Todd will also be posting follow-up information here on this blog. Also, check out interop posts here, articles on my blog on interop as well as the rest of the VB Team Interviews on Channel 9.

Enjoy,
-Beth Massi, Visual Studio Community

Petzold Chapter 3 (Young Joo)

VBTeam — Mon, 05 Nov 2007 09:55:00 GMT

I am Young Joo, PM @ VB team. I will be helping out Patrick on converting samples in Charles Petzold's WPF book (Applications = Code + Markup) to Visual Basic. This is an exciting project and I hope you enjoy this as much as I do. Another exciting news is that we have an extra help for this project. Evan Lim who currently teaches WPF & Blend courses at Foothill Community College in Los Altos, CA, has decided to help us with this. He already has a lot of chapters converted. So we will be able to release them much more quickly.

Attached is VB sample for chapter 3.

Enjoy!

Continued search for Small Business Developers and Chapter 2 of Petzold's book (finally!)

VBTeam — Sat, 13 Oct 2007 18:28:00 GMT

I've attached the chapter 2 Visual Basic.NET code for the ongoing project of converting Peztold's Applications = Code + Markup book on WPF proramming. I am happy to say that Young from my team is going to help with this effort so you will see these chapters coming out more frequently.

Also, we are about to close the doors on our intial sweep of bringing in our fellow small business developers to help us shape Visual Basic. As a note, I should mention that if you or someone you know is still using VB6 or has switched to another technology, we are very intersted in talking with you. A few links are included here.

If you are a consultant/small business developer (and that is really anyone out there who writes software for small businesses) please use the following sign up sheet: https://www.microsoft.com/usability/enrollment.htm

If you are an IT developer who builds departmental level applications, please sign up here:

https://www.microsoft.com/usability/enrollment_ITPros.htm.

And most importantly, if you are in the puget sound area, after signing up, please email uccoord@microsoft.com and cc' myself patd@microsoft.com.

Microsoft Visual Basic 2005 Power Packs 2.0 now available

VBTeam — Sat, 25 Aug 2007 03:40:00 GMT

In case you didn't see the links go live on the Visual Basic Developer Center the VB Off-Cycle team has shipped the latest edition of the Power Pack controls. You can download them from here.

In this update we've added the much anticipated Line and Shape controls.

The line and shape controls give you drag and drop ease at design time and great performance at runtime. By simply setting a few properties you can accomplish complex gradient fills. An improvement over the VB6 version of Line and Shape is we've added support for Events. These are fully supported by Microsoft as part of your Visual Basic support agreement, and will likely be rolled into the product in future releases. Remember if you have ideas for future Power Packs go to the Visual Basic 2005 Power Pack Suggestion Center and let us know about it. You can log new idea or vote for ones already there.

This release also includes updates to the PrintForm component and the Printer Compatibility Library. We also include a bootstrapper package in this release, something I am especially excited about because I am also responsible for ClickOnce experience in Visual Studio, and having a bootstrapper mean you only need to check a box to redistribute the Power Packs with your application.

Have fun, and send me pictures of any cool things you do with the new controls.

-Scott

Visual Basic on Channel9 (Beth Massi)

VBTeam — Sat, 21 Jul 2007 20:31:00 GMT

I just posted a couple screen casts/interviews on Channel9 you should definitely check out. I rounded up VB team members and influentials and asked them what their favorite Visual Studio 2008 features were and to give us all a demo of them!

The first one is with Erik Meijer and he shows us his favorite feature, XML Literals:

In this in interview Erik Meijer, an Architect on the Data Programmability team, shows us how LINQ to XML works in the next version of Visual Basic, 9.0. He talks about some of the history behind the features as well as how XML literals, unique to Visual Basic, are implemented. He takes us on an adventure on how to efficiently work with XML using XML Intellisense and an Office Open XML Excel document, pointing out a lot of tid-bits of information along the way that only Erik could show us.

The next one is with Jonathan Aneja and he shows us the Interop Forms Toolkit 2.0:

In this in interview Jonathan Aneja, a Program Manager on the Visual Basic team, shows us how the Interop Forms Toolkit 2.0 helps you migrate your existing VB 6 applications one form at a time to .NET. He gives us insight on how we can write .NET user controls and forms to take advantage of the .NET framework but still run within our VB 6 applications. He shows us a demo where he creates a .NET user control which uses LINQ to SQL features and then shows it running inside a VB 6 form.

I suggest watching them full screen for easier viewing of the demos. More will be coming soon so stay tuned! Enjoy!

-Beth Massi, VS Community

Slide deck for Interop Toolkit Webcast

VBTeam — Thu, 07 Jun 2007 03:38:00 GMT

Thanks to everyone who was able to make it out for this morning's webcast. We covered how to use the Interop Toolkit 2.0 to upgrade VB6 applications to VB.NET, how to deploy hybrid applications, and finally we touched on some other great interop resources available on MSDN.

As promised the slide deck's available below, and here's the list of important links:

VBRun - http://msdn.microsoft.com/vbrun
Interop & Upgrade Forum - http://forums.microsoft.com/msdn/showforum.aspx?forumid=879
Interop Forms Toolkit 2.0 - http://msdn2.microsoft.com/en-us/vbasic/bb419144.aspx
VB PowerPack Team - vbpwrpk@microsoft.com

Additionally, check out the VB Fusion site to learn how to Use 5000 Classes from VB6, Use SQL Express from VB6, and even implement multithreading using the BackgroundWorker!

Jonathan

InteropForms 2.0 Tip #1 - Font Property

VBTeam — Tue, 05 Jun 2007 02:55:00 GMT

(Starting today, we'll be highlighting various tips that might help you when using the InteropForms 2.0 toolkit. With the latest release of the toolkit, you can do some fairly impressive upgrades to your existing VB6 applications. Don't believe me? Check this out as one cool example - WPF in VB6 anyone?!)

If you don't have it, you can download the toolkit here.

Adding Font Property:

Here's a tip on extending Interop Usercontrols that some of you might find useful. Most usercontrols have a "font" property associated with them which can inherit its values from its container and defines what font is used for the controls that it contains. If you want to add this support to your control, here's what you can do.

1) From your VB6 Interop Usercontrol project, goto the references dialog on your project and add a reference to "stdole"

2) Open up your interopusercontrol control and in the "VB6 Properties" region, add this code:

Public Shadows Property ControlFont() As stdole.IFontDisp

Get

Dim fntTmp As New Drawing.Font(MyBase.Font.Name, MyBase.Font.Size, MyBase.Font.Style, _

System.Drawing.GraphicsUnit.Point, CType(0, Byte))

Return ActiveXControlHelpers.GetIFontDispFromFont(fntTmp)

End Get

Set(ByVal value As stdole.IFontDisp)

MyBase.Font = ActiveXControlHelpers.GetFontFromIFontDisp(value)

End Set

End Property

3) Open up ActiveXControlHelpers.vb and add this code to the activeXControlHelpers class

Friend Shared Shadows Function GetFontFromIFontDisp(ByVal obj As Object) As Font

Return AxHost.GetFontFromIFontDisp(obj)

End Function

Friend Shared Shadows Function GetFontFromIFont(ByVal obj As Object) As Font

Return AxHost.GetFontFromIFont(obj)

End Function

Friend Shared Shadows Function GetIFontDispFromFont(ByVal font As Font) As stdole.IFontDisp

Return TryCast(AxHost.GetIFontDispFromFont(font), stdole.IFontDisp)

End Function

4) You can then compile your project and reference it from VB6 and set the "controlfont" property appropriately.

This property was not included in the InteropForms 2.0 release since we didn't feel like it was that common of a scenario and it can make deploying the control in the general case a bit trickier. Specifically, you need to ensure that stdole.dll is deployed in the GAC which you can install by running a setup called vs_piaredist.exe which should be installed on your machine that has VS (typically in a \program files\common files\merge modules directory). It's a silent install, so it's pretty easy to deploy. However, you may find that all your clients have this installed and you don't need to worry about this.

Deploying Applications with the InteropForms 2.0 toolkit

VBTeam — Tue, 05 Jun 2007 02:46:00 GMT

(Recently, we released the InteropForms 2.0 toolkit which allows you to add the richness of .net windows forms to your vb6 application. We've gotten a fair number of questions from customers asking for more details on deployment, so this will hopefully answer most of your questions)

As I'm sure you're aware, deploying VB6 COM based applications can get complicated at times, which is one of the great advantages that moving your applications to .NET gives you. The Interop Forms Toolkit 2.0 allows you to easily extend your VB6 applications with .NET functionality, which is great, but it creates some interesting deployment issues. The good news is that there are some things we did in the latest 2.0 release to make this much easier than before and we tried to document the different strategies, but given that there are plenty of ways to do things, we wanted to blog about this in more detail.

To save you some time, here's what we recommend in general with building mixed apps.

a) Use the Interop Forms Toolkit to build Interop Usercontrols instead of Interop Forms.

b) Remove the reference to Microsoft.InteropForms.dll library unless you plan on taking advantage of some of it's functionality such as the Globals class (for sharing state) or the EventMessenger class (for raising application-level events).

c) Configure your usercontrol manifest appropriately and create an application manifest for your VB6 app so you can take advantage of Reg-free COM

d) Modify your legacy setup to copy over your new usercontrol binary and the application manifest into your application folder.

If you can do this, you can easily augment an existing application in a painless way. Deploying an application created this way is as simple as copying the new files down into the target directory. Of course, this doesn't work for all situations and I've glossed over a few other details that should be mentioned. To decide on the best way to deploy your application, you have to deal with three issues.

1) Prerequisites:

If you use an Interop usercontrol/form in your project, your clients need to have the .NET framework 2.0 installed on their system. This framework is on machines by default in Vista and may be on your client machines anyway, but if not, here's some options. (This assumes you have permissions to install/rollout .msi setups that globally effect the machine.)

1) The recommended approach is to use the bootstrapper technology in VS 2005 to deploy any prereqs you need. You can create a custom bootstrapper which installs prereqs like the .net framework only if necessary and in a secure way. These prereqs that the bootstrapper supports are typically called "bootstrapper packages" and you can see what's available on your machine by going to the Publish tab in the project designer and clicking on "Prerequisites" button.

A "custom bootstrapper" is basically a special "setup.exe" that is built by VS that understands what prereqs are needed for your application. Once the prereqs are installed, it will launch whatever you want - typically the application setup. If you ever build a Setup and Deployment project in VS or publish a Clickonce app, the "setup.exe" that is created is a custom bootstrapper.

2) Alternatively, you can roll your own approach (use batch file, etc...) which I won't go into detail here.

For most .Net created apps, the .Net 2.0 framework is the only dependency you have. However if you use InteropForms (rather than Interop Usercontrols) you take an a dependency on a binary called the "Microsoft.InteropFormTools.dll". You also have this dependency by default if you create an Interop UserControl project, although you can safely remove it unless you explicity want to use some of the objects in this assembly. We have bundled this file in a redist package and created a bootstrapper package so you can safely and securely deploy this binary just like you would with the .Net framework.

Lastly, if your Interop project has any extra 3rd party dependencies, you'll need to ensure those are appropriately installed. If you want, you can create your own bootstrapper package for them and have the VS bootstrapper take care of installing them for you.

Resources:

Creating a custom bootstrapper: Check out the "How To: Deploy a Hybrid Application" topic in the Interop Forms Toolkit documentation.

Creating a bootstrapper package: Check out these links:

http://msdn2.microsoft.com/en-us/library/aa730839(VS.80).aspx

http://blogs.msdn.com/chrsmith/articles/Using_the_Bootstrapper_to_wrap_a_Windows_Installer_package.aspx

Actually, there's a great tool that David Guyer created to allow you to visually create both a custom bootstrapper or a bootstrapper package. I highly recommend it. You can download it (via ClickOnce!) here:

http://www.codeplex.com/bmg

2) Registering the Controls with Reg-Free COM:

Registration free COM is a cool technology that works in Windows XP and later operating systems that allows you to deploy COM-based binaries without having to register them. If you can be sure that your clients will be on this platform or later, then it can make your deployment story much easier if you use Interop UserControls. As I mentioned above, the only thing you need to add to legacy application is add your new usercontrol assembly and an application manifest file to your application and copy those files to the application directory and you're done.

If you use InteropForms projects (or say you have to support older platforms like Windows 98 or Windows 2000), this approach won't work and you'll need to use regasm (or a windows .msi) to deploy your assemblies which is more difficult, but still quite doable. If you use InteropForms projects, probably the easiest way to deploy them is in this manner:

1) Create a VS Setup and Deployment project and add your InteropForms assembly to it. Also, make sure you set the register property to vsdraCOM so that will get globally registered on the machine and build your .msi

2) Create a bootstrapper package for this .msi and then add this package to your custom bootstrapper.

Interop UserControls projects cannot be deployed this way b/c they rely on some additional code to get run to register them properly (check out the code in the method with the DllRegisterFunction() attribute), so you need to use regasm.exe directly if you want to deploy them and cannot use reg-free COM.

Note: If you do need to use regasm.exe, what I find to be the best approach is to create an .msi like above, but use a custom action to register/unregister the assembles. The good news is that we've shipped the code to do this and you can just borrow what we have. Look in the source.zip file in the installation folder and check out the "bootstrapperpackageinstaller" project for details. In the "How to: Deploy a Hybrid Application" in the Interop Forms documentation, we also mention that you can ship regasm.exe in your installer, although I would recommend using the code that we ship (which searches for and finds the right copy of regasm.exe installed locally).

Resources:

Search MSDN for "vsdraCOM" and you'll get a bunch of information around this. Also, check out the links mentioned above for more information on bootstrapper information.

3) Your existing setup:

Part of the choosing of the best way to deploy your application comes from what you can do with your existing setup. Here's the common scenarios and what we recommend.

a) Your setup is frozen (or you cannot modify it).

In this case, you can create a custom bootstrapper to install all prereqs that your application needs (whatever component you created in (2) above).   You will end up with a single setup.exe which will launch and setup everything the application needs.

b) Your setup is a windows .msi file created in VS.   In this case, you can just add the appropriate logic for installing your assembly (see (2) above) and you can just goto the Prerequisites dialog for the setup project and rebuild your .msi.   VS will create a custom bootstrapper (the setup.exe) that installs all needed prerequisites.

c) Your setup is created with the VB6 package and deployment wizard or some other technology and you can modify it.   Depending on (1) above - namely, if you need to install prerequisites, you might want to create a custom bootstrapper to "wrap" your legacy setup.   Depending on (2), you can either just add your files to your setup (if you use RegFree COM and Interop Usercontrols), or can do something custom for your setup.

Resources:

http://blogs.msdn.com/chrsmith/articles/Using_the_Bootstrapper_to_wrap_a_Windows_Installer_package.aspx

Anyway, I hope that helps clear up any confusion around deploying hybrid applications. If you run into questions/issues feel free to ask questions here and we'll do our best to help you out.

Also we'll be doing a webcast with demos and some Q&A on June 6th, you can register for it here: http://msevents.microsoft.com/CUI/WebCastEventDetails.aspx?EventID=1032337474&EventCategory=4&culture=en-US&CountryCode=US

Good luck!

Toddap_MS

So what does ComClass actually do?

VBTeam — Sat, 02 Jun 2007 05:59:00 GMT

I came across a really cool article yesterday by James Ashley, which shows some of the cool things you can do with the Interop Forms Toolkit 2.0. The three VB6 examples cover consuming a WebService (complete with a Dilbert icon showing up in the VB6 toolbox!), implementing multithreading using the BackgroundWorker component, and last but not least a cool WPF cube. Best of all there’s tons of code samples and no less than *15* screenshots!

Along with the samples there’s also some C# translations of the templates that ship with the Interop Toolkit. While playing with these templates I was reminded of some of the subtle differences in how the VB and C# compilers handle COM Interop. The biggest difference is in how they handle the ComClass attribute, which we’ll see by looking at some code:

public event System.EventHandler ButtonClicked;

private void button1_Click(object sender, System.EventArgs e)

{

if (null!=this.ButtonClicked)

this.ButtonClicked.Invoke(this, e);

}

Public Event ButtonClicked As System.EventHandler

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click

RaiseEvent ButtonClicked(Me, e)

End Sub

In both cases we’re exposing a public event, and invoking it when the button is clicked. By using Reflector, let’s look at what gets generated under the covers:

[ComClass("c6cbbae7-44b8-422e-840f-cbaba8e3238c", "bf3ef778-6ca7-4ec8-a045-87be56528803", "37b0d42a-6740-45ec-adc6-38fcbcdc48e4")]

public class InteropUserControl : UserControl

{

…

}

<DesignerGenerated(), ComClass("a2ee6169-9a0d-4930-b8bb-ee71307c43b3", "75ff3d57-6448-40ac-a294-68252180cacd", "2b04895c-43f8-44b3-b187-00556ef53a6a"), Guid("a2ee6169-9a0d-4930-b8bb-ee71307c43b3"), ClassInterface(ClassInterfaceType.None), ComSourceInterfaces("VBControl.InteropUserControl+__InteropUserControl")> _

Public Class InteropUserControl

Inherits UserControl

Implements _InteropUserControl

…

<InterfaceType(ComInterfaceType.InterfaceIsIDispatch), Guid("2b04895c-43f8-44b3-b187-00556ef53a6a"), ComVisible(True)> _

Public Interface __InteropUserControl

<DispId(1)> _

Sub Click()

<DispId(2)> _

Sub DblClick()

<DispId(3)> _

Sub ButtonClicked(ByVal sender As Object, ByVal e As EventArgs)

End Interface

<Guid("75ff3d57-6448-40ac-a294-68252180cacd"), ComVisible(True)> _

Public Interface _InteropUserControl

<DispId(1)> _

Property Visible() As Boolean

<DispId(2)> _

Property Enabled() As Boolean

<DispId(3)> _

Property ForegroundColor() As Integer

<DispId(4)> _

Property BackgroundColor() As Integer

<DispId(5)> _

Property BackgroundImage() As Image

<DispId(6)> _

Sub Refresh()

End Interface

End Class

The VB compiler has generated two extra interfaces and applied the ComSourceInterfaces attribute to the control, which it knows to do when it sees the ComClass attribute. ComSourceInterfaces is used to link the event sink interface to the class. (<ComClass> actually does a lot more than just making events work automatically, but we'll leave that until another day).

What this means is that the VB.NET-compiled event will be visible in VB6, whereas using the C# compiler we’d have to define this interface ourselves. This also means that certain members the template adds like Visible, ForegroundColor, Refresh etc. are automatically exposed by the VB compiler; it’s still possible to do this in C#, it just takes some extra steps.

Both VB and C# offer a lot of powerful features you can use to extend VB6, but it’s important to be aware of the differences, especially when working with events. For more information on the Interop Toolkit be sure to check out our webcast on Wednesday. Also stay tuned to this blog for a series of Interop articles by Todd Apley, one of our QA leads.

Jonathan

Just Released - Interop Forms Toolkit 2.0!

VBTeam — Thu, 03 May 2007 00:40:00 GMT

Today we launched the Interop Forms Toolkit 2.0, which makes it easier than ever to upgrade VB6 applications to .NET. This new release builds on version 1.0 by adding support for the following features:

Interop UserControls - These are .NET controls that can be hosted on existing VB6 Forms. These controls look and feel just like regular ActiveX controls, but you build them the same way you would any other .NET control.
MDI Support - One of the big pieces of feedback we heard after the initial release was that MDI support was very important. With the introduction of Interop UserControls, you can now extend your MDI forms with .NET content.
Redistributable Package - The toolkit's runtime now appears in the Prerequisites dialog in Visual Studio Setup Projects, so deploying your hybrid application is very simple.

In the picture below you can see we've got a VB6 Form hosting a .NET UserControl which contains a MenuStrip and a ToolStrip. By inserting default items, we can build a control containing a MenuStrip and a ToolStrip, and hook it into VB6 - all in less than a minute!

Any public Properties, Methods, or Events defined in the UserControl are visible to VB6. You can also use My.InteropToolbox to raise application-level events and access Global variables.

You can download the toolkit here, and if you have questions you can contact Microsoft Developer Support or post questions at the Visual Basic Interop & Upgrade forum.

We're always interested in your feedback, so please let us know if there's a feature you'd like us to add! You can post comments below or send mail to vbpwrpk@microsoft.com.

Jonathan

Interop Roadmap – UserControls, MDI, and Data

VBTeam — Fri, 03 Nov 2006 02:53:00 GMT

Recently the VB team released the Interop Forms Toolkit, which allows VB6 developers to extend their existing applications using .NET. The toolkit allows developers to write a regular Windows Form in VB.NET, click “Generate Wrapper Classes”, and then call those forms from VB6. It also provides mechanisms for firing and handling events, and sharing application state (i.e. Globals).

We’ve heard a lot of great feedback since the release. For example, we heard that a better interop story and things like the toolkit help enable more gradual migrations. We also heard that several scenarios would benefit from additional support. Based on this we’ve been planning our next steps.

Here’s a preview of the direction we’d like to head in with interop. Two of the main areas we’re looking at are:

Interop UserControl support – this is basically the next step after the Interop Toolkit that enables .NET UserControls to be hosted in VB6 forms using interop. As you’ll see below you can leverage UserControls to enable more UI interop scenarios.
Data Interop – looking at what we can provide to make it easier to pass data between VB6 and .NET.

You can think of UserControl support as an extension to the Interop Forms Toolkit that adds a few more flexible ways to handle UI interop. For example, UserControls allow users to add .NET UI extensions within the same form. Also, given that a UserControl can be added to any VB6 form, there is good fidelity and communication between the VB6 forms.

As a case in point, MDI form scenarios are not supported by the current Interop Forms Toolkit due to several limitations with Windows Forms interop and the VB6 IDE. MDI support has been a top request since the release. The good news is that we believe the UserControl approach enables interop with MDI forms!

We have decided to share a very early (community supported only) Interop UserControl prototype with you to validate our direction and approach. This prototype is a UserControl project template for VS 2005 that includes attributes, helper functions, configuration, and workarounds required to do basic UserControl interop scenarios. You can use it to create a UserControl with UI, methods, properties, and even events. Simply build it and then add it to your VB6 toolbox.

To install the template, please see the file attached below called InteropUserControl.zip. This is a Visual Studio 2005 template that you can try out by placing it in your “My Documents\Visual Studio 2005\Templates\ProjectTemplates\Visual Basic” folder. Again, this is only an early prototype so expect to hit some issues and use workarounds. We hope to release a more complete version of this in the future.

We’re really interested in your feedback on this approach, so please try out the template and let us know what you think!

Jonathan Aneja & Paul Yuknewicz