Beth Massi - Sharing the goodness that is VB : Interop Toolkit

What is Microsoft’s Visual Basic 6 Support Strategy?

Beth Massi — Tue, 15 Sep 2009 03:47:00 GMT

I just posted an interview on Channel 9 with Paul Yuknewicz, Lead Program Manager on the Visual Studio team. Paul discusses Visual Basic 6 runtime and IDE support options as well as proven techniques, tools and best practices for interoperability and gradual, phased migration to .NET.

Channel 9 Interview: What is Microsoft's Visual Basic 6 Support Strategy?

Read the Official Support Statement on Windows 7, Windows Vista, and Windows XP

Today we also updated the the Visual Basic 6 Resource Center with better navigation, Visual Basic 6 samples and components, important downloads, as well as migration tools and training mentioned in the interview.

Please visit the Visual Basic 6 Migration page for information on how to plan and execute a gradual, phased migration to .NET.

Enjoy!

I Survived TechEd

Beth Massi — Tue, 10 Jun 2008 02:20:00 GMT

I feel like I need a T-shirt that says "I survived TechEd". It was my first time at TechEd and no one can really prepare you for how much work and play takes place at a huge conference like that. I had a BLAST. Our VB6 to .NET migration talks went well but I think by far the most fun was working the Visual Studio booths (so much so that I stayed longer there than I signed up for). I also did a .Net Rocks! show on VB XML Literals (I'll let you know when it goes live) and hung out at the MSDN booths for a bit playing with the new Social Bookmarks and Feeds. Oh yea, and lots and lots of parties (I'm pretty good at those ;-)) Lessons Learned: Next time bring more business cards. I ran out the second day!

Booth "Duty"

I say duty but manning the booth really didn't feel like a chore at all. The most fun I always have is talking to people about what they work on, then trying to understand their business challenges and hearing what technology decisions they've made. Most folks I spoke with were government employees (agriculture, energy, defense, and a couple people building applications for local police as well). Other folks were building or maintaining departmental applications in large corporations. Fun stuff.

It was also great to hear that most people I spoke with had downloaded and were starting to use Visual Studio 2008. There was lots of great feedback here especially related to IntelliSense and of course LINQ. Many people wanted me to show them how to do something in LINQ as it seemed that they were still trying to get their heads around it all. Some people I spoke with didn't realize that LINQ isn't just for accessing data in a database. LINQ is a way to query any collection, be that in-memory objects, XML, or even over in-memory DataSets.

I think my favorite moment was when I worked with a developer that was trying to search an XML document using the XML DOM and we moved the code to LINQ to XML and queried it using one LINQ statement -- thus eliminating more than a page full of code. I also showed XML IntelliSense in VB by including a schema in the project. I pointed people to the downloads section of the Visual Basic Developer Center to install the XML to Schema tool which automatically infers the schema of XML data. It'll be good to get this tool baked into SP1.

There were also a lot of good discussions at the booth on LINQ to relational data (SQL, Entities, DataSets) and which approach is best in what scenarios. I got a couple "not another data access technology" vibes but once I explained them as options on top of ADO.NET rather than replacements I think people were more at ease. I showed a few people how you can take advantage of LINQ without having to re-architect your data access layer at all. I also pointed people who know T-SQL but are trying to learn LINQ to a series of blog posts the VB Team is putting together on "Converting SQL to LINQ" that show translations of a variety of statements and scenarios.

VB6 to .NET Migration Talks

The VB6 to .NET Migration topic had a great turnout. What was a bit surprising is that even though the Interop Forms Toolkit has been out for more than a year, it was news to almost everyone. Folks planning a phased migration should really get the Interop Toolkit and the Power Packs into their arsenal.

This topic had two sessions that I did with Rob Windsor (VB MVP) and Paul Yuknewicz (colleague at Microsoft). We did one TLC in an "interactive theater" located on the trade show floors as well as one "birds-of-a-feather" (BOF) discussion. The TLC we presented in similar format to the Webcast I did with Rob that you can view here. The BOF was really more of an interactive discussion and the group had some great challenges and we addressed many architectural options for migration. The discussion also included a couple great folks from ArtinSoft who provide migration tools and consulting.

VB6 to .NET Migration resources:

