To create a workable structure I have always grouped individual new versions of Windows, VS.NET, VSTO and Office together. The present groups I work with are:

• Windows XP, VS.NET 2005, VSTO 2005 SE, SharePoint 2003 and Office XP/Office 2003
• Windows Vista, VS.NET 2008, VSTO 3.0, SharePoint 2007 and Office 2007
• Windows 7, VS.NET 2010, VSTO 4.0 SharePoint 2010 and Office 2010

The list also reflects my different configuration guest systems on the VMware platform. I have recently replaced Windows Vista 64-bit with Windows 7 64-bit as my host system. The grouping can also be said to represent the optimal situation where we develop solutions with the .NET/VSTO version included targeting the Office version(s) included. At least that is my experience.

While Windows 7 RTM has been released VS.NET 2010 and Office 2010 are still in the beta stage as of this writing. Beta 2 of VS.NET 2010 came out this week while Office 2010 officially still is in beta 1. To complete the picture; Exchange 2010 RTM seems to be around the corner and SharePoint 2010 will soon be in the beta stage.

I have been taking part of the Office beta testing but only for Excel. I have no intention to make any walkthrough about what is new in Excel 2010. It already exist a great number of blogposts and sites that cover all the news in detail like Microsoft Excel Team Blog and Microsoft Office 2010 Engineering. 

As for the operating system the real successor to Windows XP is Windows 7 and not Windows Vista . The later will probably get the same position as Windows ME already have in all history books. With Windows 7 we get a modern operating system, with more secured network functions, a flexible User Acess Control (UAC) together with a new folder system and improved tools for music and video. Despite all the new “whistle and bells” it is as fast as Windows XP for all kind of operations, including file operations. 

The news in VS.NET 2010 is nearly all about SharePoint developing. VB.NET has also been improved and among other things working with Collection and Array Initializers have been improved and added. As for the other languages I have not been testing anyone of them. The major news in the Beta 2 version is that VSTO 4.0 now is included. At present I’m evaluating VSTO 4.0 so I will get back to it in an upcoming blogpost.

Office 2010 includes news for all the softwares in the suite and will also be better integrated with SharePoint than any previously version. With Office 2010 we also get a new Web based Office suite. My major concern is Excel 2010 desktop version so the other tools as well as the Web based suite are less important to me. Unlike Office 2007 we now can customize the Ribbon UI via a built-in UI and Outlook 2010 has now also fully implemented the Ribbon UI. As a developer I was rather negative surprised when it turned out that we did not get any more events methods in code to control the Ribbon UI with. The Office Button has, together with its content, been revised and improved. The new programming language did not made it to this version so it looks like we will have to wait for Office 15.0.

For Excel 2010 the major news is that we finally have got a 64-bit version of it – Please see the discussion about the 64-bit version here: Excel 2010 – Now With More Bits!. With the 64-bit version it is possible to work with really large datasets which can consume more memory then 4 GB. The future will tell us to which degree we need to develop separated solutions for the 64-bit and 32-bit version of Excel.

Microsoft continues to develop the management of large datasets including data analyse, especially data visualization in Excel. Among the news in Excel 2010 are SparkLines and an improved Pivot Table tool including Slicers. The later allows us to filter data in real-time and when the data is updated so are the Slicers updated. The integration between Excel and SQL Server will in general be handle by the Business Intelligence tool (BI) Microsoft SQL Server PowerPivot for Excel which is an add-in to Excel 2010.

I must honestly say that Microsoft has managed to put the pieces together with the new versions and my overall impression of all the software are positive. Next year will be the year when Microsoft will have a complete updated versions of all the server platforms as well as the other software suites. That is impressive!

Kind regards,
Dennis

In the first part of this post I discuss how to work with the collection of add-ins as well as individual add-ins in Excel when using VB.NET/VSTO. In the second part the installation tool Visual Installer will be discussed in terms of installing and activating native add-ins in Excel.

Part I – Add-ins
When working with add-ins we need to separate native add-ins and unmanaged/managed COM and VSTO add-ins from each other. In this example I use a VSTO add-in to call the collections and add-ins.

If we want to load, i.e. activate, an add-in during a session the code below shows how to do it:

