Come mantenere le impostazioni user.config tra diverse versioni di assembly in .net?

Fondamentalmente il problema è che ogni volta che cambia la versione dell'assembly (ovvero l'utente installa una nuova versione dell'applicazione) tutte le loro impostazioni vengono ripristinate ai valori predefiniti (o più precisamente viene creato un nuovo file user.config in una cartella con una versione diversa numero come nome)

Come posso mantenere le stesse impostazioni durante l'aggiornamento delle versioni, poiché l'utilizzo dei file ini o del registro sembra scoraggiato?

Quando abbiamo usato Clickonce sembrava essere in grado di gestirlo, quindi sembra che dovrebbe essere possibile farlo, ma non sono sicuro di come.

ApplicationSettingsBase ha un metodo chiamato Upgrade che migra tutte le impostazioni dalla versione precedente.

Per eseguire l'unione ogni volta che pubblichi una nuova versione della tua applicazione, puoi definire un flag booleano nel tuo file di impostazioni che per impostazione predefinita è true. Denominalo UpgradeRequired o qualcosa di simile.

Quindi, all'avvio dell'applicazione, verificare se il flag è impostato e, in tal caso, chiamare il metodo di aggiornamento , impostare il flag su false e salvare la configurazione.

if (Settings.Default.UpgradeRequired)
{
    Settings.Default.Upgrade();
    Settings.Default.UpgradeRequired = false;
    Settings.Default.Save();
}

Ulteriori informazioni sul metodo di aggiornamento su MSDN . Il GetPreviousVersion potrebbe anche essere la pena dare un'occhiata se avete bisogno di fare un po 'fusione personalizzato.

So che è passato un po 'di tempo ... In un'app Winforms, basta chiamare My.Settings.Upgrade()prima di caricarli. Verranno visualizzate le impostazioni più recenti, sia la versione corrente sia una versione precedente.

Ecco la mia ricerca nel caso in cui qualcun altro abbia difficoltà a migrare le impostazioni che sono state modificate / rimosse. Il problema di base è che GetPreviousVersion()non funziona se la nuova versione dell'applicazione è stata rinominata o rimossa. Quindi devi mantenere l'impostazione nella tua Settingsclasse, ma aggiungi alcuni attributi / artefatti in modo da non utilizzarla inavvertitamente nel codice altrove, rendendola obsoleta. Un'impostazione obsoleta di esempio sarebbe simile a questa in VB.NET (può essere facilmente tradotta in C #):

<UserScopedSetting(),
DebuggerNonUserCode(),
DefaultSettingValue(""),
Obsolete("Do not use this property for any purpose. Use YOUR_NEW_SETTING_NAME instead."),
NoSettingsVersionUpgrade()>
Public Property OldSettingName() As String
  Get
    Throw New NotSupportedException("This property is obsolete")
  End Get
  Set
    Throw New NotSupportedException("This property is obsolete")
  End Set
End Property

Assicurati di aggiungere questa proprietà allo stesso spazio dei nomi / classe con le impostazioni dell'applicazione. In VB.NET, questa classe è denominata MySettingsed è disponibile nello Myspazio dei nomi. È possibile utilizzare la funzionalità di classe parziale per impedire che le impostazioni obsolete si confondano con le impostazioni correnti.

Riconoscimento completo a jsharrison per la pubblicazione di un eccellente articolo su questo problema. Puoi leggere maggiori dettagli al riguardo lì.

Ecco una variazione delle soluzioni qui presentate che incapsula la logica di aggiornamento in una classe astratta da cui possono derivare le classi di impostazioni.

Alcune soluzioni proposte utilizzano un attributo DefaultSettingsValue per specificare un valore che indica quando non sono state caricate le impostazioni precedenti. La mia preferenza è semplicemente usare un tipo il cui valore predefinito indica questo. Come bonus, un DateTime? sono utili informazioni di debug.

public abstract class UserSettingsBase : ApplicationSettingsBase
{
    public UserSettingsBase() : base()
    {
        // Accessing a property attempts to load the settings for this assembly version
        // If LastSaved has no value (default) an upgrade might be needed
        if (LastSaved == null)
        {
            Upgrade();
        }
    }

    [UserScopedSetting]
    public DateTime? LastSaved
    {
        get { return (DateTime?)this[nameof(LastSaved)]; }
        private set { this[nameof(LastSaved)] = value; }
    }

    public override void Save()
    {
        LastSaved = DateTime.Now;
        base.Save();
    }
}

Deriva da UserSettingsBase:

public class MySettings : UserSettingsBase
{
    [UserScopedSetting]
    public string SomeSetting
    {
        get { return (string)this[nameof(SomeSetting)]; }
        set { this[nameof(SomeSetting)] = value; }
    }

    public MySettings() : base() { }
}

E usalo:

// Existing settings are loaded and upgraded if needed
MySettings settings = new MySettings();
...
settings.SomeSetting = "SomeValue";
...
settings.Save();

Se le modifiche a user.settings vengono eseguite a livello di programmazione, che ne dite di conservare una copia di (solo) le modifiche a user.settings in un file separato, ad esempio user.customized.settings?

Probabilmente vorrai comunque mantenere e caricare le impostazioni modificate anche in user.settings. In questo modo, quando si installa una versione più recente dell'applicazione con la sua versione più recente di user.settings, è possibile chiedere all'utente se desidera continuare a utilizzare le impostazioni modificate copiandole nuovamente nella nuova user.settings. È possibile importarli all'ingrosso o diventare più elaborati e chiedere all'utente di confermare quali impostazioni desiderano continuare a utilizzare.

EDIT: ho letto troppo rapidamente la parte "più accurata" sulle versioni dell'assembly causando l'installazione di un nuovo user.settings in una nuova directory specifica della versione. Pertanto, l'idea sopra probabilmente non ti aiuta, ma può fornire qualche spunto di riflessione.

Ecco come l'ho gestito:

public virtual void LoadSettings(ServiceFileFormBaseSettings settings = null, bool resetSettingsToDefaults = false)
{
    if (settings == null)
            return;

    if (resetSettingsToDefaults)
        settings.Reset();
    else
    {
        settings.Reload();

        if (settings.IsDefault)
            settings.Upgrade();
    }

    this.Size = settings.FormSize;

}

e nella classe settings, ho definito la proprietà IsDefault:

// SaveSettings always sets this to be FALSE.
// This will have the default value TRUE when first deployed, or immediately after an upgrade.
// When the settings exist, this is false.
//
[UserScopedSettingAttribute()]
[DefaultSettingValueAttribute("true")]
public virtual bool IsDefault
{
    get { return (bool)this["IsDefault"]; }
    set { this["IsDefault"] = value; }
}

In SaveSettings, ho impostato IsDefault su false:

public virtual void SaveSettings(ServiceFileFormBaseSettings settings = null)
{
    if (settings == null) // ignore calls from this base form, if any
        return;

    settings.IsDefault = false;
    settings.FormSize = this.Size;
    settings.Save();
}