Developer Centers: Visual Basic 6, Visual Basic.NET
Interop Forms Toolkit (check out resources here and here as well)
Visual Basic PowerPacks
Assessment Tool
Code Advisor
Free PAG Guide: Upgrading Visual Basic 6.0 Applications to Visual Basic .NET
Book: Upgrading Microsoft® Visual Basic® 6.0 to Microsoft Visual Basic .NET
ArtinSoft: VB6 to .NET Migration Tool

Enjoy!

DevTeach - Last Day

Beth Massi — Fri, 16 May 2008 18:19:12 GMT

Thursday: Okay I know it's Friday but I was the last session of the day yesterday and I didn't have time to post afterwards (I'll tell you why in a minute).

My duet session with Rob Windsor was on VB6 to .NET Migration. We're going to take this one to TechEd this year as well. We've also done a webcast on this too that you can watch here. There weren't too many people in this one but it's always hard when you are the last session of the last day of a conference. Even though I was slightly burned out I think the talk went really well (at least the evals said so).

Rob and I started off the session by presenting a decision framework of different upgrade strategies. We talked about how you can decide if migration is the best option for your situation. Then Rob went over interop with COM and .NET by showing how you can call a COM component from .NET and how you can call a .NET component from VB6 using Runtime callable wrappers (RCW) and COM callable wrappers (CCW).

Next I presented the Interop Forms Toolkit. (I've written about this toolkit before in this blog as well as have done videos on these.) The toolkit allows you to take a phased migration approach to moving (or just extending) your VB6 application by making it really easy to build .NET user controls and forms and run then directly from your VB6 applications. When you install the toolkit it gives you new project templates for building user control or form libraries that have all the pluming set up to register them properly and let you use them in your VB6 apps. I showed how to create an Interop user control, expose a public property and use it from a VB6 app. Then I showed how debugging works and how you can get My settings working properly as well.

Rob finished up the show by taking the code I built and showing how to expose .NET events to VB6 as well as how you can manage global variables and state between VB6 an .NET using the features of the toolkit. I think people really liked the demos because we really showed how easy it is.

Now for the reason why I didn't have time to post yesterday. Jean-Rene, the conference organizer gave Alan and I tickets to The Cure who were playing at the Air Canada Centre. Although I was never a huge Cure fan (my sister more than me) I thought it would be semi-nostalgic to see them. But we didn't care about the opening act and I was pretty wiped so we went and had a great Italian dinner and then walked down to the arena. We walked in easily, bought a couple beers, and headed in right as they started. I have to admit they were pretty good after all these years and they played a lot of old songs that I recognized so it turned out to be a great time.

Thanks Jean-Rene and Toronto for a great conference! Now time to pack, grab some lunch and head to the airport.

Webcast Starting! -- Migrating from VB6 to .NET

Beth Massi — Fri, 28 Mar 2008 18:25:00 GMT

Come join me and Rob Windsor in 30 minutes for a webcast on how to move your VB6 investments to .NET!

Live From ~~Red~~Bethmond: Migrating Your Visual Basic 6 Investments to .NET

Hope to see you all there. If you can't make it live, the download will be available this evening.

Enjoy!

Channel 9 Interview - Tips and Tricks with the Interop Forms Toolkit

Beth Massi — Wed, 05 Mar 2008 03:14:00 GMT

I just 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 on the VB Team blog.

Also, check out articles on this blog on interop as well as the rest of the VB Team Interviews on Channel 9.

Enjoy!

Webcast on VB6 Migration to .NET

Beth Massi — Wed, 27 Feb 2008 01:48:00 GMT

I just added another webcast for March 28th on VB6 migration to .NET to the list of March madness webcasts I'll be doing.

Rob Windsor and I will be presenting a bonus webcast on VB6 to .NET migration. If you're involved in a migration push and don't know where to start this webcast is for you. We'll show some proven strategies as well as walk through the Interop Forms Toolkit which can dramatically speed up development in a phased migration approach.

Live From ~~Red~~Bethmond: Migrating Your Visual Basic 6 Investments to .NET
3/28/2008 9:00 AM Pacific Time (US & Canada)- 3/28/2008 10:00 AM | Duration:60 Minutes
Visual Basic (VB) 6 was used by millions of developers world-wide to build applications ranging from thousands to millions of lines of code representing significant organizational investments. The path from VB 6 to .NET has not always been clear, there is no one size fits all approach. We’ll cut to the chase, exploring the pros and cons of each option using real world examples. You will leave this webcast with the framework and tools to develop the right strategy for your organization to leverage your existing investments while taking advantage of the power and productivity the .NET Framework provides. Presented By Beth Massi, Visual Studio Community PM With special guest Rob Windsor, Visual Basic MVP.

Check out the other webcasts in March on Visual Basic 9 and LINQ.

Enjoy!

Migration from VB6 to .NET on dnrTV

Beth Massi — Thu, 03 Jan 2008 00:52:00 GMT

There's still a lot of Visual Basic 6 systems running the world and if you're one of the developers maintaining those systems you may be looking at migration strategies to move to .NET. You don't have to take on a complete rewrite of your system, there are many ways of interoperating with VB6 from .NET and vice versa.

Check out Rob Windsor on dnrTV where he shows us how to interoperate with VB 6.0 applications and .NET in a variety of ways. He walks through different approaches to architecting these hybrid systems. He also shows how to use the Interop Forms Toolkit to demonstrate a phased migration strategy where you can convert VB 6 forms and controls to .NET pieces at a time.

Also take a look at these How Do I videos and articles on building and deploying interop forms and user controls.

Enjoy!

First Day at DevTeach

Beth Massi — Wed, 28 Nov 2007 19:49:00 GMT

I'm up in Vancouver at DevTeach and I have to say that so far it's been a great conference! I did a demo of my Visual Studio Tip of the Day browser and built an add-in (like I showed here) for part of the keynote with Ken Levy of the VSX team. This morning I open up VS and low and behold, Sara's next tip mentions my add-in and the conference! Weird, I'm reading about my add-in in my add-in :-).

The TOTD browser is a great example of using LINQ to XML in Visual Basic so I encourage you to download it and have a look at how easy this was to do with LINQ. Also, Sara will be meeting me up here this evening for a panel discussion with Richard Campbell and Carl Franklin on Open Source. Thanks Sara! I owe you some good Canadian beer after the panel ;-).