Private Const m_sXLDATA As String = "Data.xlsm"
Private Const m_sXLAREPORT As String = "C:\Data\Report.xlam"
Private Const m_sXLAREPORT_DISPLAYNAME As String = "Report"

Private Sub Application_WorkbookOpen( _
                ByVal Wb As Microsoft.Office.Interop.Excel.Workbook) _
                Handles Application.WorkbookOpen

        Try
            If Wb.Name.ToString() = m_sXLDATA Then
                With Globals.ThisAddIn.Application
                    .AddIns.Add(Filename:=m_sXLAREPORT)
                    .AddIns(m_sXLAREPORT_DISPLAYNAME).Installed = True
                End With
            End If
        Catch ex As Exception
            MsgBox(ex.Message.ToString())
        End Try

End Sub

Private Sub Application_WorkbookBeforeClose( _
                ByVal Wb As Microsoft.Office.Interop.Excel.Workbook, _
                ByRef Cancel As Boolean) _
                Handles Application.WorkbookBeforeClose

        Dim xlAddin As Excel.AddIn = Nothing

        Try
            If Wb.Name.ToString = m_sXLDATA Then
                For Each xlAddin In _
                Globals.ThisAddIn.Application.AddIns
                    If xlAddin.FullName = m_sXLAREPORT Then
                        xlAddin.Installed = False
                        Exit For
                    End If
                Next
            End If
        Catch ex As Exception
            MsgBox(ex.Message.ToString())
        End Try

End Sub

As we can see it does not differ from how we do it in VBA. If we want to load a COM add-in or a VSTO add-in it can be done in the following way:

Private m_xlCOMAddins As Office.COMAddIns
Private m_xlCOMData As Office.COMAddIn

Private Const m_sXLDATA As String = "Data.xlsm"
Private Const m_sXLDATAANALYZE As String = "SQL Tester NET 2010.AddinModule"

Private Sub Application_WorkbookOpen( _
                ByVal Wb As Microsoft.Office.Interop.Excel.Workbook) _
                Handles Application.WorkbookOpen

        m_xlCOMAddins = Globals.ThisAddIn.Application.COMAddIns
        m_xlCOMData = m_xlCOMAddins.Item(m_sXLDATAANALYZE)

        Try
            If Wb.Name.ToString() = m_sXLDATA Then
                If m_xlCOMData.Connect = False Then _
                m_xlCOMData.Connect = True
            End If
        Catch ex As Exception
            MsgBox(ex.Message.ToString())
        End Try

End Sub

Private Sub Application_WorkbookBeforeClose( _
                ByVal Wb As Microsoft.Office.Interop.Excel.Workbook, _
                ByRef Cancel As Boolean) _
                Handles Application.WorkbookBeforeClose

        m_xlCOMAddins = Globals.ThisAddIn.Application.COMAddIns
        m_xlCOMData = m_xlCOMAddins.Item(m_sXLDATAANALYZE)

        Try
            If Wb.Name.ToString = m_sXLDATA Then
                If m_xlCOMData.Connect Then _
                m_xlCOMData.Connect = False
            End If
        Catch ex As Exception
            MsgBox(ex.Message.ToString())
        End Try

End Sub

Again, it does not differ from how it’s done in VBA.

Part 2 SamLogic’s Visual Installer
In the past I have made comments on various blogs and at Q&A forums about an installation tool that can help us with the installation and with the activation of native Excel add-ins in a smooth way. I finally decided to make a blogpost about this superb tool. I have been using it for years and so far I have not seen any other tool that makes it so easy to set up the installation instructions. The software I talk about is Visual Installer 2008 from the Swedish company SamLogic.

At present Visual Installer 2008 is available in Swedish but it can create set up packages in English. Anyway, whenever I need to distribute native add-ins and related files I use it. It also works great with .NET packages including managed COM add-ins.

For the demonstration purpose here I use an add-in with name Report.xlam. To set it up in Visual Installer it only requires one line (!) as the below screen shot show:

The command XLADDIN trigger Visual Installer to add the required entry in the Windows Registry. After the installation the entry exist in the Registry as the following screen shot shows (OPEN5): 

When we uninstall the add-in the entry in the Windows Registry is silently removed. All in all, I find it to be an excellent companion.

