Steve Fox's OBA Ramblings : Outlook Addin

OBA Sample Application Kit for SAP & Siebel Released to Web

Steve Fox — Tue, 09 Jun 2009 00:57:09 GMT

Over the past few months, we’ve received some very positive feedback on the OBA Sample Application Kits that we’ve released. Well, today we release to web the latest in the family of kits, the OBA Sample Application Kit for SAP & Siebel. Included in this kit are:

Overview whitepaper
Source code
Installation guide
Developer guide

As per the diagram below, this latest OBA kit provides guidance on how developers can integrate Outlook and MOSS 2007 with Siebel and SAP. It integrates a variety of key MS technologies (e.g. BizTalk LOB adapters, WCF, VSTO, and so on) to help you understand how you can integrate LOB systems such as Siebel and SAP into your Office and SharePoint solutions.

The actual developer kit can be found here: http://code.msdn.microsoft.com/sapsiebel. And for more information on other OBA developer kits, you can go here: http://msdn.microsoft.com/en-us/office/cc442491.aspx.

Enjoy!

Steve

Conference Follow-Up Post

Steve Fox — Fri, 25 Apr 2008 22:41:00 GMT

Over the past few weeks, I've attended and presented at a number of conferences (specifically VSLive, MS CSAF, Collaborate, and DevConnections) and had some great conversations with attendees who were seeking more information or had questions in the sessions on additional OBA resources. During some of these conversations, I promised to follow up in my blog on some specific issues/questions. In this blog post, I've added some additional information on:

Deployment
SharePoint Workflow
Outlook add-in development

I'll also be following up on this post in the future with additional information, so I encourage you to check back or RSS the blog (as I'm not exactly to a schedule when posting).

Deployment

In a couple of my sessions, we had some detailed conversations around deployment. Here is a question that I was going to check on. I've also added some additional information that you can check out.

1. Can you point to the root folder assembly and have it point to the latest version of the bits? (This was in relation to mapping a content type from SharePoint and then invoking the assembly from the doc library.) The answer to the question, as I suspected, was yes--and that the deployment manifest should point you to the right location. However, the thing I forgot to mention was that you have to make sure that in your deployment properties you have "Check every time the customization runs." Also, this is not the default setting; the default setting is "Check Every 7 Days." So, once you publish a solution with that configuration, each time the custom document is opened you will get the latest version of the assembly associated with that document.

Misha Schneerson, one of the devs on VSTO, has a great multi-part post on Deployment. While we've made it easier in VS 2008 (by virtue of ClickOnce), there are still some things to keep in mind. You can check out his blog here: http://blogs.msdn.com/mshneer/archive/2008/04/24/deploying-your-vsto-add-in-to-all-users-part-iii.aspx.

SharePoint Workflow

Many of you asked me about some additional workflow guidance. I've pinged a couple of different people, and we're going to put together a blog-post with some additional information. I've also requested some web-casts to address some of the basics. I'll post pointers as these become available. Until then, here are a few things to get you started:

1. http://channel9.msdn.com/ShowPost.aspx?PostID=358685

2. http://office.microsoft.com/en-us/sharepointdesigner/HA101005911033.aspx

3. http://blogs.msdn.com/nikhil/archive/2007/09/11/vsto-and-sharepoint-workflow.aspx

4. http://msdn2.microsoft.com/en-us/library/bb386168.aspx

I'm also working on a couple of other things (whitepaper and webcast) that I'll try and get out to you soon.

Outlook Add-in Development

I'm noticing more and more developers extending Outlook. In one of my sessions, we talked a little about deployment across 2003 and 2007 instances of Outlook and we also discussed migration of OFS form regions to managed code OFRs. Here is some additional information for you guys on this:

Outlook 2007 should host an Outlook 2003 add-in. Mary Lee recently wrote a blog post about developing and testing an Outlook 2003 add-in on a computer running Outlook 2007. You can read more at this post - http://blogs.msdn.com/vsto/archive/2008/03/20/developing-an-add-in-for-multiple-versions-of-office.aspx.

