When using ClickOnce for distributing an Office Add-in the default configuration is to check for updates every 7 days. In an add-in I built I have situations where the add-in must be up to date (for example when changing the WCF service interface). In this post I will show how I solved it.

To check for existing updates I use the regularly ClickOnce API:s, for example a simple check could look like this:

return ApplicationDeployment.IsNetworkDeployed && ApplicationDeployment.CurrentDeployment.CheckForUpdate();

If there is a new version available the solution is to quit Outlook and start another small updater program which will start the installation and then restart the application (Outlook in my case). I have called the little program OutlookRestarter and is a simple Windows Application which is created as its own project in the solution. The compiled output from that project, I have added to the add-in project as a linked file and the important part is to set the file as Content in the Build Action so that it will be included in the ClickOnce installation.
To start the OutlookRestarter I use a simple Process.Start and the only “hard” part about it is to resolve the folder in which the files are deployed:

Uri updateLocation = ApplicationDeployment.CurrentDeployment.UpdateLocation;
                    
Assembly addinAssembly = Assembly.GetExecutingAssembly();
string cachePath = addinAssembly.CodeBase.Substring(0, addinAssembly.CodeBase.Length -
    System.IO.Path.GetFileName(addinAssembly.CodeBase).Length);
Uri restarterPath = new Uri(cachePath + "OutlookRestarter.exe");

Process.Start(restarterPath.AbsoluteUri, updateLocation.AbsoluteUri.Replace("File.vsto", "Setup.exe"));

Globals.ThisAddIn.Application.Quit();

I pass the Url to the installation as an argument to OutlookRestarter and the only notable thing about it is that I replace vsto, with the bootstrapper exe file, because I get ClickOnce errors if trying to go for the vsto file directly.

The OutlookRestarter application have three tasks; download the setup, run the setup and start Outlook again. I choose to download the file and run it manually to save the user from one click, which would be the effect if just doing a Process.Start on the Uri. For downloading the file I copied the DownloadFile method from http://www.codeguru.com/columns/dotnettips/article.php/c7005, with a small modification. Before creating the file I check if it already exists and in that case deletes it.

//Download setup
string tempFileName = Path.Combine(Path.GetTempPath(), "Setup.exe").ToString();
DownloadFile(args[0], tempFileName);

//Start and wait for setup to finish
System.Diagnostics.Process setupProcess = System.Diagnostics.Process.Start(tempFileName);
setupProcess.WaitForExit();

//Check to see if any existing Word Processes exist
System.Diagnostics.Process[] currentOutlookProcesses =
    System.Diagnostics.Process.GetProcessesByName("OUTLOOK");

//Empty Case gets ignored, lazy but effective enough
foreach (System.Diagnostics.Process p in currentOutlookProcesses) p.WaitForExit();

//Start Outlook
StartOutlook();

Before starting Outlook again I wait for setup to finish and also makes sure that Outlook is closed. To start Outlook I check the registry settings that is created by Office 2010 (14), but for Office 2007 (12) I make an assumption that it is installed under Program Files.

private static void StartOutlook()
{
    //Office 14 has installation path in the registry
    RegistryKey localMachine = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\Office");
    object installationPath = null;
    string installationFolder = null;

    foreach (string s in localMachine.GetSubKeyNames())
    {
        installationPath = Registry.GetValue(string.Format(@"{0}\{1}\{2}", localMachine.ToString(), s, @"Outlook\InstallRoot"), "Path", null);
        if (installationPath != null) break;
    }

    if (installationPath != null)
        installationFolder = installationPath.ToString();

    //Guess that Office is installed under Program Files
    if (installationFolder == null || !File.Exists(Path.Combine(installationFolder, "Outlook.exe"))) //Office 12
    {
        installationFolder = Path.Combine(System.Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), "Microsoft Office\\Office12");
        if (!File.Exists(Path.Combine(installationFolder, "Outlook.exe")))
            installationFolder = Path.Combine(System.Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), "Microsoft Office\\Office12");
    }

    string filePath = Path.Combine(installationFolder, "Outlook.exe");
    if (File.Exists(filePath))
    {
        System.Diagnostics.Process.Start(filePath);
    }
}

Since we are developing a product, we need to support both Windows authentication (for most installations), and Forms Authentication for smaller installations or cases where the customer does not use Active Directory for whatever reason. A design goal we had for this was to only change the needed configuration in one place, and that ended up being the authentication tag in web.config. The solution turned out to be simple. What we did was to use initParams of the Silverlight host to set the configured value:

<object data="data:application/x-silverlight-2," type="application/x-silverlight-2" width="100%" height="100%">
    <…>
    <param name="initParams" value="authenticationMode=<%= 
(int)((System.Web.Configuration.AuthenticationSection)System.Configuration.ConfigurationManager.GetSection("system.web/authentication")).Mode %>" />
</object>

When the application starts we sets up the WebContext depending on configured value of the authenitcation mode:

private void InitializeWebContext()
{
    const int Windows = 1;
    const int Forms = 3;

    // Create a WebContext and add it to the ApplicationLifetimeObjects
    // collection.  This will then be available as WebContext.Current.
    WebContext webContext = new WebContext();

    int authenticationMethod = 
Host.InitParams.ContainsKey("authenticationMode") ? int.Parse(this.Host.InitParams["authenticationMethod"], CultureInfo.InvariantCulture) : Windows;

    if (authenticationMethod == Windows)
        webContext.Authentication = new WindowsAuthentication();
    else if (authenticationMethod == Forms)
    {
        webContext.Authentication = new FormsAuthentication();
    }
    else
        throw new NotSupportedException();

    this.ApplicationLifetimeObjects.Add(webContext);

    // This will enable you to bind controls in XAML files to WebContext.Current
    // properties
    this.Resources.Add("WebContext", WebContext.Current);
}

In both cases we load the user when our main page is created.

WebContext.Current.Authentication.LoadUser(UserLoaded, null);

This will succeed if Windows Authentication is used or if the user have chosen “Remember Me” feature of the Forms Authentication. If the user isn’t loaded and Forms Authentication is configured, we then shows a login dialog prompting for user name and password. After closing it we call UserLoaded again so that our event UserAuthenticated is executed.

private void UserLoaded()
{
    if (!WebContext.Current.User.IsAuthenticated && WebContext.Current.Authentication is FormsAuthentication)
    {
        LoginView loginWindow = new LoginView();
        loginWindow.Closed += delegate(object sender, EventArgs e) { if (loginWindow.DialogResult == true) UserLoaded(); };
        loginWindow.Show();
    }
    else if (WebContext.Current.User.IsAuthenticated)
    {
        OnUserAuthenticated(EventArgs.Empty);
    }
}

… is the title of a great post by Vibro that can be found here. This is an important subject and in all project where I have used claims and STS I also wanted the claims on the client. When cracking my own STS (before WIF) I always used the display token to get them from the identity provider (IP, aka the STS) so that seems to be in the line with Vibros thoughts.

Just recently I tried to create a Silverlight application that was supposed to be an active client for a STS (as in the example of the WIF labs), but it failed on the current implementation requirements to use https protocol. What I would have wanted was the possibility to encrypt the username token with the public part of the STS in some cases and use https in some cases depending on the configuration of the installation. What we ended up with was to use the standard RIA support for authentication, but extending the User object with claims so that the client could hide/show functionality that the server anyway would deny the user. We also chose to use IClaimsPrincipal and IClaimsIdentity on the server side even if the claims is created by the server itself. This will make it easier for us to move to a STS when the tooling for Silverlight becomes a little bit more mature.

Anyone else out there having experience with using WIF and Silverlight? I would love to here about your experience in that case.

This is the second post in a series of X. Read the first one here about our overall design.

Since we will develop a product that will be sold in more countries in a not to far future it is important to make sure that it can be localized. In Silverlight the key to localization is (as many other things in SL) data binding. This different for developers that are used to Windows Forms, but it is still very easy and it is still resource files that are used so lets start there.

First step is to add a resource file and I usually create a Resources folder in my project in which I put a new resource (resx) file. There is one important step to do in the resource editor that I have never done before and that is to set the Access Modifier to public (Internal is default). Even though it is set to public, the constructor of the class is generated as internal, which makes it hard to instantiate the class in XAML. Instead we choose to expose the resource in our ViewModel base class.

[Display(AutoGenerateField = false)]
public Resources.Resource Resource { get { return resources; } }

The Display attribute is from data annotations and we put it there to make sure that the property never should show up when using auto generation in the controls that supports it. With this in place we can bind to it in XAML (and we have our ViewModel as data context for the view/user control).

<Button Content="{Binding Path=Resource.Save, FallbackValue=Spara}" />

The first part in the path refers to the Resource property in the view model and the second part is the name of the string in the resource file. We also set FallbackValue to have something shown in the designer.

We will also use data annotations extensively. This means that we need to make sure that the annotations will use localized strings for everything. Lets start by looking at some more code.

[Display(Order = 1, ResourceType = typeof(Resources.Resource), Name = "ProcessGroup")]
[Required(ErrorMessageResourceType = typeof(Resources.Resource), ErrorMessageResourceName = "RequiredErrorMessage")]
public int ProcessGroupId { get; set; }

Here we use two data annotation attributes; Display and Required. The Required attributes of course means that the property is required to be set and the Display attribute has information about how this property should be handled when using auto generation in for example the data grid. Both attributes also uses a resource file to get the error message and the caption for the property in auto generation. When WCF RIA Services tooling auto generates this class on the client side the resource is not available there, but it will have to be. To solve this you add a structure that will give the same namespace as the generated code, in our case this means adding a Web folder and under that a Resources child folder. In this folder we then adds an existing item, but we add it as a link so that changes on the client is immediately available in the client.