Although I do not agree I know some VBA developers that have several Excel versions installed side by side. When using Visual Installer the add-ins are installed once but are registered for all available Excel versions on configurations with multiply versions installed.

The next version, i.e. Visual Installer 2010, will also support the 64-bits Windows platform as well as Windows 7.

Kind regards,
Dennis

For years I have been using the Radio Button control in many of my solutions (where it has been appropriated). When using the control it was usually together with the Group Box control. The following screen shot shows a common approach when using these two controls together and where users are supposed to select one of the three options. Typically one of the Radio Buttons is also pre-checked when the Windows Form is loaded.

When designing the UI and consider to use Radio Buttons the question we should raise is; when is the number of items relevant to the end users? My answer is when the users are about to make a selection, not before and not after that decision point. After the decision has been made the selected item should be viewed. 

This lead to a new standpoint, at least to me, when designing UI; instead of a group of Radio Button controls we replace them with a Combo Box control as the following screen shot show:

When the Windows Form is loaded we have the same option as with Radio Buttons; to have one (or more) item(s) selected or to have no no item pre-selected. When the users have made their decisions the selected item is showed in the control. Consequently,  the UI gets cleaner and the Windows form may even be down sized. Of course, the same discussion can be applied to the List Box control.

All in all, for all my future projects I will simple drop the Radion Button control and instead use the Combo Box control. Do You agree?

Kind regards,
Dennis

In 2007 Microsoft aquired Dundas Data Visualization but Dundas still remains as a standalone company. What matters is that by acquiring Dundas Microsoft got access to all the Dundas .NET controls. Last year Microsoft made the Chart control available for free. Originally the Chart control comes from Dundas but  Microsoft has done an update of its code base so it fits better with Visual Studio.

So far Microsoft have only provided some basic controls in Visual Studio and has let other providers to provide more advanced commercial controls. But with the Chart control they make an exception and provide an excellent control for free. Perhaps we will see more of that in the future?

I find the Chart control to be a great companion into my solutions where it requires some data presentation in terms of charts. Due to this I believe it deserves to be more highlighted within the Excel and .NET developing communities.

 Initially I planned to create a sample and discuss it in more detail however because MSFT has made over 200 samples available there are no reasons why I just should repeat some of these samples here. Actually, the sample collection is very nice and all the code samples can be viewed in both C# and VB.NET as the below screen shot shows.

What should be noted is that we cannot place the control on worksheets when creating document centric VSTO solutions. But on the other hand we don’t need to use it like that as we have access to Excel’s nice built-in chart control.

 For more information and to download please see the following links:

• Microsoft Chart Controls for Microsoft .NET Framework 3.5
• Microsoft Chart Controls Add-on for Microsoft Visual Studio 2008
• Microsoft Chart Controls for .NET Framework Documentation
• Samples Environment for Microsoft Chart Controls

A great blog about the Chart control is Alex Gorev’s Weblog.

Kind regards,
Dennis

In the second edition of PED we introduce a new area; Creating Cross Version Applications. That is, to develop solutions that must run with all Excel versions and Windows versions using a single code base. I will not discuss how to code against different Excel versions. Instead I set focus on running .NET solutions on different Windows versions, i.e. Windows 2000/Windows XP and Windows Vista/Windows 7.  It should be noted that I have previously blogged how to check which Excel version that is installed.

With Windows 2000 and Windows XP we know that the user accounts are available in paths like:
C:\Documents and Settings\Dennis

In Windows Vista and Windows 7 the user accounts are located in  paths like:
C:\Users\Dennis

Given this information we can rather easily code for different Windows versions in VB.NET. First we need to find out which Windows version that the targeting computers use. As the code shows below the namespace My.Computer once again comes to our rescue.

In the next step we retrieve the current user’s identity which is carried out by the SystemInformation namespace. Finally we put it together with the help from the StringBuilder namespace.

When we run the code on a Windows Vista configuration we get the following information: 

When the User Access Control (UAC) is turned on (Windows Vista/Windows 7) we cannot access the c:\ root unless we run as administrator. But no matter the UAC status we can always access the current user’s folder system. In that way we can write and read files to the user’s folders in addition to the above.

Kind regards,
Dennis