Note that the deployment method isn't Office version specific; it's VSTO runtime specific. A VSTO solution that works for both O11 and O12 must be designed with the VSTO 2.0 runtime and .NET FX 2.0, so the same setup project with CASPOL deployment would apply.

There is also an interesting topic named "Creating Solutions for Multiple Versions of Office" at http://msdn2.microsoft.com/en-us/library/bb772080.aspx.

We do have topics that discuss how to import an OFS into an Outlook 2007 project. We also discuss the advantages and disadvantages of importing a form region vs. creating one fresh by using our designer. I will admit that the discussion of using an OFS file is not overly extensive. However, I don't think we missed any discussion critical to who are considering the idea of moving their OFS files to VSTO. Here are the topics that discuss using an OFS file:

· Creating Outlook Form Regions - http://msdn2.microsoft.com/en-us/library/bb386301.aspx.

· Walkthrough: Importing a Form Region that was Designed in Outlook - http://msdn2.microsoft.com/en-us/library/bb608611.aspx.

· Accessing a Form Region at Run Time - http://msdn2.microsoft.com/en-us/library/bb772084.aspx.

Note: Thanks to the VSTO dev team and UE team for providing responses to my field notes and queries.

To those of you who attended my sessions and had questions, I hope the above at least gets you started. If not, I'll be sure to post more in the coming days and weeks.

Steve

Your Second Outlook Add-in

Steve Fox — Fri, 28 Mar 2008 16:52:00 GMT

In my previous post, I showed you how to create a custom task pane that hosted a user control data bound to an external data source. The control enabled you to browse data and then create a sales contact with the currently selected record. Vaguely interesting, yes, but more to the point we successfully extended Outlook and then manipulated and changed an Outlook item based on external data that we were browsing. In this post, I've added a small snippet to get you started on creating an Outlook form region (OFR).

OFRs are great; they allow you to extend your Outlook experience with customized forms that integrated into the various inspectors or forms within Outlook. For example, I could create a custom OFR for a mail message that is dynamically bound to my email properties or I could create a custom OFR for my sales contacts that looks up their address and maps their address for us on the OFR. In this blog post, I'll walk you through a simple OFR and then point you to some additional information that may be helpful for your more extensive OFR development.

OFRs are an artefact of Visual Studio Tools for Office (VSTO) 3.0, which is a component technology within Visual Studio 3.0 that enables you to create Office solutions. To create an OFR, open Visual Studio 2008 and click File, New, Project, and then select the Office node under either Visual C# or Visual Basic. Once you've got your project set up, right-click the Project and click Add New. In the Add New dialog, select Office and then select Outlook Form Region. Provide your OFR with a name and click Add. This kicks off a wizard that walks through the OFR creation process. You can either create a new OFR or import an existing one. Note that you have a number of choices here: i) Adjoining, ii) Separate, iii) Replacement, or iv) Replace All (see the article below for more information on these). Select Separate and click Next.Give your OFR a name and leave the two check-boxes checked.Click Next and then select Mail Message and then click Finish. This will set up and add your OFR to your project.

The OFR will have a couple of critical methods you'll want to pay attention to (double-click the OFR designer to see these methods):

[C#]

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

{

}

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

{

}

[VB]

Private Sub FormRegion1_FormRegionShowing(ByVal sender As Object, ByVal e As System.EventArgs) Handles MyBase.FormRegionShowing

End Sub

Private Sub FormRegion1_FormRegionClosed(ByVal sender As Object, ByVal e As System.EventArgs) Handles MyBase.FormRegionClosed

End Sub

These methods are, similar to other VSTO project shell methods, methods that allow you write constructor and clean-up code for your OFR when it shows and when it is closed. If you go back to the designer view, you can add controls to your OFR. Go ahead and add a combo-box, a label, a button and a web-browser control. In my project, I added "Stocks:" as the label text, added the text "Go" to the button, set the Name property of the button to Go, set the combo-box Name property to cmboStock, and then added five items to the combo-box collection: i) V, ii) MSFT, iii) GOOG, iv) GE, and v) CSCO. You'll want to size the web browser as 1000 x 900. I also changed the Name property of the web-browser control to stockBrowser.

