C# Applicazione - memorizzazione delle preferenze nel database o nel file di configurazione?

Question

Ho un'applicazione che utilizza SQLite, che è estremamente leggero e veloce. Ho alcune preferenze che non devono necessariamente essere caricate all'avvio, ma potrebbe essere necessario utilizzarle in momenti diversi a seconda di dove va l'utente. Detto questo, non posso decidere dove conservare queste informazioni.

Q1: Devo solo andare avanti e memorizzarlo nel database? Dovrei memorizzarlo in un file di configurazione?

Q2: Devo caricare e memorizzare le preferenze e altri dati all'avvio anche se non vengono necessariamente utilizzati immediatamente? O dovrei semplicemente interrogare il database quando ne ho bisogno?

Esempio: la mia applicazione può memorizzare le informazioni sulla società per la società che utilizza il software. Nome dell'azienda, telefono aziendale, ecc. L'unica volta che questa informazione viene utilizzata è quando il software stampa automaticamente una lettera o l'utente va a modificare le informazioni della propria azienda nel programma.

EDIT: Ho capito che questo si riduce alle impostazioni dell'applicazione rispetto alle impostazioni utente. Il mio programma non ha più utenti per copia del software. Detto questo, suppongo che queste sarebbero le impostazioni dell'applicazione.

Answer 1

Quante impostazioni stai cercando di salvare? L'uso della funzione di impostazione integrata è piuttosto semplice.

http://msdn.microsoft.com/en-us/library/aa730869.aspx

Answer 2

Memorizzazione dati di configurazione in un file è un bene per le impostazioni leggeri che cambiano raramente. Solitamente lo faresti per impostazioni diverse tra sviluppo e produzione e sono utilizzate per far funzionare la tua applicazione.

Dopodiché, tutto il resto è memorizzato in un database. Questo ti dà la possibilità per le buone interfacce utente di modificare le impostazioni, caricarle quando necessario, salvarle durante gli aggiornamenti al tuo sistema, essere disponibili se usi più front-end (rispetto al salvataggio della configurazione in un file e assicurandoti tutto -end hanno gli stessi file aggiornati.)

Answer 3

Quello che si potrebbe desiderare di fare è scrivere una classe che incapsula le impostazioni e poi le legge in Hashtable.

Si potrebbe avere un metodo GetSetting di base che ricerca un'impostazione basata su un nome. Se l'impostazione si trova in Hashtable, restituire il valore, altrimenti andare al DB per trovare le impostazioni e quindi memorizzarle in Hashtable. È quindi possibile scrivere proprietà separate per ciascuna impostazione desiderata, ciascuna chiamata i metodi GetSetting/SetSetting.

Ciò consente di memorizzare facilmente le impostazioni nel DB e memorizza nella cache le letture per evitare di leggere costantemente il DB.

public class Settings { 
    private object SyncRoot = new object(); 
    private System.Collections.Hashtable _cache = new System.Collections.Hashtable(); 

    public T GetSetting<T>(string xPath, T defaultValue) 
    { 
     lock (SyncRoot) 
     { 
      if (!_cache.ContainsKey(xPath)) 
      { 
       T val = GetSettingFromDB<T>(xPath, defaultValue); 
       _cache[xPath] = val; 
       return val; 
      } 
      return (T)_cache[xPath]; 
     } 
    } 

    public T GetSettingFromDB<T>(string xPath, T defaultValue) 
    { 
     // Read from DB 
    } 

    public void SaveSetting<T>(string xPath, T value) 
    { 
     lock (SyncRoot) 
     { 
      if (_cache.ContainsKey(xPath)) 
       _cache[xPath] = value; 
     } 

     SaveSettingToDB<T>(xPath, value); 
    } 

    public T SaveSettingToDB<T>(string xPath, T defaultValue) 
    { 
     // Read from DB 
    } 
} 

Poi basta creare una classe con un mazzo di proprietà come questa:

public static bool BooleanFeature 
    { 
     get { return Settings.GetSetting<bool>("BooleanFeature", true); } 
     set { Settings.SaveSetting<bool>("BooleanFeature", value); } 
    } 

Ora si può fare questo nel codice:

if (Setting.BooleanFeature) { 
    // Run certain code 
else { 
    // Run other code 
} 

Answer 4

Oltre a JTAS rispondere vorrei Mi piace aggiungere che ho usato 3 metodi e tutti hanno i loro lati su e giù.

1. La conservazione in built-in uno realtà non bloccarle per l'utente che esegue . Quindi, ad esempio, se gli utenti di utilizzano la tua app, lì saranno impostazioni indipendenti per per ciascun utente. Se questo è quello che vuoi, scegli questo .

2. La loro memorizzazione nel database è utile se non si desidera che sia associato a un utente, ma piuttosto al database . Sebbene non sia possibile modificare le impostazioni dall'esterno dell'app.

3. Ho usato una classe di configurazione che ho serializzato con XML se ho bisogno di modificare con un editor xml. Ad esempio questo è molto utile se si è in esecuzione un servizio.