Excel Loader is a free standalone utility that let the user choose which add-ins should be loaded or not when launching Microsoft Excel.

I have updated the utility so it can run on Windows Vista and Windows 7 as well. The new version will also work with Excel 2010 once it’s out on the market. 

The next version of the tool will be completely rewritten as it will be developed on the .NET platform. In case You have any input about new features of the tools please let me know.

Below is a screen shot of its main window:

For more information about the tool and to download it please visit: Excel Loader 1.5

Kind regards,
Dennis

It has been a while since I last made a post here.  But I intend to get up to speed and publish on a more regular basis. Anyway, on the .NET platform and with VB.NET we can rather easy check if the computer we work on is connected to a network or not.

To know that information allows us:

• To run methods that update workbooks with the latest data.
• Run network located templates and individual workbooks.
• Load network based add-ins.

Technically we will be using the My namespace to find out if the computer is connected or not.  More specifically we will use the  My.Computer namespace which provides methods to control the computer’s hardware and the system software.  Among other things, it allows us to work with the file system, clipboard, Windows Registry network printers, network connection and keyboard & mouse.

The following snippet code shows how we can use it to determine if the computer is connected to a network.

Because the property isAvailable only indicates if there is a network available or not we need to make sure that there is a connection to the network we actually want to access. In order to do so we use the Ping function to insure that the wanted remote location is available.

Kind regards,
Dennis

Some of us Excel developers like the Ribbon UI while others find it more difficult to work with it. No matter what we developers think about it exist a growing number of clients requiring that the Ribbon UI to be implemented in .NET based Excel solutions.

Microsoft offers no controls that can be used to implement any Ribbon UI solution so we are forced to decide which third-party controls package to be used.  Of cause, most large vendors, such as Component One et al, offer components that can be used but they can be rather expensive.  DotNetBar from DevComponents is an inexpensive controls package including controls for the Ribbon UI.  I have been using the package for a while in clients solutions. DotNetBar includes 47 controls whereof some controls allow us to create a Ribbon UI in Windows Forms. All controls that are shipped with DotNetBar are highly customized. The controls are also frequently updated and new versions of DotNetBar are released on a regular basis.

With the package a collection of relevant case studies are shipped, both in VB and in C#. A knowledgebase is available to the DotNetBar customers and I find it easy to use it and it also provides relevant links based on the search criterias. The knowledgebase can also be accessed via the help file. The help file describes, in a strictly technical way, the DotNetBat assembly and its namespaces.

The following screen shot shows DotNetBar Samples Explorer: 

Because I find the controls to be good, especially the Ribbon UI controls, I have decided to use them for the upcoming .NET version of my commercial tool for Excel, the SQL Tester. The following screen shots are from the alpha version of SQL Tester.NET and all controls in use are part of DotNetBar package. 

The following screen shot views the main Windows Forms for SQL Tester.NET in the VS IDE. In addition to use a Ribbon UI it also use a tabcontrol with two tabs. These tabs will be synchronized with the tabs in the Ribbon UI and therefore is hidden when the tool is being executed.

Next screen shot shows the code in use to synchronize the tabs in the tab control with the tabs in the Ribbon control:

Having access to a tab’s click event is something we miss when building native Ribbon UI solutions in Excel. With DotNetBar we have it available without the need to create any workaround. Initially it may take some time to get used to the controls and what they offer. In my experience I would like to say that the more time we put into learning the controls the more we can leverage them in our Windows Forms solutions.

The following two screen shots show when SQL Tester.NET is being executed and we switch between the tabs in the Ribbon UI solution.

Kind regards,
Dennis

General
The book “Professional Excel Development” (aka “PED”) is now available in the second edition. The major news is that .NET including VSTO has been added to the book. Because I’m responsible for the .NET section in the book the list of authors now also includes my name too.

For some weeks ago Ross McLean had the kindness to make an interview me. Instead of repeating what I said in the interview you can read the full story here. However, I would like to thank Rob Bovey  for being an excellent teamleader for this edition. Another person I would also like to thank is Gabhan Barry (a Program Manager in the Excel group at Microsoft) who made the technical review on the .NET chapters.

New Chapters
The second editions includes five new chapters:

Chapter 10 - The Office 2007 Ribbon User Interface:
This chapter cover the Ribbon UI paradigm and discuss some advanced problem solving with the new UI.