The heavy-lifting, or not so heavy-lifting, is done by our button. You will want to add an event off of the button and then load the page in the web browser based on the user's selection. This is the code that you'll hang off of the button:

[C#]

private void Go_Click(object sender, EventArgs e)

{

string strMsnURL = "http://moneycentral.msn.com/detail/stock_quote?Symbol=";

string strStock = cmboStock.SelectedItem.ToString();

string fullStockURL;

fullStockURL = strMsnURL + strStock;

stockBrowser.Navigate(fullStockURL);

}

[VB]

Private Sub Go_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Go.Click

Dim strMsnURL As String

Dim strStock As String

Dim fullStockURL As String

strMsnURL = "http://moneycentral.msn.com/detail/stock_quote?Symbol="

strStock = cmboStock.SelectedItem.ToString

fullStockURL = strMsnURL + strStock

stockBrowser.Navigate(fullStockURL)

End Sub

Once you've done this, you're done with the coding part of the sample. You can hit F5 and build your project.

I like the Separate OFR because it creates a button that enables you to toggle back and forth across default and custom inspector views. And for the above sample, if you create a new mail message you should see a button on your ribbon (name of your OFR), which you can click to view the OFR (see the attached image).

In general, OFRs are pretty exciting because you can host Windows Forms or WPF user controls and of course OFRs (and more widely VSTO) supports LINQ, WF, WCF, etc. This was a simple one to get you started, but you can check out the VSTO Developer Center for more information. Also, I recently published an article with MSDN magazine that provides a more in-depth walkthrough of a custom OFR (this one walks through a Replacement OFR). You can find these links as follows:

1. VSTO Developer Center: http://msdn2.microsoft.com/en-us/office/aa905533.aspx.

2. MSDN Magazine Article: http://msdn2.microsoft.com/en-us/magazine/cc164242.aspx.

Also, as I mentioned in an earlier blog entry the MSPress book Programming Applications for Office Outlook 2007 is a good book for learning about all things Outlook.

Have a great day!

Steve

Your First Outlook Add-in...

Steve Fox — Thu, 27 Mar 2008 21:47:00 GMT

I just finished a private technical briefing and during the session showed a few demos. Many of the attendees asked me to share the code, so I thought I'd post to my blog to get my butt in gear and actually post some useful stuff and get the code up here so the attendees could read up on it.

When thinking about OBAs, one of the key integration points in Office is Outlook. It makes sense; a ton of people use this tool every day, so why wouldn't you leverage the Outlook OM and VSTO to create some killer OBAs? To get you started, I put together a small demo that shows how you integrate Outlook with AdventureWorks using VSTO. The demo shows i) how to add a custom task pane that's bound to data and enables you to create a new contact (or more widely access the Outlook OM).

First, the environment. My dev environment is Windows Server 2003, MOSS 2007 (which I won't use in this demo), VS 2008 (which includes VSTO 3.0), Expression Blend, SQL Server 2005, and Office Enterprise 2007. I've also downloaded the Adventureworks 2005 sample db off of Codeplex.

To begin, open Visual Studio and create a new project (File, New, Project, click Visual C# (or Visual Basic), Office, and then select Outlook Add-in). Name the project what you want and click OK. This creates the VSTO Outlook project shell for you.

In my project, I first added the Adventureworks database (Data, Add New Data Source, and walk through the wizard to add the database). The only table you'll want to add to the project is the vSalesPerson table. Once the database is added, click Data, Show Data Sources to make sure it's there.

I then added a new user control (right click project, click Add, New Item, and then select User Control in the New Item dialog). Resize the control to be about 300 x 760. I then dragged a few of the fields from the Data view onto the user control--specifically, I added FirstName, Lastname, Phone, Email, AddressLine1, and City. You can select the ones you want; just remember you'll need to account for them in your code-behind. Once you've done this, add a button to the user control (see attached image).

I added some code-behind to the button, which is listed below:

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Drawing;

using System.Data;

using System.Linq;

using System.Text;

using System.Windows.Forms;

using Outlook = Microsoft.Office.Interop.Outlook;

namespace MyTestAddin

{

public partial class CustomerBrowser : UserControl

{

string strFirstName;

string strLastName;

string strPhone;

string strEmail;

string strAddress;

string strCity;

public CustomerBrowser()

{

InitializeComponent();

}

private void CustomerBrowser_Load(object sender, EventArgs e)

{

vSalesPersonTableAdapter.Fill(this.adventureWorks_DataDataSet.vSalesPerson);

}

private void button1_Click(object sender, EventArgs e)

{

strFirstName = firstNameTextBox.Text;

strLastName = lastNameTextBox.Text;

strPhone = phoneTextBox.Text;

strEmail = emailAddressTextBox.Text;

strAddress = addressLine1TextBox.Text;

strCity = cityTextBox.Text;

createCustomerContact(

strFirstName,

strLastName,

strPhone,

strEmail,

strAddress,

strCity);

}

private void createCustomerContact(

string firstName,

string lastname,

string phone,

string email,

string address,

string city)

{

Outlook._Application myOutlookObject = new Outlook.Application();

Outlook.MAPIFolder custContacts = (Outlook.MAPIFolder)myOutlookObject.Session.GetDefaultFolder(Outlook.OlDefaultFolders.olFolderContacts);

Outlook.ContactItem newSalesContact = (Outlook.ContactItem)custContacts.Items.Add(Outlook.OlItemType.olContactItem);

newSalesContact.FirstName = firstName;

newSalesContact.LastName = lastname;

newSalesContact.Business2TelephoneNumber = phone;

newSalesContact.Email1Address = email;

newSalesContact.BusinessAddress = address;

newSalesContact.BusinessAddressCity = city;

newSalesContact.Save();

}

You'll note that you need to call the FIll method when the user controls loads to ensure the data from the Adventureworks database loads. But, most of the other data is pretty self-explanatory. You're essentially grabbing the string variables and then mapping them to the properties of the new contact item you've created. You need to note that there is no error handling in this code, though. So, for example I could add the same person from the data source over and over again. You may not want to do that.

Hit F6 to build, but don't run just yet. After you've successfully built the app, go to the ThisAddIn class and make sure you have the following code in it:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Xml.Linq;

using Outlook = Microsoft.Office.Interop.Outlook;

using Office = Microsoft.Office.Core;

namespace MyTestAddin

{

public partial class ThisAddIn

{

Microsoft.Office.Tools.CustomTaskPane ctp;

private CustomerBrowser ctrl = new CustomerBrowser();

string title = "Demo";

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

{

ctp = this.CustomTaskPanes.Add(ctrl, title);

ctp.Visible = true;

ctp.Width = 350;

ctp.DockPosition = Microsoft.Office.Core.MsoCTPDockPosition.msoCTPDockPositionRight;

}

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

{

}

#region VSTO generated code

/// <summary>

/// Required method for Designer support - do not modify

/// the contents of this method with the code editor.

/// </summary>

private void InternalStartup()

{

this.Startup += new System.EventHandler(ThisAddIn_Startup);

this.Shutdown += new System.EventHandler(ThisAddIn_Shutdown);

}

#endregion

}

The important code here is that you need to create a custom task pane object (CTP) and then add an instance of the newly created user control to the CTP object and then set some properties on the CTP object. What this will do (notice that we've added some of the code in the ThisAddinStartup method) is invoke the custom task pane.

You can now F5 to build. You should see the user control on the right-hand side of the screen. Open your Contacts folder, and then browse to a sales person from the Adventureworks db and click the button to add them to your Contacts. Voila! You've created your first Outlook add-in.

The extrapolation for an OBA is connecting to a LOB system via a service. You can try and wrap the Adventureworks db in a service and do the same thing we did above--just do it through a service call--and you'd have built a small OBA.

Well, happy coding!

Steve

PS I recently picked up the book Programming Applications for Office Outlook 2007, and this helped me with some questions I had about coding against the Outlook OM. Lots of code samples in it, and very well written.