File INI o Registro o file personali?

Voglio salvare la configurazione del mio progetto che include

1. Grandezza schermo
2. Posizione dello schermo
3. Percorsi delle cartelle
4. Impostazioni degli utenti e così via.

I luoghi standard in cui è possibile salvare questi sono valori di configurazione sono:

1. Registro
2. File INI
3. File personali (come * .cfg)

Come scegli tra questi luoghi? Inoltre, ci sono dei pro e dei contro nell'usarli?

Ci sono anche dei pro e dei contro nell'usarli?

Registro di sistema:

• + Relativamente standard in ambiente Windows.
• + Generalmente un buon supporto da parte degli installatori, ecc.
• - API specifica per piattaforma, se mai desideri eseguire il porting della tua applicazione.
• - Non particolarmente leggibile dall'uomo.

File INI:

• + Formato semplice.
• + Portatile.
• + Leggibile dagli umani.
• - Può essere difficile archiviare informazioni più complesse (ad esempio, qualsiasi cosa nidificata a più di due livelli di profondità).
• ?Potrebbe essere necessario scrivere il proprio parser (anche se non difficile) o utilizzare una libreria esterna come SimpleIni (grazie a Jonathan Merlet per il commento).

File XML (suppongo che questa sia l'opzione .cfg):

• + Un formato standard
• + Portatile.
• + Supporta strutture profondamente annidate.
• - Non particolarmente leggibile dall'uomo.

Personalmente, per le applicazioni Windows tendo a usare C # e vado con un file personale per l'utente, memorizzato come XML. Lo faccio in genere perché la leggibilità umana di solito non è una priorità nei tipi di applicazioni che scrivo (e l'applicazione dovrebbe avere un editor di configurazione, in ogni caso), e in ambiente .NET , è molto facile lavorare con XML. Molto spesso finisco con un oggetto UserConfiguration che viene semplicemente serializzato da e verso un file di configurazione - quasi nessuno sviluppo coinvolto (analisi, casting roba in giro) e hai la tua configurazione pronta per l'uso in un ambiente fortemente tipizzato.

Vorrei andare con i file INI, sono l'opzione più umana:

[window]
width       = 600
height      = 350
position.x  = 400
position.y  = 200

[paths]
path1       = "/some/random/path/"
path2       = "/some/other/random/path/"

[user]
name        = "Yannis"
preference  = "INI"

XML potrebbe essere una buona opzione, ma non può battere la semplicità e l'eleganza di INI:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <window>
        <width>600</width>
        <height>350</height>
        <position>
            <x>400</x>
            <y>200</y>
        </position>
    </window>
    <paths>
        <path1>/some/random/path/</path1>
        <path2>/some/other/random/path/</path1>
    </paths>
    <user>
        <name>Robert</name>
        <preference>XML</preference>
    </user>
</configuration>

Gli INI sono anche molto ben compresi e indipendenti dalla piattaforma. Probabilmente non ci sono tanti strumenti disponibili per loro come per i file XML, perché, beh, chi ha bisogno di uno strumento specializzato per leggere e modificare un file INI?

La mia preferenza sono i file XML. Sono gerarchici, puoi piegarli alla tua volontà in quasi ogni modo immaginabile, sono ben compresi, indipendenti dalla piattaforma e c'è una vasta gamma di software disponibili per leggerli e scriverli.

Per espandere il suggerimento di YAML di Jeff D , ecco una breve introduzione.

YAML è simile a JSON (in effetti, JSON è un sottoinsieme di YAML dalla versione 1.2 dello standard YAML e quindi può essere analizzato JSON valido dai parser YAML). A prima vista, la differenza principale è che YAML (per impostazione predefinita) utilizza il rientro anziché il bracketing per mostrare la gerarchia. C'è anche una notevole mancanza di virgolette per le stringhe. Un rapido esempio dall'alto:

configuration:
  window: 
    width:       600
    height:      350
    position:
      x:         400
      y:         200
  paths:
    path1:       some/random/path
    path2:       some/other/random/path
  user:
    name:        Joe Soap
    preference:  YAML

Vedi la pagina YAML di Wikipedia per esempi migliori. Il supporto per YAML esiste per la maggior parte delle lingue principali (vedere yaml.org per i dettagli).

Hai dimenticato un'opzione: il database. Viene utilizzato principalmente negli scenari in cui gli utenti accedono all'applicazione quando l'applicazione non può fare affidamento sull'utente di Windows connesso. Questo ad esempio quando l'app è in esecuzione in una finestra in modalità kiosk.

Le mie preferenze personali sono i file XML:

Nella maggior parte dei casi non mi aspetto che l'utente debba modificare le impostazioni di configurazione, quindi il problema della leggibilità umana non è un argomento in questo caso.

Se è necessario modificarli, è possibile fornire uno strumento di modifica: ciò impedisce all'utente di fare qualcosa di stupido con i dati. Se vogliono ripristinare le impostazioni predefinite, puoi semplicemente dire loro di eliminare il file x che la maggior parte degli utenti si sentirà a proprio agio.

Si noti che è comunque necessario fare attenzione a disporre dell'autorizzazione per archiviare il file poiché alcune posizioni non hanno accesso in scrittura per impostazione predefinita in Windows 7, ecc.

I file INI sono un buon modo standard per archiviare la configurazione e sono provati e testati ma mi sembrano un po 'Windows 3.1'!

Probabilmente l'opzione migliore se si desidera che l'utente sia in grado di armeggiare con i propri dati

Mi allontanerei personalmente dal registro. Per prima cosa non puoi garantire che l'utente disponga delle autorizzazioni necessarie per leggere / scrivere ovunque desideri archiviare i tuoi dati.

Nei sistemi operativi più recenti in cui entra in gioco la virtualizzazione del registro, ciò può causare confusione perché non è possibile "vedere" le impostazioni virtualizzate; questo ci ha morso più di una volta in cui hanno trascorso ore a cercare di capire perché qualcosa non funzionava.