Yesterday I also did a session on migration strategies for VB6 apps to .NET. I talked about a decision framework and then showed a ton of code that demonstrated interop between VB6 and VB.NET using the Interop Forms Toolkit 2.0. I also showed a couple ways to approach debugging as well as showed how to deal with application config settings.

I was surprised by how many people came to the talk and how well received it was. There's a lot of great VB developers here in Canada. If you're scratching your head about how to approach a migration project, please check out the Toolkit and these posts for more information.

Later today I'm doing a session on What's New in Visual Basic 9 and it should be LOADS of fun. I have a few surprises planned :-).

Using My.Settings and WCF Configuration with the Interop Forms Toolkit

Beth Massi — Wed, 24 Oct 2007 23:07:00 GMT

Recently I received a question from a customer asking how to get an Interop User control developed with the Interop Forms Toolkit to be able to read the application configuration settings (app.config) in order to call a WCF service. (If you're unfamiliar with how to develop Interop user controls you can read these posts and watch these videos.) Since Interop user controls are compiled into library (.dll) assemblies the configuration file that is generated is named after the assembly, not the VB 6 application, which means that the Interop User Control isn't able to read the settings from this file.

The trick to solve this is simple, just rename the .dll.config file generated in your bin folder to the name of your VB 6 EXE and place that file in the same folder as your VB 6 EXE. Once you do that, the WCF service client configuration settings will be read properly at runtime.

You can easily set this to happen automatically using Build Events. Just double-click on My Project in the Solution Explorer to open the project properties, select the Compile tab, click the "Build Events" button, then click "Edit Post-build...". In the window type the copy command you want to execute. I.e.

copy /Y "$(TargetDir)$(ProjectName).dll.config" "$(ProjectDir)..\..\VB6App\Project1.exe.config"

Now every time the app.config file is modified in your Interop user control project, the .config settings will get renamed and copied to the right place, your VB6 application folder.

But what about using My.Settings? My.Settings allow you to easily store application-scoped and user-scoped settings and access them easily in your .NET programs. They are also stored in the application config file. But just renaming the file in this case doesn't work alone. This is because My.Settings uses what's called a Settings Provider. In Visual Studio 2005 the default settings provider loads and saves settings using the configuration system, thus they appear in the .config file, however they are read differently than the WCF settings.

So in addition to renaming the config file, we need to also modify the section headers in the app.config file to also specify the name of our VB 6 application (the bolded sections were added):

<?xml version="1.0" encoding="utf-8" ?>

<!--

Using userSettings in a VB6 application:

Change the name here to the name of your VB6 .EXE -->

<section name="Project1.My.MySettings" type="System.Configuration.ClientSettingsSection, System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" allowExeDefinition="MachineToLocalUser" requirePermission="false" />

</sectionGroup>

<!--

Using applicationSettings in a VB6 application:

Change the name here to the name of your VB6 .EXE -->

<section name="Project1.My.MySettings" type="System.Configuration.ClientSettingsSection, System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" requirePermission="false" />

</sectionGroup>

</configSections>

These section groups will not be lost if you add new settings via the Settings tab on your project properties. Now you can freely change the setting in the .exe.config file after deployment and your Interop user control will be able to read the settings properly. I've attached a complete example, including the WCF service, for you to play with in Visual Studio 2005. Please read the Readme.txt included for proper set-up.

Enjoy,
-B

Visual Basic on Channel9

Beth Massi — Sat, 21 Jul 2007 20:18: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 so stay tuned. And many thanks to Kathleen McGrath for helping with the production.

Enjoy!

Debugging Hybrid VB6/.NET Applications

Beth Massi — Wed, 04 Jul 2007 03:11:00 GMT

To wrap up this series of posts on hybrid applications with the Interop Forms Toolkit, I'd like to talk about debugging. There's a couple ways we can go about debugging with VB6 and Visual Studio and depending on where you're spending most of your coding time, you may opt for one method or the other.

The first way we can debug is by attaching to the running VB6.EXE process from Visual Studio. This works well if you are working primarily in VB6 code. You'll need to already have the VB6 IDE open and the project running in order to attach properly. Start your VB6 project from the VB6 IDE then go back to Visual Studio and select Tools --> Attach to Process and select VB6.EXE. It's important that the VB6 application is running and not in design mode when you attach.

Now you'll be able to set breakpoints in both Visual Studio and VB6 and have them step through each other by hitting F8. (NOTE: The Visual Basic Development Settings profile gives you the VB6 keyboard mappings, including F8 for stepping through code. If you just want F8 and not the other VB mappings, go to Tools --> Options --> Environment --> Keyboard and select the Debug.StepInto command.)

The other way to debug across both environments is to use the Debug Start Action. This method works well if you are primarily working in Visual Studio like when you are first creating your .NET controls/forms. This is because when you need to recompile your .NET assembly you'll sometimes need to close VB6 in order to see the new changes. This is because VB6 hangs onto the DLL while you're developing. It may be easier for you to set up debugging this way because VB6 is automatically started when you start the Debug from Visual Studio. But watch out, the VB6 IDE is also closed as well when you stop debugging in Visual Studio and so any changes that you make to your VB6 application (like via Edit and Continue) you'll need to remember to explicitly save by stopping the application in VB6 and saving the project.

To set this up, go to My Project --> Debug tab then select "Start External Program" and find your VB6.EXE (i.e. C:\Program Files\Microsoft Visual Studio6\VB98\VB6.EXE). Next you'll need to specify your VB6 project file and wrap the argument in quotes (i.e. "C:\VB6App\MyVB6App.vbp"). Finally you'll want to set the working directory appropriately. For instance, if you connect to a database file or other resources in the current directory then make sure you set that appropriately too.

Now when you start the Debug in Visual Studio, the VB6 IDE will open your project and you can then start the Debug there and set the necessary breakpoints.

Deploying Interop UserControls with RegFree-COM

Beth Massi — Thu, 28 Jun 2007 06:12:00 GMT

One of the features of the latest Interop Forms Toolkit is the ability to develop UserControls in addition to Windows Forms. In a previous post, I showed how to create a simple Interop UserControl. I also have a video here on creating them, and one here on deploying a hybrid application using the standard Setup and Deployment project in Visual Studio 2005.

The benefit of creating Interop UserControl libraries is that you can deploy them using what's called RegFree-COM. This means that if you're deploying your VB6 applications on XP or higher OSs then you don't have to manually register the assemblies as COM components. Instead the operating system will "register" them for you on-the-fly at runtime. The COM component registry keys aren't physically created in the system's registry, keeping the system clean and allowing you to deploy COM components in a side-by-side fashion. (On your development machine the UserControls are still physically registered when you build the assemblies so that you can develop in Visual Basic 6.) This may be the way to go if you have a current setup program that you use for your VB6 application that was written with the Setup and Deployment Wizard.

Using RegFree-COM also means that you can take advantage of ClickOnce Deployment (since ClickOnce will not register COM components). The benefit of using ClickOnce deployment with your VB6 applications is that you can take advantage of a modern deployment architecture which includes automatic updates and deploying from a central web server.

What the toolkit does to enable RegFree-COM is that it gets you started with a private assembly manifest for the UserControls. When you select the Interop User Control Library template when creating a new project in Visual Studio, a InteropUserControl.manifest file is created for you along with the rest of the files. Inside this private assembly manifest is XML describing the controls inside your library. By default, the name of the UserControl that is created when you first create your library is InteropUserControl with a generated class id. This information is described in the <clrClass> node.

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

<assembly xmlns="urn:schemas-microsoft-com:asm.v1"
manifestVersion="1.0">
<assemblyIdentity
            type="win32"
            name="InteropUserControlLibrary1"
            version="1.0.0.0" />
<clrClass
            clsid="{7395b9d9-da47-4262-80e7-b4eed8768d09}"
            progid="InteropUserControlLibrary1.InteropUserControl"
            threadingModel="Both"
            name="InteropUserControlLibrary1.InteropUserControl" >
</clrClass>
</assembly>

When you change the name of InteropUserControl or the assembly name you need to also update the contents of this file as well. If you add more UserControls to your library you'll need to create a new <clrClass> node with that control's information. You can find the class ID by looking in the Interop UserControl's VB6 Interop Code Region and then in the COM Registration Region:

<ComClass(InteropUserControl.ClassId, InteropUserControl.InterfaceId, InteropUserControl.EventsId)> _

Public Class InteropUserControl

#Region "VB6 Interop Code"

#If COM_INTEROP_ENABLED Then

#Region "COM Registration"

' These GUIDs provide the COM identity for this class

' and its COM interfaces. If you change them, existing

' clients will no longer be able to access the class.

Public Const ClassId As String = "7395b9d9-da47-4262-80e7-b4eed8768d09"

Public Const InterfaceId As String = "739b2e94-6bdf-4417-beff-25a457e6df8f"

Public Const EventsId As String = "65029223-ea4e-4cb0-9462-27edbbf985fa"

'These routines perform the additional COM registration needed by ActiveX controls

<EditorBrowsable(EditorBrowsableState.Never)> _

<ComRegisterFunction()> _

Private Shared Sub Register(ByVal t As Type)

ComRegistration.RegisterControl(t)

End Sub

<EditorBrowsable(EditorBrowsableState.Never)> _

<ComUnregisterFunction()> _

Private Shared Sub Unregister(ByVal t As Type)

ComRegistration.UnregisterControl(t)

End Sub

#End Region

As an example, I created an Interop UserControl library called ARegFreeComLibrary. In this library I created two UserControls, one called CustomerDetails and one called OrderDetails so my manifest looks like this:

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

<assembly xmlns="urn:schemas-microsoft-com:asm.v1"
manifestVersion="1.0">
<assemblyIdentity
            type="win32"
            name="ARegFreeComLibrary"
            version="1.0.0.0" />
<clrClass
            clsid="{7395b9d9-da47-4262-80e7-b4eed8768d09}"
            progid="ARegFreeComLibrary.CustomerDetails"
            threadingModel="Both"
            name="ARegFreeComLibrary.CustomerDetails" >
</clrClass>
<clrClass
            clsid="{bb58ec27-8668-49e0-90cf-3542075654a9}"
            progid="ARegFreeComLibrary.OrderDetails"
            threadingModel="Both"
            name="ARegFreeComLibrary.OrderDetails" >
</clrClass>
</assembly>

The other manifest file you need to have for RegFree-COM to work is called a client manifest file and this needs to be manually created and then placed in the application's directory. This would be where your VB6 application is also deployed. The contents of this manifest include the name and version of the VB6 application and then the Interop UserControl assembly information:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
    <assemblyIdentity type="win32" name="MyVB6App" version="1.0.0.0" processorArchitecture="x86" />
        <dependency>
            <dependentAssembly>
                 <assemblyIdentity type="win32" name="ARegFreeComLibrary" version="1.0.0.0" />
            </dependentAssembly>
        </dependency>
</assembly>

Place this into a file named after your VB6 application with an extension of .manifest, in my case, MyVB6App.exe.manifest, and pop it into the same folder as the exe. It's important that you name the client manifest file the same as your VB6 application + exe.manifest extension otherwise RegFree-COM will not work. To manage the file easier, from the Project menu in Visual Studio I selected Add New Item and selected Text File to create the manifest. In the properties window I then set the "Build Action" to Content and "Copy to Output Directory" to Copy Always. I find it easier to keep track of it this way.

Next thing to do is copy your VB6 app into the release folder under \bin\Release\ and any supporting files. In my example I am using an Access mdb, but I've added this file to the library I created as a local data file so it'll get built into the Release folder as well. Note, when working with local data files you'll need to also set the Copy to Output Directory appropriately like I explain in this post. Now what the client is going to need in order to run all this is:

1) The .NET Framework 2.0
2) The VB runtime (comes with XP and up OS's) and any OCX's or other referenced components/data you use in your VB6 application
4) Your Interop UserControl assembly and any .config files and the client .exe.manifest
3) The Microsoft.InteropFormTools assembly

