What is the best way to store some data in VSTO addin?

Question

I have developed one outlook add-in, that has to be On or Off.

to do that i have declared one static variable as shown below,

ThisAddIn.cs

public static bool isAddInOn = false;

RibbonButton.cs

    private void btnRibbon_Click(object sender, RibbonControlEventArgs e)
    {
        if (ThisAddIn.isAddInOn )
        {

            ThisAddIn.isAddInOn = false; 
            btnRibbon.Label = "Disabled";

        }
        else
        {

            ThisAddIn.isAddInOn = true;
            btnRibbon.Label = "Enabled";


        }
    }

It is working. But the static variable reset again when i close outlook and open it again. That means when i open outlook by default my add-in is in disabled state.

I just want to store that value at some place. so i can check that value when outlook reopened.

Scenario:

1) open outlook

2) Enable add-in by clicking on its logo (that is in ribbon)

3) now close the outlook

4) when i open outlook again it must enabled

so how can i achieve this ?

Answer 1

There are several techniques you can use to achieve this result. For sure your settings must be serialized to some storage/deserialized during startup of add-in.

One of possible solution could be to use registry for that (in this case probably HKCU (Current user, then it will be private for each user using your add-in) and no special permission is needed.

For storing variable:

    public void StoreInRegistry(string keyName, string value)
    {
        RegistryKey rootKey = Registry.CurrentUser;
        string registryPath = @"Software\YourCompanyName\YourAddInName";
        using (RegistryKey rk = rootKey.CreateSubKey(registryPath))
        {
            rk.SetValue(keyName, value, RegistryValueKind.String);
        }
    }

For reading variable:

    public string ReadFromRegistry(string keyName, string defaultValue)
    {
        RegistryKey rootKey = Registry.CurrentUser;
        string registryPath = @"Software\YourCompanyName\YourAddInName";
        using (RegistryKey rk = rootKey.OpenSubKey(registryPath, false))
        {
            if (rk == null)
            {
                return defaultValue;
            }

            var res = rk.GetValue(keyName, defaultValue);
            if (res == null)
            {
                return defaultValue;
            }

            return res.ToString();
        }
    }

Such stored/retrieved variable should be used during add-in initialization to set your properties. So modification could look like:

ThisAddin.cs

public static bool isAddInOn = ReadFromRegistry("MySetting1", "0") == "1";

RibbonButton.cs

private void btnRibbon_Click(object sender, RibbonControlEventArgs e)
{
    if (ThisAddIn.isAddInOn )
    {

        ThisAddIn.isAddInOn = false; 
        btnRibbon.Label = "Disabled";

    }
    else
    {

        ThisAddIn.isAddInOn = true;
        btnRibbon.Label = "Enabled";


    }
    StoreInRegistry("MySetting1", ThisAddIn.isAddInOn ? "1" : "0");
}

Other options could serialization to file - some class with settings serialized to i.e. isolated storage, database (local or central) etc.

Answer 2

I've used several methods over the years to store configuration data for users.

• Properties.Settings.Default.Properties, so writing in the application project properties. It's solid, never had an issue with it, for hundreds of users over several years.

• Local config files in text, so writing to a known area for the user with fallback. In a stable environment, one can choose the home area for the user, and read/write to the local config file, which also makes it accessible to support if it breaks and needs manual changes. As a fallback, one could write to the local temp folder.

• Registry is an option i have not used in this case, but it is likely to be a good choice.

Performance is likely a key concern considering it will impact the UI for users. Another concern is ease of use for the developer. For both, my choice would be setting it in the application's properties, where reading and writing is very simple and handled within code, and likely very fast.

Write

Properties.Settings.Default.PropertyName = propertValue;

Read

var propertValue = Properties.Settings.Default.PropertyName;