Retargeting a Word 2007 Add-In that uses Smart Tags from .NET 3.5 to .NET 4.0

In Visual Studio 2010, in the Solution Explorer window, right-click the project node and select Properties from the context menu.

In the Properties window, for Microsoft Visual Basic, select the Compile tab and then the Advanced Compile Options button. For both Microsoft Visual Basic and Microsoft C#, set the Target framework property to .NET Framework 4.0 Client Profile. (Note that the Client Profile option sets the project up for client-side use, and includes references to fewer assemblies than would be added by selecting the .NET Framework 4.0 option.) When prompted to close and re-open the project so that Visual Studio can change the Target Framework, click Yes.

Save and compile the project: You will find that the project, which originally compiled and ran fine, now returns many errors that you must fix.

In the Solution Explorer window, double-click TemperatureSmartTag.vb or .cs, displaying the code in the Code Editor.

In .NET Framework 4.0 projects, a smart tag implements the ISmartTagExtension interface, instead of inheriting from the SmartTag class: In the Code Editor, change the declaration of the TemperatureSmartTag class so that it implements the Word.ISmartTagExtension interface, instead of inheriting from the SmartTag class. The class declaration should look like the following code.

Public Class TemperatureSmartTag
  Implements Word.ISmartTagExtension

class TemperatureSmartTag : Word.ISmartTagExtension

In Visual Basic, press Enter to have Visual Studio create the necessary procedure stubs required by the interface. In C#, right-click the interface name, and select Implement Interface, and then Implement Interface (again) to generate the stubs.

Within the class, add a declaration for an instance of the Word.SmartTag class; you will use this instance to represent the actual smart tag.

Private smartTagDemo As Word.SmartTag

private Word.SmartTag smartTagDemo = null;

Find the ExtensionBase property, and modify it so that it returns the smartTagDemo variable.

Public ReadOnly Property ExtensionBase As Object _
  Implements Microsoft.Office.Tools.IExtension.ExtensionBase

  Get
    Return smartTagDemo
  End Get
End Property

public object ExtensionBase
{
  get { return smartTagDemo; }
}

Because the smart tag class now implements an interface, instead of inheriting from a class, you must add code to create an instance of the smart tag. Modify the class' constructor so that it calls the Globals.Factory.CreateSmartTag method, which returns the smart tag object that you need. In Visual Basic, replace the call to MyBase.New. In C#, replace the call to the base method.

Me.smartTagDemo = Globals.Factory.CreateSmartTag(
  "http://www.microsoft.com#TemperatureSmartTag", "Temperature", Me)

this.smartTagDemo = Globals.Factory.CreateSmartTag(  
"http://www.microsoft.com#TemperatureSmartTag", "Temperature", this);

In the constructor, replace code that calls Expressions.Add so that it calls the same method on the smartTagDemo object.

smartTagDemo.Expressions.Add(New Regex(
  "\s*(?'number'[-+]?[0-9]+)°?\s?(?'temperature'(F|C|f|c))\s*"))

smartTagDemo.Expressions.Add(new Regex(
  "\\s*(?'number'[-+]?[0-9]+)°?\\s?(?'temperature'(F|C|f|c))\\s*"));

Modify the code that creates the Word.Action instances--rather than creating the object yourself, call the appropriate factory method to create the object.

temperatureAction = Globals.Factory.CreateAction("Convert")

temperatureAction = Globals.Factory.CreateAction("Convert");

Modify the code that sets the class' Action property so that it sets the Action property of smartTagDemo, instead:

smartTagDemo.Actions = New Word.Action() {temperatureAction}

smartTagDemo.Actions = new Word.Action[] { temperatureAction };

Add a Base property that returns the smartTagDemo variable:

Public ReadOnly Property Base As Word.SmartTag
  Get
    Return smartTagDemo
  End Get
End Property

public Word.SmartTag Base
{
  get { return smartTagDemo; }
}

In C#, remove the code from the Recognize method. This code, provided by the Visual Studio template when you implemented the interface, throws an exception because the method hasn't yet been implemented. Because the current example does not require a Recognize method to do its job, the code should do nothing at all:

public void Recognize(
  string text, 
  Microsoft.Office.Interop.SmartTag.ISmartTagRecognizerSite site, 
  Microsoft.Office.Interop.SmartTag.ISmartTagTokenList tokenList, 
  SmartTagRecognizeContext context)
{
  // Do nothing at all.
}

In the Solution Explorer window, double-click ThisAddIn.vb or .cs, loading it into the Code Editor.

Find the code that calls the GetVstoObject method, and replace the line with the following code.

Dim vstoDocument = Globals.Factory.GetVstoObject(interopDocument)

var vstoDocument = Globals.Factory.GetVstoObject(interopDocument);

Because the VstoSmartTags.Add method requires an actual smart tag instance, modify the call to VstoSmartTags.Add so that it passes in the Base property of the new smart tag that the code creates.

vstoDocument.VstoSmartTags.Add(smartTagDemo.Base)

vstoDocument.VstoSmartTags.Add(new TemperatureSmartTag().Base);

In the Solution Explorer window, expand Ribbon1.vb or .cs, and double-click Ribbon1.Designer.vb or .cs to open it in the Code Editor. (If you cannot expand Ribbon1, select Project, and then Show All Files.)

Modify the Ribbon1 class so that it inherits from the RibbonBase class, as opposed to the OfficeRibbon class.

Modify the class' constructor so that it calls the Globals.Factory.GetRibbonFactory method in the base class:

Public Sub New()
  MyBase.New(Globals.Factory.GetRibbonFactory())

  'This call is required by the Component Designer.
  InitializeComponent()

End Sub

public Ribbon1():
  base(Globals.Factory.GetRibbonFactory())
{
  InitializeComponent();
}

Because all the elements that you place on Ribbon customizations are now based on interfaces, rather than classes, you must call the appropriate factory method to hand you an instance of the corresponding Ribbon control. In your own code, you will have to find any place in which you create an instance of a control. In the sample, in Ribbon1.Designer.vb or .cs, find the InitializeComponent procedure. (In C#, expand the Component Designer generated code block first.)

Replace the lines in the sample that create instances of controls with the following code, which calls the correct factory method for each control type.

Dim RibbonDropDownItem1 As  _
  Microsoft.Office.Tools.Ribbon.RibbonDropDownItem =
  Me.Factory.CreateRibbonDropDownItem()
Dim RibbonDropDownItem2 As  _
  Microsoft.Office.Tools.Ribbon.RibbonDropDownItem =
  Me.Factory.CreateRibbonDropDownItem()
Me.TabCustom = Me.Factory.CreateRibbonTab()
Me.temperatureGroup = Me.Factory.CreateRibbonGroup()
Me.TemperatureEditBox = Me.Factory.CreateRibbonEditBox()
Me.ScaleDropDown = Me.Factory.CreateRibbonDropDown()
Me.InsertButton = Me.Factory.CreateRibbonButton()

Microsoft.Office.Tools.Ribbon.RibbonDropDownItem ribbonDropDownItem1 = 
  this.Factory.CreateRibbonDropDownItem();
Microsoft.Office.Tools.Ribbon.RibbonDropDownItem ribbonDropDownItem2 = 
  this.Factory.CreateRibbonDropDownItem();
this.TabCustom = this.Factory.CreateRibbonTab();
this.temperatureGroup = this.Factory.CreateRibbonGroup();
this.TemperatureEditBox = this.Factory.CreateRibbonEditBox();
this.ScaleDropDown = this.Factory.CreateRibbonDropDown();
this.InsertButton = this.Factory.CreateRibbonButton();

Find the ThisRibbonCollection class, and modify the class so that it no longer inherits from the RibbonReadOnlyCollection class.

In C#, you must replace all event handler declarations with new, generic delegates. The simplest way to do this is to create a new blank line, type the event name, type the += operator, and allow the editor to create the new delegate instance. In the sample, find the line of code that sets up the this.Load event handler, create a blank line, and let the editor generate the new event handler hookup for you. Delete the original when you're done. For example, the new code for the Load event looks like the following code.

this.Load +=new Microsoft.Office.Tools.Ribbon.RibbonUIEventHandler(
  Ribbon1_Load);