When creating Interop UserControls you can remove the reference to the Microsoft.InteropFormTools assembly if you aren't using it -- just remove the reference and then comment out the code at the top of the ActiveXControlHelpers.vb file. However, if you are using it then it's easy to get ClickOnce to install this as a prerequisite (just like the Framework 2.0) because the toolkit now comes with a redistributable package. (You'll see this in a minute.)

You can also add your VB6 application to the project which, in my example, includes the MyVB6App.exe and the Msdatgrd.ocx (the VB6 DataGrid I'm using). Adding them as content files and marking them to always copy to output directory will put them into the \bin\Release folder every time you build the UserControl project. You can also specify the class library project location when you make your VB6 EXE, that way all the files you need to deploy come out in one place, the \bin\Release. If you're deploying this to a machine that already has the VB6 Runtime and the .NET 2.0 Framework then you can just xcopy deploy the Release to the client machine and run.

Using ClickOnce Deployment is optional but for this example we'll set it up this way. Since you can't use ClickOnce to deploy a class library project, instead of adding the VB6 application files to the class library project, we'll add them to a new Windows Forms application instead. So I just added a simple Windows Application to my solution called InteropAppLauncher. Once you have this project created you can then add a reference to your Interop UserControl Assembly and select "Add Existing Item" on the VB6 application files as well as the client manifest file (MyVB6App.exe.manifest). In my case, since I'm using an Access.mdb file I moved this file into the launcher application as well so it can be deployed.

Next thing to do is to write a couple lines of code in the launcher's form so that it will launch your VB6 application right away and close.

Public Class Form1

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load

Process.Start("MyVB6App.exe")

Me.Close()

End Sub

End Class

Now we're ready to publish with ClickOnce. Select My Project and go to the Publish Tab and enter the deployment location. I just set up a local file share, but you can easily publish to a web server as well. Select the Prerequisites button and you'll see the redistributable packages available. You'll definitely need .NET Framework 2.0 but you can decide whether you need the Interop Forms Toolkit 2.0 package depending on if you left the reference to Microsoft.InteropFormTools assembly. If you did, then you'll need to include this package.

Once you've set all that up you can click the Publish Now button or select Publish from the build menu. Now you have a ClickOnce setup that will launch your VB6 application which uses RegFree-COM in order to create a friction free deployment for your Interop User Controls. I've included the sample I built for your reference. To try out RegFree-COM, just compile the solution and then run the InteropAppLauncher.exe in the \ARegFreeComLibrary\InteropAppLauncher\bin\Release\ folder. For more info on setting up ClickOnce to deploy Visual Basic 6 applications, check out Scott's article on MSDN and this LabCast to try it out yourself right now. By the way, you can use ClickOnce for deploying Visual FoxPro applications as well.

Anyone developing Visual Basic 6 (or Visual FoxPro) applications should consider taking advantage of the Interop Forms Toolkit 2.0, ClickOnce Deployment, and RegFree-COM to bring .NET's modern capabilities to your users in an easy-to-manage way.

In the next interop post I'll talk about setting up debugging across Visual Studio and VB6. (UPDATE: Here's how to debug.)

Visual Basic Interop Video Series is Live!

Beth Massi — Tue, 26 Jun 2007 05:23:00 GMT

This how-to video series is focused on the Interop Forms Toolkit and working with Visual Basic .NET and Visual Basic 6 together. The Interop Forms Toolkit allows Visual Basic developers to migrate their Visual Basic 6 applications over to .NET using a phased migration strategy. Instead of having to convert the entire VB6 application at once, the toolkit enables.NET Forms and User Controls to run directly in Visual Basic 6 applications so that you can build the pieces that you need over time.

Download the Visual Basic Interop Video Series #1 and the associated code now!

Interop Forms Toolkit - Your New Best Friend

Beth Massi — Thu, 14 Jun 2007 05:41:00 GMT

I've been heads down this week (re)learning an older technology -- Visual Basic 6! With all the things to focus on like this, this and this you're probably asking "Um, Beth, WHY!?". It's because I've really been learning the Interop Forms Toolkit 2.0 in order to bring you some killer videos on the subject. The Interop Forms Toolkit makes interoperating with .NET forms and user controls from VB6 (and Fox) apps a total snap! I'm really impressed with how easy it is. The toolkit provides a library and code templates that does all the heavy lifting for you so you can concentrate purely on the task at hand. (NOTE: The Interop Forms Toolkit 2.0 is a Visual Studio Add-In and does not run under the Express editions of Visual Studio.)

Why would you want to use it? Well lets say you have a 10 year old Visual Basic (or Visual FoxPro) line-of-business application that needs new features that only .NET can provide, or it's just brain-dead simple in .NET and you're crying because of the effort involved with VB6. Well that's where the toolkit comes in. Instead of converting your entire codebase over to .NET (yea, that'll happen), you can take a phased migration strategy to your application -- even if the application is a monolithic one. This is because the toolkit allows you to seamlessly interoperate between VB6 (COM) and .NET code. .NET controls look like ActiveX controls to VB6.

