Stockage des paramètres sans base de données

Question

Je dois stocker une liste de paires colonnes/type de données en tant que paramètres d'application. La quantité de paires colonne/type de données sera comprise entre 50 et 100, mais pourrait être supérieure. Je ne peux pas les stocker dans une table en raison des exigences du client. Il y aura une interface utilisateur pour l'utilisateur à ajouter/modifier/supprimer de la liste.

Je pensais initialement à une chaîne délimitée stockée dans app.config. Existe-t-il une limite pratique à la taille de la chaîne stockée dans une clé dans app.config?

Y a-t-il un meilleur moyen? [Modifier le commentaire de sanjii] est-il possible de lire/écrire un fichier xml avec un jeu de données?

Answer 1

Je les stockerais dans un fichier XML. Vous pouvez utiliser la sérialisation XML ou simplement un DataSet.

DSUser ds = new DSUser(); 
ds.ReadXml(fileName); 

ds.AcceptChanges(); 
ds.WriteXml(fileName); 

Answer 2

Étant donné que ces paramètres sont chargés dans la mémoire au démarrage de l'application, vous pouvez stocker en toute sécurité des valeurs dans une configuration pouvant être stockée en mémoire. En d'autres termes, c'est exactement comme si vous aviez codé en dur la chaîne en C# (en ce qui concerne l'utilisation de la mémoire). Par ailleurs, les obligations de votre client empêcheraient-elles l'utilisation de quelque chose comme SQLite?

SQLite est une bibliothèque logicielle qui met en œuvre un autonome, Serverless, zéro configuration, moteur transactionnel de base de données SQL. SQLite est le moteur de base de données SQL le plus largement déployé dans le monde. Le code source pour SQLite se trouve dans le domaine public .

Answer 3

N'abandonnez pas pour l'instant sur app.config/app-settings. Afin de stocker des structures de données plus complexes dans notre configuration d'application, nous avons adopté deux approches: Si la structure de données que nous essayons de stocker peut sérialiser vers/depuis XML, nous la stockons sous forme de chaîne dans l'application. paramètres. L'alternative est la mise en œuvre d'un TypeConverter qui convertit votre structure de données en une chaîne et retour.

Voici un exemple recadrée:

[TypeConverter(typeof(FormStateConverter))] 
public class FormState : INotifyPropertyChanged, IDisposable { 
    private Size _Size = Size.Empty; 
    private Point _Location = Point.Empty; 
    private FormWindowState _WindowState = FormWindowState.Normal; 

    public FormState(Form form) { BindTo(form); } 

    internal FormState(Size size, Point location, FormWindowState state) { 
     _Size = size; 
     _Location = location; 
     _WindowState = state; 
    } 

    // lotsa other code... 
} 

internal class FormStateConverter : ExpandableObjectConverter { 
    public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) { 
     if (destinationType == typeof(string)) { 
     return true; 
     } else { 
     return base.CanConvertFrom(context, destinationType); 
     } 
    } 

    public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) { 
     if (sourceType == typeof(string)) { 
     return true; 
     } else { 
     return base.CanConvertFrom(context, sourceType); 
     } 
    } 

    // This converts a FormState to a string, we're just making a CSV string here... 
    public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) { 
     if (destinationType == typeof(String)) { 
     FormState formState = (FormState)value; 
     string converted = string.Format("{0},{1},{2},{3},{4}", formState.Size.Height, formState.Size.Width, 
      formState.Location.X, formState.Location.Y, formState.WindowState.ToString()); 
     return converted; 
     } 

     return base.ConvertTo(context, culture, value, destinationType); 
    } 

    // This converts a string back into a FormState instance. 
    public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) { 
     if (value is string) { 
     string formStateString = (string)value; 
     string[] parts = formStateString.Split(','); // split the CSV string 

     if (parts != null && parts.Length == 5) { // attempt some error checking 
      Size size = new Size(); 
      Point location = new Point(); 
      FormWindowState state = FormWindowState.Normal; 

      int tmp; 
      size.Height = (Int32.TryParse(parts[0], out tmp)) ? tmp : 0; 
      size.Width = (Int32.TryParse(parts[1], out tmp)) ? tmp : 0; 
      location.X = (Int32.TryParse(parts[2], out tmp)) ? tmp : 0; 
      location.Y = (Int32.TryParse(parts[3], out tmp)) ? tmp : 0; 

      if (string.Equals(parts[4], "maximized", StringComparison.OrdinalIgnoreCase)) { 
       state = FormWindowState.Maximized; 
      } else if (string.Equals(parts[4], "minimized", StringComparison.OrdinalIgnoreCase)) { 
       state = FormWindowState.Minimized; 
      } else { 
       state = FormWindowState.Normal; 
      } 

      return new FormState(size, location, state); 
     } 
     } 

     return base.ConvertFrom(context, culture, value); 
    } 
} 

Après la mise en œuvre du convertisseur de type et d'attribuer notre type de données FormState avec le TypeConverterAttribute, le type FormState apparaît dans notre concepteur Paramètres dans Visual Studio:

Answer 4

Je vote également pour la solution de paramètres XML. Vous pouvez trouver un bel exemple au DotNetBlogEngine Code Source.

Il est basé sur un fichier Xml de base, une classe de paramètres singleton et un paramètre SettingsProvider pour lire des données liées à l'écriture &. Après une implémentation correcte, tout ce que vous avez à faire pour atteindre les paramètres est d'appeler une instance de la classe de paramètres;

ApplicationSettings.Instance.Name = "MyApplicationName"; 
ApplicationSettings.Instance.Description = "It's an awesome application"; 
ApplicationSettings.Instance.Theme = "LoveThemeofMGS"; 
ApplicationSettings.Instance.Save(); 

testlabel.Text = ApplicationSettings.Instance.Name; 
testlabel2.Text = ApplicationSettings.Instance.Description; 

J'utilise personnellement pour la plupart de mes projets Web, il est une solution facile & propre.

Answer 5

1) Comme la plupart des personnes qui ont répondu à votre question - je pense que l'utilisation d'une configuration basée sur XML sera la plus pratique. Je pense que appconfig devrait être suffisant. Cela dépend de vous si Properties.Settings.Default est tout ce dont vous avez besoin, ou peut-être que vous avez besoin d'utiliser ConfigurationManager uniquement pour des tâches plus sophistiquées.

2) Si vous souhaitez utiliser un jeu de données typé, vous devez utiliser l'outil xsd.exe (disponible dans Visual Studio Packaga et .Net Framework SDK). Ce petit outil vous permet de générer un schéma à partir d'un fichier XML et d'un jeu de données codé ou typé à partir d'un schéma. Vraiment utile.

3) Si vous envisagez d'utiliser dans la base de données de la mémoire ... peut-être vaudra-t-il mieux utiliser SQL Compact Server de Microsoft au lieu de SQLite? (Sachez qu'il y en a quelques problems with dealing with date fields while using SQLite)