There is also a DisplayFormat attribute that controls formatting of values, even though this does not seem to get handled by the data grid. For example we use this for dates:

[DisplayFormat(DataFormatString = "{0:d}")]

To work around that you could easily create a value converter, for example:

public class StringFormatValueConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        if (parameter == null) return value;
        
        string formatString = parameter.ToString();
        if (string.IsNullOrEmpty(formatString)) return value;

        return string.Format(System.Globalization.CultureInfo.CurrentCulture, formatString, value);
    }

    public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        throw new NotSupportedException();
    }
}

This converter can then be used in the Binding element in XAML. When we use auto generation in for example the data grid we need to catch the AutoGeneratingColumn and add the formatter to the binding.

private void dataGrid_AutoGeneratingColumn(object sender, DataGridAutoGeneratingColumnEventArgs e)
{
    if (e.PropertyName == "Imported")
    {
        DataGridTextColumn textColumn = e.Column as DataGridTextColumn;
        if (textColumn != null)
        {
            textColumn.Binding.ConverterParameter = "{0:d}";
            textColumn.Binding.Converter = new Converters.StringFormatValueConverter();
        }
    }
}

Finally we need to control the culture of the web project by adding the globalization information to web.config or the hosting page.

<globalization culture="sv-SE" uiCulture="sv-SE" />

Another possibility is to use the enableClientBasedCulture attribute of the globalization element. It is also possible to set it just for the Silverlight object by setting uiculture and culture param for the object in the Silverlight test aspx page. In all cases it probably would be nice to allow the user to control which culture that should be used, either in a web page or in a settings dialog of the Silverlight application.

I bought a new laptop (DELL Precision M6500) a while ago. My idea was to run much of my work in virtual machines and just keep the parts that I use the most in the main operating system. So this is my story of setting this new machine up.

Setting Up the Host and Main OS

I installed Windows 7 64-bit with Forefront anti-virus and of course hooked it up with my Home Server for backups. I choose both Office 2010 and Visual Studio 2010, but SQL Server 2008 (not R2) for my main OS. Additionally I installed TweetDeck for twitter, Live Writer for blogging, Spotify for music and iTunes is required since I have iPhone.

Getting the Old Machine Running on the New Machine

To enable a fast switch, my idea was to create a virtual machine of my old one. I downloaded Disk2vhd from sysinternals.com which can take a snapshot of the disc even when it’s running. The process to create the file took a couple of hours, but when it was on the external hard drive it was easy to copy to my new machine. In the meanwhile I downloaded Windows Virtual PC. Booting up the old PC in Virtual PC was a big disappointment, because it can not handle 64-bit versions of OS and even my old PC was running Vista 64-bit. This is a big limitation in Virtual PC that I can’t understand, it could at least be available in Ultimate version of Windows?

The next thing to try was downloading WMware Player (also free) which has support for 64-bit guest OS. I spent several days trying to get my image up and running in WMware Player, but it always ended with a blue screen of death before login screen should have shown up. It didn’t help to run repairs from the setup or anything.

After a tip from a colleague I installed Virtual Box instead, which is open source and also free. My image booted immediately in Virtual Box, but I got problems with 100% CPU utilization. Trying different things with great support on the Virtual Box forums, finally got it working. Its not perfect, but I can boot it up and do some work in it, even if it still easily get high CPU utilizations. The settings that got it going was that I turned down from 2 CPU cores to just 1 and I set the RAM to something just below 4GB. With any of these parameters higher blocks the CPU completely.

Creating More Virtual Machines

After getting my new machine working, it was time to fulfill my plans on making virtual machines for different things. First thing to do was of course to set up a new Windows 7 guest, with all current Windows Updates and making sure it is activated. I also needed to spend some time to get the networking working as I wanted. I ended up with a single network card running NAT, but it required me to configure my host machine name in the hosts file and setting the DNS servers hard. With that completed I saved a copy of my clean OS installation to make it easy to set up as many of them as I need.
Next step I choose to install only the client tools for SQL Server 2008 SP1, because I believe that it wont be necessary to have running databases more than on the host. Saving a new copy of the disk and then continuing with Office 2003 (just Excel, Outlook, PowerPoint and Word), SP2 and then a last copy of the disk. Note that there is no CPU utilizations problems with Virtual Box on this freshly installed machines.
Now I have started to make a Visual Studio 2008 machine, and later on I will continue with a Visual Studio 2005 (need that for some WSE3 stuff that isn’t upgraded yet). A Windows Server 2008 with Sharepoint for development is also on the list.

Have you done anything similar and want to share your ideas or what have worked for you?

So I have created an account on twitter too now. You can follow me here: http://twitter.com/ericqu

I hade a really strange problem with a LINQ to SQL diagram today. I added an association between two classes and everything looked perfectly fine in the designer, but there were no code generated for the association. After some frustrating hours I found a blog post written by Bart Lannoeye that saved me. Read it since he also has very claryfing pictures.

THe problem was that my classes had no primary keys since they were generated from views.