Let's look at an example. Once you install the toolkit you're ready to start creating .NET control assemblies that can interoperate with VB6. (You can also create complete .NET forms, but the advantage of creating user controls (new to version 2.0 of the toolkit) instead is that they can use RegFree-COM which allows you to deploy your assemblies along with your VB6 exe's via ClickOnce Technology. ) When you create a new project, select the template located under "My Templates" called VB6 Interop User Control which will create a control library that you can interoperate with VB6 applications. This template sets up the proper interop code you need as well as the manifests that enable RegFree-COM.

If we double-click on the InteropUserControl you'll notice some ComClass attributes as well as a region called "VB6 Interop Code".

So I have a VB6 application that we want to extend. For this example it's just a simple form with a grid that pulls up customers from an Access database. A new requirement is to be able to edit the customer details below this grid so we'll extend the VB6 application with a .NET user control. We can easily create this user control in .NET and connect to the same Access database using the drag-and-drop databinding of Visual Studio 2005 as shown in my videos.

Of course this is a very simple example. You are not limited to data-access controls. You have the entire .NET Framework here at your disposal including the BackgroundWorker for multi-threading and .NET Web Services -- things that in VB6 are difficult or impossible to do.

When we design our .NET user control, any public property or method we create on the control will be exposed to VB6. I'll add a public property called CustomerID and in the setter I'll load the customer record from our database. I just create a simple parameterized query (like I did here) on the CustomerTableAdapter that passes the CustomerID.

'Please enter any new code here, below the Interop code

Private m_custID As String

Public Property CustomerID() As String

Get

Return m_custID

End Get

Set(ByVal value As String)

If m_custID <> value Then

m_custID = value

LoadCustomer()

End If

End Set

End Property

Private Sub LoadCustomer()

If Me.CustomerID <> "" Then

Me.CustomersTableAdapter.FillByCustomerID( _

Me.CustomerDataSet.Customers, Me.CustomerID)

End If

End Sub

Now build the solution. In development, this will register your interop user controls into the registry so that you can use them as ActiveX controls in Visual Basic 6. So back in the VB6 IDE, just add a reference to your new components by selecting "Project -- Components" (or Ctrl +T) and selecting your library. This will add the components to the VB6 toolbox.

Then you can drag-and-drop the user control from the toolbox onto the VB6 form. Jump to the code-behind in VB6 and add the code to set the CustomerID on the user control. You get intellisense on the public properties and methods.

Running the VB6 app we can now access our .NET control just like any other control on the form. The interop forms toolkit helper methods even take care of managing tabbing and focusing of the controls for you.

Consider performing a phased migration to your current LOB applications instead of a costly rewrite using the Interop Forms Toolkit 2.0. As you can see it allows you to quickly get .NET functionality into your current applications. Your users will need the .NET framework installed on their machines and the .NET user control assemblies registered, however with RegFree-COM and ClickOnce Deployment, these issues can be easily solved.