Chapter 11 – Creating Cross-Version Applications:
In view of the fact that the Ribbon UI was introduced with Excel 2007 and that Windows Vista differ from Windows XP we decided to add this chapter. It covers how to create applications that target both Excel 2003 and previously versions and Excel 2007. We also discuss the major differences between the two operating systems.

Chapter 24 – Excel and VB.NET:
In the first part we introduce the IDE in detail and cover some basic VB.NET programming. In the second part of the chapter we discuss how to automate Excel with VB.NET.
The chapter present a practical case, PETRAS Report Tool.NET which is a standalone utility to retrieve data from PETRAS SQL Server database and populate some Excel reports templates.

Chapter 25 – Writing Managed COM Add-ins with VB.NET:
This chapter is the “flag ship” of the .NET section and goes in detail on how to create managed COM Add-ins and it also discuss in detail Automation Add-ins.
Here we also port the practical standalone utility, PETRAS Report Tool.NET. to a managed COM Add-in.

Chapter 26 – Developing Excel Solutions with Visual Studio Tools for Office System (VSTO):
In the first part of the chapter we set focus on two questions: What is VSTO and When to use VSTO. We also discuss VSTO add-ins, VSTO workbooks and how to deploy a VSTO workbook via the Web with the ClickOnce technology. To leverage the content in this chapter it requires that you have access to Excel 2007.

To buy the book or not?
If you have an interest in Excel and .NET including VSTO then you should consider buying the second edition. However, if your concern is native Excel and VBA then it is better that you save the money and wait until the next edition of the book is available.

If you want to buy or rank the book then please click here. 

PED’s site
With this edition we decided to build a completely new site for the book with Q&A forums. The intention with the site is to allow you to interact with the authors and leave suggestions for future editions of the book. The Q&A forums are built around the book’s content and they have a similar structure as the book’s TOC. In addition, it is here you will find information about updates and more downloads. 
We strongly encourage you to become a member and discuss the book in detail. Rob and I will try to answer all questions to the best of our knowledge. At the same time we feel it is important to state that the site is not a general Q&A forum about the involved technologies.

Together with the publisher we have made two chapters available for free download. To find out more please visit the PED’s site.

Let me know if you want any further information.

Kind regards,
Dennis

In my first post about Sheet Navigation I showed a basic approach. Here I will show a more practical and realistic solution to navigate between sheets. The example is based on a VSTO workbook however it can be applied to both native Excel solutions as well as managed COM/VSTO add-ins.

When it comes to customize the Ribbon UI with VBA and with VB.NET the major difference is the callbacks signatures. Because I constantly forget which signatures to be used depending on which language I use I check with the following article: Customizing the 2007 Office Fluent Ribbon for Developers (Part 3 of 3).

Anyway, in this example I use the dropDown control but the drawback with it is that it does not explicitly give us the name of the selected item, only its ID and index number. Therefore we need to resolve it in the code. 

Although we should strive to create fully dynamic applications, they come with the price of having to write code for all possible scenarios. In real-world applications we therefore tend to create semifixed applications where some parts of the solutions are fixed and some parts are dynamic. In the example here we have a fixed list of sheets whose names will not change during runtime and we therefore do not need to invalidate the dropDown control during runtime. On the other hand, we will not hard-code the sheets names in order to ease the maintenance.

The following screen shot shows the whole VSTO project: 

As we can see we have four worksheets and one chart. One of the worksheets, “Hidden”, is hidden which we also need to resolve in the code.

The following screen shot lists the Ribbon UI XML solution:

The next screen shot shows the relevant code in the ThisWorkbook module:

We grab the collection of sheets in the workbook in a sheet collection variable which we use in the callbacks signatures as the following screen shot shows:

It should be noted that I use Option Strict for the example solution, i.e. it forces us to cast.  When running it we can navigate between the sheets rather smooth as the following screen shot lists:

The example shows that we can rather easily create robust solutions to navigate between the sheets in a workbook. Compared with the basic approach the above solution gives the end users a better option as it shows the names of the sheets.

In the coming blogpost I will demonstrate how we can implement the Ribbon UI in Windows Forms.

Kind regards,
Dennis