As Facebook becomes more widely used by corporate users a.k.a older people like me, I thought it would be cool if I could link Facebook data into Outlook.  Originally I wanted to build something similar to the Plaxo Toolbar for Outlook to sync Facebook contact info with my Outlook contacts, but unfortunately  the Facebook API doesn't allow you to retrieve contact info. (If anyone from Facebook is reading this, contact info in the API would be awesome

So what does the Facebook Outlook Add-in do? Two things.  First, you can synchronize Facebook data available via the API like Favorite TV Shows, Movies, etc. to an Outlook contact by linking a contact with his/her Facebook ID (The ID appears in the url on profile pages i.e. http://www.facebook.com/profile.php?id=828485692).  After a contact is linked to his/her Facebook profile, profile data is then displayed on a custom region in the Outlook contact form (Figure 1).  The data is stored in a local SQL Server 2005 Compact Edition DB and periodically refreshed from Facebook.

Figure 1: Custom Contact Region

The second feature is RSS feed monitoring for articles that match interests of your Facebook friends.  For example, I subscribe to Pitchfork's record review and one of my friends on Facebook likes Iron & Wine.  If Pitchfork reviews a new Iron & Wine album, the add-in will flag the post for follow-up to notify me that my friend might be interested in that post.  A custom region on the RSS post displays which friends matched and why (Figure 2).  In a class I once attended on relationship management (business relationships and networking....not dating.  I think my girlfriend already manages me quite well), the speaker mentioned that it's important to keep relationships fresh.  If I see an article that is potentially interesting to one of my contacts, it's a good excuse to email them and keep the relationship current.  Normally I'd have to remember what everyone likes, but Facebook allows me to be lazy.

Figure 2: Custom RSS Post Region

Getting Started

If you'd like to follow along at home and debug the source code, you first need to install Microsoft SQL Server 2005 Compact Edition and the Microsoft Visual Studio 2005 Tools for the 2007 Microsoft Office System.  Also, when building Outlook add-ins, there are several registry entries that need to be created.  To debug the source code for this article you must run all of the .reg files in the "RegistryEntries" folder inside "src\FBOutlookCS" or "src\FBOutlookVB". 

If you just want to try out the add-in without messing around with the source code, first install Microsoft SQL Server 2005 Compact Edition then run "setup.exe" in the "install" folder from the downloaded code of this article.

Creating a Custom From Region in Outlook

I previously posted another add-in article on Coding4Fun, Collecting Outlook 2007 Statistics Using VSTO 2005 SE.  The steps I used to create this add-in are basically the same.  One difference this time was instead of adding registry entries to point to the custom region's manifest file, the registry entry just points to the actual add-in (Figure 3).  The add-in then dynamically loads the proper custom region from the project's resources based on the which form was requested.

Figure 3: Registry Settings

C#

   1: /// <summary>

   2: /// Implemented from the FormRegionStartup interface, GetFormRegionManifest is called when the

   3: /// Form Region manifest information is requested by Outlook.  This can happen from a number of

   4: /// trigger points in Outlook.  Once the manifest information is loaded, Outlook will not ask for 

   5: /// this information again during the same Outlook session.

   6: /// </summary>

   7: /// <param name="FormRegionName">Name of the form region, as provided by the registry key</param>

   8: /// <param name="LCID">Language ID for the Office UI language</param>

   9: /// <returns>A string value containing the XML contents of the form region manifest</returns>

  10: public object GetFormRegionManifest(string FormRegionName, int LCID)

  11: {

  12:     switch (FormRegionName)

  13:     {

  14:         case CONTACT_REGION:

  15:             return Properties.Resources.FacebookContactRegionManifest;

  16:  

  17:         case RSS_REGION:

  18:             return Properties.Resources.FacebookRSSRegionManifest;

  19:  

  20:         default:

  21:             return null;

  22:     }

  23: }

VB.NET

   1: Public Function GetFormRegionManifest(ByVal FormRegionName As String, ByVal LCID As Integer) As Object Implements Microsoft.Office.Interop.Outlook._FormRegionStartup.GetFormRegionManifest

   2:     Select Case FormRegionName

   3:         Case CONTACT_REGION

   4:             Return My.Resources.facebookcontactregionmanifest

   5:  

   6:         Case RSS_REGION

   7:             Return My.Resources.facebookrssregionmanifest

   8:  

   9:         Case Else

  10:             Return Nothing

  11:     End Select

  12: End Function

Synchronizing Data with Facebook

Facebook has a REST API for retrieving work & school history, photos, events and personal info (Basically everything except contact info).  When building your own Facebook application, you must first get an API key.  There are a variety of ways to call the Facebook web services.  You could use XSD, Linq, or the .NET Facebook Developer Toolkit.  I chose the Facebook Developer Toolkit which has a strongly typed object model for Facebook data, simplifies web service calls, handles authentication / session management and is a pleasure to use.  Plus I helped build the toolkit so I was looking for a chance to promote it 

After adding a reference to the toolkit, you can retrieve Facebook data and store it in a SQL Server Compact DB with just a few lines of code.

C#

   1: _fbService = new Facebook.Components.FacebookService();

   2: _fbService.ApplicationKey = APP_KEY;

   3: _fbService.Secret = SECRET;

   4:  

   5: Collection<Facebook.Entity.User> users = _fbService.GetUserInfo(facebookID);

   6:  

   7: FacebookDBDataSetTableAdapters.FacebookDataTableAdapter fbTA =

   8:     new FacebookDBDataSetTableAdapters.FacebookDataTableAdapter();

   9:  

  10: fbTA.Insert(facebookID, users[0].AboutMe,

  11:     users[0].Interests, users[0].Activities, users[0].Movies,

  12:     users[0].TVShows, users[0].Books, entryID);

VB.NET

   1: _fbService = New Facebook.Components.FacebookService()

   2: _fbService.ApplicationKey = API_KEY

   3: _fbService.Secret = SECRET

   4:  

   5: Dim users As Collection(Of Facebook.Entity.User) = 

   6:     _fbService.GetUserInfo(facebookID)

   7:  

   8: Dim fbTA As FacebookDBDataSetTableAdapters.FacebookDataTableAdapter = 

   9:     New FacebookDBDataSetTableAdapters.FacebookDataTableAdapter()

  10:  

  11: fbTA.Update(facebookID, users[0].AboutMe,

  12:     users[0].Interests, users[0].Activities, users[0].Movies,

  13:     users[0].TVShows, users[0].Books, entryID, entryID);

The table adapters used in the code above were generated from a dataset linked to the database.  The SQL Server Compact DB is a lightweight database that can be deployed in a single file.  The database doesn't run any services like SQL Express and is a svelte 35KB when empty.

Figure 4: Facebook Local DB Dataset

Based on a user configurable setting, the add-in will periodically synchronize all Facebook data for each contact.  The sync process is controlled through a timer and the actual synchronization runs asynchronously on a background thread to keep the Outlook UI responsive.  If the UI freezes, it's probably that other add-in you installed.

C#

   1: /// <summary>

   2: /// Begins the sync timer

   4: private void InitializeSyncTimer()

   5: {

   6:     _syncTimer = new Timer();

   7:     _syncTimer.Enabled = true;

   8:     _syncTimer.Interval = SyncIntervalInMiliseconds;

   9:     _syncTimer.Start();

  10: }

  11:  

  12: /// <summary>

  13: /// Event handler for the sync interval timer.  Starts the sync to facebook async

  14: /// </summary>

  15: /// <param name="sender"></param>

  16: /// <param name="e"></param>

  17: private void syncTimer_Tick(object sender, EventArgs e)

  18: {

  19:     StartBackgroundSync();

  20:     _syncTimer.Interval = SyncIntervalInMiliseconds;

  21: }

  22:  

  23: /// <summary>

  24: /// Starts an asynchronous sync of facebook friend data

  25: /// </summary>

  26: private void StartBackgroundSync()

  27: {

  28:     System.Threading.Thread syncThread = new System.Threading.Thread(new System.Threading.ThreadStart(SyncUsersWithFacebook));

  29:     syncThread.IsBackground = true;

  30:     syncThread.SetApartmentState(System.Threading.ApartmentState.STA);

  31:     syncThread.Start();

  32: }

  33:  

  34: /// <summary>

  35: /// Synchronizes facebook data of facebook friend data to the sql compact db

  36: /// </summary>

  37: private void SyncUsersWithFacebook()

  38: {

  39:     FBSync.Instance.SyncUsersWithFacebookAsync();

  40: }

VB.NET

   1: ''' <summary>

   2: ''' Begins the sync timer

   3: ''' </summary>

   4: Private Sub InitializeSyncTimer()

   5:     _syncTimer = New Timer()

   6:     _syncTimer.Enabled = True

   7:     _syncTimer.Interval = SyncIntervalInMiliseconds

   8:     _syncTimer.Start()

   9: End Sub

  10:  

  11: ''' <summary>

  12: ''' Event handler for the sync interval timer.  Starts the sync to facebook async

  13: ''' </summary>

  14: ''' <param name="sender"></param>

  15: ''' <param name="e"></param>

  16: Private Sub syncTimer_Tick(ByVal sender As Object, ByVal e As EventArgs)

  17:     StartBackgroundSync()

  18:     _syncTimer.Interval = SyncIntervalInMiliseconds

  19: End Sub

  20:  

  21: ''' <summary>

  22: ''' Starts an asynchronous sync of facebook friend data

  23: ''' </summary>

  24: Private Sub StartBackgroundSync()

  25:     Dim syncThread As System.Threading.Thread = New System.Threading.Thread(New System.Threading.ThreadStart(AddressOf SyncUsersWithFacebook))

  26:     syncThread.IsBackground = True

  27:     syncThread.SetApartmentState(System.Threading.ApartmentState.STA)

  28:     syncThread.Start()

  29: End Sub

  30:  

  31: ''' <summary>

  32: ''' Synchronizes facebook data of facebook friend data to the sql compact db

  33: ''' </summary>

  34: Private Sub SyncUsersWithFacebook()

  35:     FBSync.Instance.SyncUsersWithFacebookAsync()

  36: End Sub

  37:  

Searching Posts for Keywords

To monitor incoming RSS posts first you need to wire up the ItemAdd events on each sub-folder of the RSS feeds folder in Outlook.  There are thousands more events that you can handle in addition to ItemAdd.  My goal is to keep writing Coding4Fun articles until I use them all. 

You also need to wire up an event for adding sub-folders to the RSS feed folder (so you can dynamically add more event handlers for the previously mentioned ItemAdd events)  That way if a new feed is added to Outlook, the add-in will know to monitor it.  A code snippet might illustrate better what is happening.

C#

   1: /// <summary>

   2: private Outlook.MAPIFolder _rssFeedRootFolder;

   3: private Outlook.Folders _rssFeedFolders;

   4:  

   5: _rssFeedFolders.FolderAdd +=

   6:     new Microsoft.Office.Interop.Outlook.FoldersEvents_FolderAddEventHandler(_rssFeedFolders_FolderAdd);

   7:  

   8: foreach (Outlook.Folder rssFolder in _rssFeedFolders)

   9: {

  10:     AddRSSFolderHandlers(rssFolder.Items);

  11: }

  12:  

  13: /// Add a handler to a RSS folder to watch incoming posts

  14: /// </summary>

  15: /// <param name="items"></param>

  16: private void AddRSSFolderHandlers(Outlook.Items items)

  17: {

  18:     _rssFolderItems.Add(items);

  19:     _rssFolderItems[_rssFolderItems.Count - 1].ItemAdd +=

  20:         new Microsoft.Office.Interop.Outlook.ItemsEvents_ItemAddEventHandler(Items_ItemAdd);

  21:     _rssFolderItems[_rssFolderItems.Count - 1].ItemRemove +=

  22:         new Microsoft.Office.Interop.Outlook.ItemsEvents_ItemRemoveEventHandler(Items_ItemRemove);

  23: }

  24:  

  25: void _rssFeedFolders_FolderAdd(Microsoft.Office.Interop.Outlook.MAPIFolder Folder)

  26: {

  27:     AddRSSFolderHandlers(Folder.Items);

  28: }

VB.NET

   1: Private _rssFeedRootFolder As Outlook.MAPIFolder

   2: Private _rssFeedFolders As Outlook.Folders

   3:  

   4: AddHandler _rssFeedFolders.FolderAdd, AddressOf _rssFeedFolders_FolderAdd

   5:  

   6: For Each rssFolder As Outlook.Folder In _rssFeedFolders

   7:     AddRSSFolderHandlers(rssFolder.Items)

   8: Next rssFolder

   9:  

  10: Private Sub _rssFeedFolders_FolderAdd(ByVal Folder As Microsoft.Office.Interop.Outlook.MAPIFolder)

  11:     AddRSSFolderHandlers(Folder.Items)

  12: End Sub

  13:  

  14: ''' <summary>

  15: ''' Add a handler to a RSS folder to watch incoming posts

  16: ''' </summary>

  17: ''' <param name="items"></param>

  18: Private Sub AddRSSFolderHandlers(ByVal items As Outlook.Items)

  19:     _rssFolderItems.Add(items)

  20:     AddHandler _rssFolderItems(_rssFolderItems.Count - 1).ItemAdd, AddressOf Items_ItemAdd

  21:     AddHandler _rssFolderItems(_rssFolderItems.Count - 1).ItemRemove, AddressOf Items_ItemRemove

  22: End Sub

When a new RSS post comes into Outlook, the ItemAdd event fires and the add-in launches a search of the post on a background thread.  Searching of a post involves looping through each stored Facebook profile and tokenizing the personal info fields into keywords based on commas.  As your list of friend's grows, there might be a more a efficient way of storing keywords and searching posts.  I'm shy so I only have a handful of friends on Facebook. 

Another feature is the ability to exclude certain keywords (Figure 5).  Suppose someone likes the rapper "Common", but that word might appear in unrelated posts.  In the add-in settings you can add words to an exclusion list to prevent false matches.  Obviously the searching function is pretty simple, but it works for the purposes of this sample.

Figure 5: Add-in Settings

Below are some snippets of code for searching incoming posts.

C#

   1: void Items_ItemAdd(object Item)

   2: {

   3:     Outlook.PostItem post = Item as Outlook.PostItem;

   4:  

   5:     if (post != null)

   6:     {

   7:         System.Threading.Thread syncThread = new System.Threading.Thread(new System.Threading.ParameterizedThreadStart(SearchPostAsync));

   8:         syncThread.IsBackground = true;

   9:         syncThread.SetApartmentState(System.Threading.ApartmentState.STA);

  10:         syncThread.Start(post);

  11:     }

  12: }

  13:  

  14: /// <summary>

  15: /// Begins async search of an incoming post

  16: /// </summary>

  17: /// <param name="item"></param>

  18: private void SearchPostAsync(object item)

  19: {

  20:     Outlook.PostItem post = item as Outlook.PostItem;

  21:  

  22:     if (post != null)

  23:     {

  24:         PostSearcher ps = new PostSearcher();

  25:         ps.SearchPost(post, _contacts);

  26:     }

  27: }

  28:  

  29: public void SearchPost(Outlook.PostItem postItem, Outlook.Items contacts)

  30: {

  31:  

  32:    FacebookDBDataSetTableAdapters.FacebookDataTableAdapter fdTA = 

  33:        new FacebookDBDataSetTableAdapters.FacebookDataTableAdapter();

  34:  

  35:    FacebookDBDataSet.FacebookDataDataTable fdDT = fdTA.GetData();

  36:  

  37:    List<string> entryIDs = new List<string>();

  38:    string keyword = string.Empty;

  39:  

  40:    //look through each facebook friend associated with an outlook contact

  41:    //and search the incoming post to match keywords

  42:    foreach (FacebookDBDataSet.FacebookDataRow row in fdDT.Rows)

  43:    {

  44:        if (IsKeywordFound(row.FavoriteTVShows, postItem, out keyword))

  45:        {

  46:            entryIDs.Add(row.EntryID);

  47:  

  48:  

  49:            continue;

  50:        }

  51:     //more code

  52:     }

  53:  

  54:     //more code

  55: }

  56:  

  57: private bool IsKeywordFound(string keywords, Outlook.PostItem postItem, out string matchedKeyword)

  58: {

  59:     bool isFound = false;

  60:     matchedKeyword = string.Empty;

  61:  

  62:     if (!String.IsNullOrEmpty(keywords))

  63:     {

  64:         string[] keywordList = keywords.Split(',');

  65:  

  66:         //take the tokenized facebook data and search the post for matching keywords

  67:         //not the most sophisticated search, can be improved in later versions

  68:         foreach (string keyword in keywordList)

  69:         {

  70:             string keywordSearch = keyword.ToUpperInvariant().Trim();

  71:             if (postItem.Body.ToUpperInvariant().Contains(keywordSearch) || postItem.Subject.ToUpperInvariant().Contains(keywordSearch))

  72:             {

  73:                 //exclude and keywords that the user has added to the settings screen to exclude

  74:                 if (!Properties.Settings.Default.ExcludeList.ToUpperInvariant().Contains(keywordSearch))

  75:                 {

  76:                     isFound = true;

  77:                     matchedKeyword = keyword;

  78:                     break;

  79:                 }

  80:             }

  81:         }

  82:     }

  83:  

  84:     return isFound;

  85: }

VB.NET

   1: Private Sub Items_ItemAdd(ByVal Item As Object)

   2:     Dim post As Outlook.PostItem = TryCast(Item, Outlook.PostItem)

   3:  

   4:     If Not post Is Nothing Then

   5:         Dim syncThread As System.Threading.Thread = New System.Threading.Thread(New System.Threading.ParameterizedThreadStart(AddressOf SearchPostAsync))

   6:         syncThread.IsBackground = True

   7:         syncThread.SetApartmentState(System.Threading.ApartmentState.STA)

   8:         syncThread.Start(post)

   9:     End If

  10: End Sub

  11:  

  12: ''' <summary>

  13: ''' Begins async search of an incoming post

  14: ''' </summary>

  15: ''' <param name="item"></param>

  16: Private Sub SearchPostAsync(ByVal item As Object)

  17:     Dim post As Outlook.PostItem = TryCast(item, Outlook.PostItem)

  18:  

  19:     If Not post Is Nothing Then

  20:         Dim ps As PostSearcher = New PostSearcher()

  21:         ps.SearchPost(post, _contacts)

  22:     End If

  23: End Sub

  24:  

  25: Public Sub SearchPost(ByVal postItem As Outlook.PostItem, ByVal contacts As Outlook.Items)

  26:  

  27:     Dim fdTA As FacebookDBDataSetTableAdapters.FacebookDataTableAdapter = 

  28:         New FacebookDBDataSetTableAdapters.FacebookDataTableAdapter()

  29:  

  30:     Dim fdDT As FacebookDBDataSet.FacebookDataDataTable = fdTA.GetData()

  31:  

  32:     Dim entryIDs As List(Of String) = New List(Of String)()

  33:     Dim keyword As String = String.Empty

  34:  

  35:     'look through each facebook friend associated with an outlook contact

  36:     'and search the incoming post to match keywords

  37:     For Each row As FacebookDBDataSet.FacebookDataRow In fdDT.Rows

  38:         If IsKeywordFound(row.FavoriteTVShows, postItem, keyword) Then

  39:             entryIDs.Add(row.EntryID)

  40:  

  41:             Continue For

  42:         End If

  43:         'more code.....

  44:     Next row

  45:  

  46: 'more code.....

  47: End Sub

  48:  

  49: ''' <summary>

  50: ''' search the post for a keyword string

  51: ''' </summary>

  52: ''' <param name="keywords"></param>

  53: ''' <param name="postItem"></param>

  54: ''' <param name="matchedKeyword"></param>

  55: ''' <returns></returns>

  56: Private Function IsKeywordFound(ByVal keywords As String, ByVal postItem As Outlook.PostItem, <System.Runtime.InteropServices.Out()> ByRef matchedKeyword As String) As Boolean

  57:     Dim isFound As Boolean = False

  58:     matchedKeyword = String.Empty

  59:  

  60:     If (Not String.IsNullOrEmpty(keywords)) Then

  61:         Dim keywordList As String() = keywords.Split(","c)

  62:  

  63:         'take the tokenized facebook data and search the post for matching keywords

  64:         'not the most sophisticated search, can be improved in later versions

  65:         For Each keyword As String In keywordList

  66:             Dim keywordSearch As String = keyword.ToUpperInvariant().Trim()

  67:             If postItem.Body.ToUpperInvariant().Contains(keywordSearch) OrElse postItem.Subject.ToUpperInvariant().Contains(keywordSearch) Then

  68:                 'exclude and keywords that the user has added to the settings screen to exclude

  69:                 If (Not My.Settings.ExcludeList.ToUpperInvariant().Contains(keywordSearch)) Then

  70:                     isFound = True

  71:                     matchedKeyword = keyword

  72:                     Exit For

  73:                 End If

  74:             End If

  75:         Next keyword

  76:     End If

  77:  

  78:     Return isFound

  79: End Function

Creating the Installer

When you create a new Outlook Add-in project, Visual Studio creates a setup project along with it.  The default setup project needs a little tweaking before you can distribute to your friends to install. Chris Castillo wrote an excellent post on building setup projects for office add-ins.  A few minor challenges are granting full trust, installing / checking additional prerequisites like VSTO 2005 SE for Office 2007 / PIAs and creating the right registry entries.  If something doesn't work with the installer in this project, I blame him  

Conclusion

The add-in for this article is just one example of the fun things you can do with some of the API blocks that are being created by the Visual Studio Express team and others.  The Facebook toolkit in particular can be used to create applications within Facebook on the web or in stand-alone desktop applications like this add-in.  I plan on adding this code into the Facebook Developer Toolkit project on CodePlex as a sample at some point so anyone can help expand this add-in.  Some future things I think would be cool to add are photo album exporting, more sophisticated keyword searching, syncing of contact info and email synchronization.  Some of those are dependent on the API changing and may not be possible.

If you'd like to contact me, feel free to send me a message or add me as a friend on Facebook.

Outlook is used by many people everyday, but few people probably realize the wealth of data that can be learned from how they use Outlook. How long does it take you to respond to emails on average? How many hours do you spend in meetings per week? Using Visual Studio Tools for Office Second Edition (VSTO 2005 SE) and Office 2007, you can easily find the answers to these questions and more by building an add-in for Outlook. This article demonstrates how you can listen to outlook events, store data about outlook usage, and produce reports on that usage in a custom form and new to VSTO 2005 SE, a form region.

What is VSTO 2005 SE?

VSTO 2005 SE is a free add-on to Visual Studio 2005 that enables developers to build applications targeting the 2007 Office system. Developers can create Office-based solutions using the professional development environment of Visual Studio 2005 and the new programming model features of Office 2007 like the ribbon bar and custom form regions.

Creating an Outlook Add-in Project

After installing VSTO 2005 SE and the Outlook Add-in template, you can begin creating an Outlook 2007 add-in. Create a new project, then select Office Outlook 2007 Add-in from the My Templates group and click OK.

The newly created project will have several files. Connect.cs is the main file which contains two methods, InitializeAddin and ShutdownAddin which provide you a starting point for interfacing with Outlook.

Initializing the Add-in

The InitializeAddin method is called whenever your add-in is loaded into memory. For our add-in, we will do three things during start up:

• Create an instance of our EventTracker class. This is the main class that handles all of the logic for processing incoming appointment and mail items.
• Load existing Outlook data via the EventTracker.
• Add a menu item to the Outlook toolbar. The menu item is used to pop up the report window.

 Visual C#

private void InitalizeAddin()
{
   //Initialize report menu item
   this.InitializeMenu();

   // Initialize the event tracker object.
   _eventTracker = new EventTracker(this.Application);

   ListenToEvents(true);

   _eventTracker.LoadData();
}

 Visual Basic

Private Sub InitalizeAddin()

    '//Initialize report menu item
   InitializeMenu()

    '// Initialize the event tracker object.
   _eventTracker = New EventTracker(Me.Application)

    ListenToEvents(True)

   _eventTracker.LoadData()
End Sub

Top-level menu items can be created the same way in office application. For this add-in, we'll create a new menu “Reports”, with a single menu item to launch the report popup window.

Visual C#

// Get the Outlook menu bar.
_menuBar = this.Application.ActiveExplorer().CommandBars.ActiveMenuBar;

// Get the index of the Help menu item on the Outlook menu bar.
_helpMenuIndex = _menuBar.Controls[_MENU_BEFORE].Index;
// Add the top-level menu right before the Help menu.
_topMenu = 

(Office.CommandBarPopup)_menuBar.Controls.Add(Office.MsoControlType.msoControlPopup,
   Type.Missing, Type.Missing, _helpMenuIndex, true);

_topMenu.Caption = "Reports";
_topMenu.Visible = true;

// Add the menu item for loading email reports.
_reports = 

   (Office.CommandBarButton)_topMenu.Controls.Add(Office.MsoControlType.msoControlButton, 

   Type.Missing, Type.Missing, Type.Missing, true);                                                                                   Type.Missing,                                                                                 Type.Missing,                                                                                   Type.Missing,                                                                                    true);

_reports.Caption = "Calendar / Email Reports";
_reports.Visible = true;

Visual Basic

 '// Get the Outlook menu bar.
 _menuBar = Me.Application.ActiveExplorer().CommandBars.ActiveMenuBar

 '// Get the index of the Help menu item on the Outlook menu bar.
_helpMenuIndex = _menuBar.Controls(_MENU_BEFORE).Index

 '// Add the top-level menu right before the Help menu.
_topMenu = 

   CType(_menuBar.Controls.Add(Office.MsoControlType.msoControlPopup, _
      Type.Missing, Type.Missing, _helpMenuIndex, True), Office.CommandBarPopup)

 _topMenu.Caption = "Reports"
 _topMenu.Visible = True

 ' Add the menu item for loading email reports.
_reports = _topMenu.Controls.Add(Office.MsoControlType.msoControlButton, _
         Type.Missing, Type.Missing, Type.Missing, True)
 _reports.Caption = "Calendar / Email Reports"
 _reports.Visible = True

Loading Statistics Based on Existing Outlook Data

Data to produce reports on Outlook usage is stored in a SQL Express database. When the add-in first loads, it needs to scan the mail and calendar folders to gather statistics on existing items. The EventTracker class handles the initial data load, as well as hooking events fired when new items are added to those folders.

The schema for the database has tables for storing information about the three types of items we are reporting statistics: inbox items, sent mail items, and appointment items.

Since scanning through the folders can take some time if you are like me and keep every email ever received, it's best to start the initial data load on a separate thread. Now Outlook can continue responding to user input, while the add-in does its work.

Visual C#

public void LoadData()
{
   //create new thread for large inboxes
   Thread thread = new Thread(new ThreadStart(CheckInitialLoad));
   thread.IsBackground = true;
   thread.Start();
}

Visual Basic

Public Sub LoadData()
   Dim thread As Thread = New Thread(AddressOf CheckInitialLoad)
   thread.IsBackground = True
   thread.Start()
End Sub

The initial data load raises an to notify other code, like the report popup form, that the data isn't ready to produce reports yet. If the database doesn't contain any exisitng data, then the data load will add records for each exisiting item. Allowing the thread to sleep briefly between iterations prevents the data load from interfering with the responsiveness of the main Outlook thread.

Visual C#

private void CheckInitialLoad()
{
   if (!object.Equals(StartDataLoad,null))
   {
      StartDataLoad(this, null);
   }

ReportDBDataSetTableAdapters.SentMailTableAdapter sentItemTA = 

   new ReportDBDataSetTableAdapters.SentMailTableAdapter();
ReportDBDataSetTableAdapters.InboxTableAdapter inboxTA = 

   new ReportDBDataSetTableAdapters.InboxTableAdapter();
ReportDBDataSetTableAdapters.CalendarTableAdapter calTA = 

   new ReportDBDataSetTableAdapters.CalendarTableAdapter();

   //check to see if calendar stats have been loaded
   if (calTA.GetData().Rows.Count == 0)
   {
      foreach (object item in _calendarItems)
      {
         if (item is Outlook.AppointmentItem)
         {
            AddCalendarItem(item as Outlook.AppointmentItem);
         }
         Thread.Sleep(10);
      }
   }
   if (!object.Equals(StopDataLoad, null))
   {
      StopDataLoad(this, null);
   }
}

Visual Basic

 Private Sub CheckInitialLoad()

   RaiseEvent StartDataLoad(Me, Nothing)

   Dim sentItemTA As ReportDBDataSetTableAdapters.SentMailTableAdapter = _

      New ReportDBDataSetTableAdapters.SentMailTableAdapter
   Dim inboxTA As ReportDBDataSetTableAdapters.InboxTableAdapter = _

      New ReportDBDataSetTableAdapters.InboxTableAdapter
   Dim calTA As ReportDBDataSetTableAdapters.CalendarTableAdapter = _

      New ReportDBDataSetTableAdapters.CalendarTableAdapter

   If calTA.GetData.Rows.Count = 0 Then
      For Each item As Object In _calendarItems
         If TypeOf item Is Outlook.AppointmentItem Then
            AddCalendarItem(CType(item, Outlook.AppointmentItem))
         End If
         Thread.Sleep(10)
      Next
   End If
   If inboxTA.GetData.Rows.Count = 0 Then
       For Each item As Object In _inboxItems
          If TypeOf item Is Outlook.MailItem Then
             AddInboxItem(CType(item, Outlook.MailItem))
          End If
          Thread.Sleep(10)
        Next
    End If
    If sentItemTA.GetData.Rows.Count = 0 Then
       For Each item As Object In _sentMailItems
          If TypeOf item Is Outlook.MailItem Then
             AddSentMailItem(CType(item, Outlook.MailItem))
          End If
      Thread.Sleep(10)
      Next
   End If

   RaiseEvent StopDataLoad(Me, Nothing)

End Sub

By listening to the StartDataLoad and StopDataLoad events, we can display a message to the user if they try to load a report.

Visual C#

if (_isDataLoading)
{
MessageBox.Show("Outlook is currently initializing your folders to 

   enable reporting for the first time.  Try again in a few minutes.", 
   "Loading initial data", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}

Visual Basic

If (_isDataLoading) Then

MessageBox.Show("Outlook is currently initializing your folders to enable reporting for the first time.  Try again in a few minutes.", "Loading initial data", MessageBoxButtons.OK, MessageBoxIcon.Warning)

Listening for New Items

After the initial data load, the add-in can just listen for incoming items to keep track of Outlook usage. To listen for incoming items, you can use folder events. To hook into folder events you first need to obtain a reference to an Outlook.MAPIFolder object that encapsulates an Outlook folder like Inbox, Sent Mail, or Calendar. In order to get the default Outbox folder call the GetDefaultFolder method of the MAPI namespace object. Then you need to add handlers for the ItemAdd event of the Outlook folders. The following code shows how to listen for incoming mail items in the Inbox folder.

Visual C#

// Obtain references to the folder objects that fire the events we are interested in.
Outlook.MAPIFolder inbox = 

   app.Session.GetDefaultFolder(Outlook.OlDefaultFolders.olFolderInbox);
// Store references to the item collection objects.
_inboxItems = inbox.Items;
_inboxItems.ItemAdd += new Outlook.ItemsEvents_ItemAddEventHandler(InboxFolderItemAdded)

/// <summary>
/// Handles new mail items added to the inbox
/// </summary>
/// <param name="Item">Reference to the Outlook object added</param>
private void InboxFolderItemAdded(object Item)
{
   if (Item is Outlook.MailItem)
   {
      AddInboxItem(Item as Outlook.MailItem);
   }
}

Visual Basic

Dim inbox As Outlook.MAPIFolder = _

   app.Session.GetDefaultFolder(Outlook.OlDefaultFolders.olFolderInbox)
_inboxItems = inbox.Items
AddHandler _inboxItems.ItemAdd, AddressOf InboxFolderItemAdded

Private Sub InboxFolderItemAdded(ByVal Item As Object)
   If TypeOf Item Is Outlook.MailItem Then
      AddInboxItem(CType(Item, Outlook.MailItem))
   End If
End Sub

Appointments and sent mail items can be tracked in a similar manner. Additionally, the Outlook folders support events for removing or changing items.

Items can easily be stored in the database by using table adapters automatically generated from the dataset. Each item has a table adapter which corresponds to a table in the database.

Visual C#

/// <summary>
/// Stores a new message in the database
/// </summary>
/// <param name="mailItem"></param>
private void AddInboxItem(Outlook.MailItem mailItem)
{
ReportDBDataSetTableAdapters.InboxTableAdapter ta = 

   new ReportDBDataSetTableAdapters.InboxTableAdapter();

   //determine if mail was sent to an alias or group address
   bool isAliased = true;
   if (mailItem.To == mailItem.ReceivedOnBehalfOfName || mailItem.CC == mailItem.ReceivedOnBehalfOfName)
   {
      isAliased = false;
   }
   try
   {
      ta.Insert(mailItem.SenderName, 

      mailItem.SenderName, mailItem.SentOn, isAliased, null, 

      mailItem.Subject, mailItem.EntryID);
   }
   catch (Exception ex)
   {
      System.Diagnostics.Debug.Write(ex);
   }
}

Visual Basic

Private Sub AddInboxItem(ByVal mailItem As Outlook.MailItem)
   Dim ta As ReportDBDataSetTableAdapters.InboxTableAdapter = New ReportDBDataSetTableAdapters.InboxTableAdapter
   Dim isAliased As Boolean = True
   If mailItem.To = mailItem.ReceivedOnBehalfOfName OrElse mailItem.CC = mailItem.ReceivedOnBehalfOfName Then
                isAliased = False
   End If
   Try
      ta.Insert(mailItem.SenderName, mailItem.SenderName, mailItem.SentOn, isAliased, Nothing, mailItem.Subject, mailItem.EntryID)
   Catch ex As Exception
      System.Diagnostics.Debug.Write(ex)
   End Try
End Sub

Producing the Reports

Now that we a have some data points about our Outlook usage, we can produce reports. The reports are displayed in a datagrid on a form that is launched from the Reports menu. The report popup dialog contains a selector for various report types and a selectable date range.

Each report is populated using a method from our table adapters. For example, to get a count of emails sent over a given period, you can use the following code:

Visual C#

this.inboxTableAdapter.CountEmailsRecieved(this.reportDBDataSet.Inbox, fromDate, toDate);
this.dataGridView1.Columns.Add("Emails Recieved", "Emails Received");
this.dataGridView1.Columns["Emails Recieved"].DataPropertyName = "Emails Recieved";
this.reportDBDataSetBindingSource.DataSource = this.reportDBDataSet.Inbox;

Visual Basic

Me.InboxTableAdapter.CountEmailsRecieved(Me.ReportDBDataSet.Inbox, fromDate, toDate)
Me.dataGridView1.Columns.Add("Emails Recieved", "Emails Received")
Me.dataGridView1.Columns("Emails Recieved").DataPropertyName = "Emails Recieved"
Me.reportDBDataSetBindingSource.DataSource = Me.ReportDBDataSet.Inbox

Creating a Form Region

Another way you can display data about Outlook usage is a form region. Form regions can be added to any existing Outlook form. You can also control whether the region is shown in the preview pane, the inspector, or on new items. For this add-in, we'll add a form region on email messages to show statistics about the recipient / sender.

The first step in creating a new form region is to customize an existing Outlook form. In Outlook, click Tools -> Forms -> Design a Form. Then select Message from the standard forms library. The Outlook form will appear in the design view. On the ribbon bar, select the button for creating a new form region.

On the form, add a new textbox control. You can't use the regular Outlook textbox though. Right-click the Toolbox window and select Custom Controls. Scroll through the list of controls and select the Microsoft Office Outlook TextBox Control, and then click OK.

Add the textbox to the form to display the Outlook statistics.

Now you can save the form region as an .ofs file and add it to the project as a resource file. In order to connect the form region with our add-in, we need to create a region manifest file and a registry entry. The region manifest is an xml file that defines how Outlook displays the region.

<?xml version="1.0" encoding="utf-8" ?>
<FormRegion xmlns="http://schemas.microsoft.com/office/12/outlook/formregion.xsd">
  <name>OutlookStatsRegionCS</name>
  <formRegionType>adjoining</formRegionType>
  <title>Outlook Statistics</title>
  <showInspectorRead>true</showInspectorRead>
  <showReadingPane>true</showReadingPane>
  <showInspectorCompose>false</showInspectorCompose>
  <addin>OutlookStatsCS.Connect</addin>
</FormRegion>

The documentation for the XML Schema for form regions is located here. Since the form for composing new mail item shouldn't have usage statistics at the bottom, set the showInspectorCompose property to false.

To associate the region manifest with Outlook, you need to create a new registry key under HKEY_CURRENT_USER\Software\Microsoft\Office\Outlook\FormRegions\IPM.Note called OutlookStatsRegionCS. The value of the key should be the path to the region manifest XML file. A sample registry file is included in the project's \Registry folder in the region_registry.reg file.

Wiring the Region to the Outlook Add-in

Because form regions are based on the Microsoft Forms 2.0 types, you need to add a reference in the add-in project to Microsoft Forms 2.0 Object Library. Now you can add a new class to manage that form region, called OutlookStatsRegion.cs.

The constructor for this class needs a reference to the instance of the form region.

Visual C#

public OutlookStatsRegion(Outlook.FormRegion region)
{
   _region = region;
   _region.Close += new Outlook.FormRegionEvents_CloseEventHandler(Region_Close);

   _form = region.Form as Forms.UserForm;

   _txtStats = (Outlook.OlkTextBox)_form.Controls.Item("txtStats");
   _txtStats.Text = GetEmailStatistics(region.Item);
}

Visual Basic

Public Sub New(ByVal [region] As Outlook.FormRegion)
   _region = [region]
   AddHandler _region.Close, AddressOf Region_Close

   _form = CType([region].Form, Forms.UserForm)

   _txtStats = CType(_form.Controls.Item("txtStats"), Outlook.OlkTextBox)
   _txtStats.Text = GetEmailStatistics([region].Item)
End Sub 'New

Using the reference to the region, we can get access to the mail item, and therefore the sender name and email address need to display the statistics.

Visual C#

private string GetEmailStatistics(object Item)
{
   string result = string.Empty;

   if (Item is Outlook.MailItem)
   {
      Outlook.MailItem mailItem = Item as Outlook.MailItem;

ReportDBDataSetTableAdapters.InboxTableAdapter inboxTA = new ReportDBDataSetTableAdapters.InboxTableAdapter();

      int? countEmailsReceived = inboxTA.CountEmailsReceivedFrom(mailItem.SenderName);
                
      sb.Append("Emails received from ");
      sb.Append(mailItem.SenderName);
      sb.Append(": ");
      sb.Append(countEmailsReceived.Value.ToString());
      sb.Append("  [");
      sb.Append(percentTotalReceived);
      sb.AppendLine("% of total received]");

      result = sb.ToString();
   }

   return result;
}

Visual Basic

Private Function GetEmailStatistics(ByVal Item As Object) As String
   Dim result As String = String.Empty

   If TypeOf Item Is Outlook.MailItem Then
      Dim mailItem As Outlook.MailItem = CType(Item, Outlook.MailItem)
      Dim inboxTA As New ReportDBDataSetTableAdapters.InboxTableAdapter()
      Dim inbox As New ReportDBDataSet.InboxDataTable()
      Dim countEmailsReceived As Nullable(Of Integer) = _

         inboxTA.CountEmailsReceivedFrom(mailItem.SenderName)

      sb.Append("Emails received from ")
      sb.Append(mailItem.SenderName)
      sb.Append(": ")
      sb.Append(countEmailsReceived.Value.ToString())
      sb.Append("  [")
      sb.Append(percentTotalReceived)

      result = sb.ToString()
   End If

    Return result
End Function 'GetEmailStatistics

Almost there. Next we have to modify the Connect class to implement the form region interface.

Visual C#

public partial class Connect : Outlook.FormRegionStartup

Visual Basic

Partial Public Class Connect
   Implements Outlook.FormRegionStartup

The two methods defined in this interface are called as Outlook loads an item and prepares to show a form. When Outlook starts to load the user interface for a message class that has a form region registered, it first calls the GetFormRegionStorage method to load the layout information for the form region. GetFormRegionStorage should return either a string (which is the path to the .ofs file), an IStorage instance for the contents of the .ofs file, or a byte array that contains the contents of the .ofs file. Before Outlook displays the form region to the user, it calls the BeforeFormRegionShow method, and passes a reference to the form region object.

Visual C#

public object GetFormRegionStorage(string FormRegionName, object Item,
   int LCID, Outlook.OlFormRegionMode FormRegionMode,
   Outlook.OlFormRegionSize FormRegionSize)
{
   if (FormRegionName == "OutlookStatsRegionCS")
   {
      // Return the storage only when there are headers
      return Properties.Resources.OutlookStatsRegionCS;
   }

   return null;
}

public void BeforeFormRegionShow(Outlook.FormRegion FormRegion)
{
   if (FormRegion.InternalName == "OutlookStatsRegionCS")
   {
      OutlookStatsRegion newRegion = new OutlookStatsRegion(FormRegion);
      newRegion.Closed += new EventHandler(Region_Closed);

      _openRegions.Add(newRegion);
   }
}

Visual Basic

Public Sub BeforeFormRegionShow(ByVal FormRegion As Microsoft.Office.Interop.Outlook.FormRegion) Implements Microsoft.Office.Interop.Outlook._FormRegionStartup.BeforeFormRegionShow
   If FormRegion.InternalName = "OutlookStatsRegionVB" Then
      Dim newRegion As New OutlookStatsRegion(FormRegion)
      AddHandler newRegion.Closed, AddressOf Region_Closed

      _openRegions.Add(newRegion)

   End If
End Sub

Public Function GetFormRegionStorage(ByVal FormRegionName As String, _

   ByVal Item As Object, ByVal LCID As Integer, _

   ByVal FormRegionMode As Microsoft.Office.Interop.Outlook.OlFormRegionMode, _

   ByVal FormRegionSize As Microsoft.Office.Interop.Outlook.OlFormRegionSize) As Object Implements Microsoft.Office.Interop.Outlook._FormRegionStartup.GetFormRegionStorage

   If FormRegionName = "OutlookStatsRegionVB" Then
      Return My.Resources.OutlookStatsRegionVB
   End If

   Return Nothing
End Function

The last step is to register the add-in with Outlook. The add-in template provided with this article automatically generates a .reg file with the necessary settings to register the COM add-in created by the project with Outlook. Double click the .reg in Windows Explorer to register the add-in. Now you can change the debug properties of the project to start Outlook when debugging by setting the Start Action to Start External Program and then browse to the path of Outlook 2007.

Conclusion

As you can see, VSTO 2005 SE allows developers a powerful tool for customizing Office 2007. New features in VSTO 2005 SE such as the Ribbon bar and custom form regions allow for even better integration than previous versions of VSTO. Outlook events made it possible for us to calculate statistics about email and calendar usage. In addition to the reports included in this add-in there is room for future additions. Some possibilities are:

• Adding a custom region on contacts to show amount of time spent in meetings with a particular person
• Tracking the amount of time spent reading / composing emails
• Tracking the amount spent on tasks or the percentage of tasks completed on time

Because we're competitive software developers, we started recording the games in an Excel spreadsheet to track stats. While arguing whether I had lost my last four games or my last five games, I realized there had to be a better way. And so the inspiration for the .NET foosball tracker was born. In this article, I'm going to cover a few ways to harness the power of Visual Studio 2005, SQL Server 2005, and a free foosball table to create the ultimate break room accessory.

Hacking the Table

The first step in building the foosball scoreboard application was to wire the table to a spare computer via the I-Pac, a PC interface for arcade buttons purchased from Ultimarc. Using what little carpentry skills were available in our software development consultancy office, we drilled several holes in the table to mount the buttons. The I-Pac translates button presses into keystrokes. Each player has a button to select his or her account at the beginning of a game (we have a very competitive woman's division) or to signal that he or she scored a goal. Three other buttons were added for game setup and other special features. We used the KeyUp event, so the Visual Basic .NET scoreboard WinForm application could respond to any of the button presses. It's not the most exciting code, but hey, this is just the beginning of the article.

Visual Basic

Private Sub KeyPressed(ByVal sender As System.Object,_
   ByVal e As System.Windows.Forms.KeyEventArgs) Handles MyBase.KeyUp

        Select Case (e.KeyValue)
            Case Windows.Forms.Keys.V
                'Home Offense Button
                If _gameMode = GameModeList.ChoosePlayers Then
                    homeOffense.ChangePlayer()
                ElseIf _gameMode = GameModeList.InGame Then
                    AddGoal(PlayerList.HomeOffense)
                End If
            Case Windows.Forms.Keys.X
                If _gameMode = GameModeList.InGame Then
                    'InstantReplay
                    _instanyReplay.ShowReplay()
                Else
                    StartScreenSaver()
                End If
            Case Windows.Forms.Keys.Menu
                'Undo Button
                If _gameMode = GameModeList.InGame Then
                    RemoveLastGoal()
                End If
        End Select

Figure 1. Foosball Table

Designing the Scoreboard

Lucky for us, our break room contains a 30-inch TV with VGA inputs near the foosball table to display the scoreboard application. The scoreboard consists of a form with several picture boxes and labels with transparent backgrounds on a foosball background image. Each set of player names and icons is a user control that tracks information such number of goals scored. Using the new table adapters in Visual Studio 2005, it's easy to bind the controls to a data table. The following code loads player attributes such as the player image and sounds from SQL Server.

Visual Basic   

Public Sub LoadPlayer()
        
        playerName.DisplayMember = _playerDT.NicknameColumn.ColumnName

        Dim tauntsTA As New FoosDataTableAdapters.TauntsTableAdapter()
        Dim tauntsDT As New FoosData.TauntsDataTable()
          _taunts = New Collection

        tauntsTA.FillByPlayerID(tauntsDT, _playerID)
        For Each row As FoosData.TauntsRow In tauntsDT
            _taunts.Add(row.Item("SoundClip"))
        Next row

        Dim dr As DataRow() = _playerDT.Select("PlayerID = " & _playerID)
        If Not dr(0).Item("Avatar") Is DBNull.Value Then
            Dim img As Byte()
            img = CType(dr(0).Item("Avatar"), Byte())
            playerPic.Image = Image.FromStream(New System.IO.MemoryStream(img))
        Else
            playerPic.Image = My.Resources.Resource.clarityLogo
        End If
End Sub

After cycling through a list of employee accounts in the database using the player's button, it's time to play some foosball. Without budget enough to hire Keith Jackson to provide game commentary full-time, we added our own virtual announcer using the Microsoft Speech API. To make your application speak, all you need to do is add a reference to SpeechLib.dll and declare a new speech object.

Visual Basic

Dim voice As New SpVoice
voice.Speak("Whoa Nelly! Welcome to the Clarity Foos League",_
             SpeechVoiceSpeakFlags.SVSFDefault)

Figure 2. Scoreboard

Taunting Your Opponent

When playing office foosball, nothing is more important than a witty taunt to demoralize your opponent. When a player scores a goal, he presses the button in his corner, which fires a goal scored event which then triggers several actions. One action is to play a random sound clip from the player's personal sound collection retrieved from SQL Server. I'm mostly a C# developer, so the new Visual Basic .NET My Classes was something I wanted to try out. My Classes make it simple to perform dozens of tasks like playing any .wav file.

Visual Basic   

Private Sub PlayRandomSoundFile()
            randomInt = r.Next(1, _taunts.Count)
            My.Computer.Audio.Play(_taunts(randomInt),_
            AudioPlayMode.WaitToComplete)
End Sub

Let's See That in Instant Replay

When we first started this project, instant replay was buried in my list of dream features. I never thought I'd actually code half of those and instant replay seemed like it would take longer than my break to do. With a little lunchtime Internet surfing, I found this easy-to-use video capture/player ActiveX control from Fath Software called VideoCapX. (Oh, and I nearly tore apart the ceiling while trying to run a 50-ft USB cable through the tiles to the Clarity SkyCam©, but let's keep that from the office admin) In just a few lines of code, I can watch over and over again how terrible I am at blocking a pull shot.

Visual Basic  

Public Sub ShowReplay()
        Dim vidLength As Double
        vcx.StopCapture()
        vcx.PlayerOpen(FOOS_REPLAY_WMV)
        vidLength = vcx.PlayerGetLenMS()
        If vidLength > 10000 Then
            vcx.PlayerSetPos(vidLength - 10000)
        End If
        vcx.PlayerSetSize(640, 480)
        Me.BringToFront()
        My.Computer.Audio.Play(My.Resources.Resource.InstantReplay,_
                               AudioPlayMode.WaitToComplete)
        vcx.PlayerStart()
End Sub

Figure 3. Instant Replay

Archiving the Results

It's game over and there is an 80 percent chance that I lost in a blowout; time to put that box score in the record books. For those of you keeping score at home, the table adapters make it simple to save the game record to the database.

Visual Basic   


        Dim gameTA As New FoosDataTableAdapters.GameTableAdapter()
        gameTA.Insert(homeOffense.playerName, homeOffense.goals, _
        homeDefense.playerName, homeDefense.goals, _
        visitorOffense.playerName, visitorOffense.goals, _
        visitorDefense.playerName, visitorDefense.goals, _
        gameStartTime, gameEndTime)

With all the game stats recorded in SQL Server, we can produce dozens of reports such as win percentage, total goals scored, shutouts, average goals scored per game, average goals allowed per game, and using a formula based loosely on the BCS (U.S. college football) computer rankings, the top overall player. Sadly, I wrote the application and I still can't get my name into the top 10 players.

These stats are displayed on an arcade-like teaser screen that loads after the application has been idle for a few minutes. The teaser screen cycles through several dozen datasets to provide a different set of stats on the screen.

Visual Basic


Private Sub LoadStats()
        statTimer.Enabled = True
        Dim statType As Integer = ChooseRandomStatList()
        Dim playerDT As New FoosData.PlayerDataTable()
        Dim playerTA As New FoosDataTableAdapters.PlayerTableAdapter()

        Select Case statType
            Case 1
                playerTA.FillByTop10Winners(playerDT)
                statTitle.Text = "Most Wins"
                ResizeFont(FontSize.Large)
            Case 2
                playerTA.FillByTop10WinPercentage(playerDT)
                statTitle.Text = "Best Win %"
                ResizeFont(FontSize.Large)
            Case 3
                playerTA.FillByTop10Foosers(playerDT)
                statTitle.Text = "Biggest Foosers"
                ResizeFont(FontSize.Large)
                    …More stats…
                End Select
End Sub

Figure 4. Teaser Screen

Conclusion

Visual Basic.NET has dozens of new features that make quickly building an application very easy. In just a few hours I was able to put together an application that has significantly improved the fun of having a foosball table in the office. Unfortunately, it still can't make me play better. Maybe next version. Speaking of the next version, on my brand new blog, I'm going to cover some future additions to Visual Foos 2005 like a Web front-end to view game logs and upload sound files. Some other additions I'd like to develop are a RSS feed of games played, pre-game predictions using SQL Server Analysis Services, player identification through RFID readers, and a foosball speed radar. If anyone has any suggestions, I'd love to hear them! Or if you have a foosball table you don't want.