Comment stocker le tableau int [] dans les paramètres de l'application

Je crée une application Windows Forms simple en utilisant C # express 2008. Je suis un développeur C ++ expérimenté, mais je suis à peu près tout nouveau dans C # et .NET.

Je stocke actuellement certains de mes paramètres d'application simples à l'aide du concepteur de paramètres et d'un code comme celui-ci:

// Store setting  
Properties.Settings.Default.TargetLocation = txtLocation.Text;  
...  
// Restore setting  
txtLocation.Text = Properties.Settings.Default.TargetLocation;  

Maintenant, j'aimerais stocker soit un tableau de ints ( int[]), soit éventuellement une liste d'ints ( List< int >), en tant que paramètre. Cependant, je ne peux pas comprendre comment faire cela. J'ai recherché la documentation, le stackoverflow et Google, et je ne trouve pas d'explication décente sur la façon de procéder.

Mon intuition basée sur les exemples rares que j'ai trouvés est que je dois créer une classe sérialisable qui encapsule mon tableau ou ma liste, puis je pourrai utiliser ce type dans le concepteur de paramètres. Cependant, je ne sais pas exactement comment procéder.

Il existe également une autre solution - nécessite un peu d'édition manuelle du fichier de paramètres, mais fonctionne ensuite très bien dans l'environnement VS et dans le code. Et ne nécessite aucune fonction ou emballage supplémentaire.

Le fait est que VS permet de sérialiser le int[]type par défaut dans le fichier de paramètres - il ne vous permet tout simplement pas de le sélectionner par défaut. Alors, créez un paramètre avec le nom souhaité (par exemple SomeTestSetting) et faites-le de n'importe quel type ( stringpar exemple par défaut). Enregistrez les modifications.

Maintenant, allez dans votre dossier de projet et ouvrez le fichier "Properties \ Settings.settings" avec l'éditeur de texte (Notepad, par exemple) Ou vous pouvez l'ouvrir dans VS en cliquant avec le bouton droit dans l'Explorateur de solutions sur "-> Propriétés -> Settings.settings ", sélectionnez" Ouvrir avec ... ", puis choisissez" Editeur XML "ou" Editeur de code source (texte) ". Dans les paramètres xml ouverts, trouvez votre paramètre (il ressemblera à ceci):

<Setting Name="SomeTestSetting" Type="System.String" Scope="User">
  <Value Profile="(Default)" />
</Setting>

Modifiez le paramètre "Type" de System.Stringà System.Int32[]. Maintenant, cette section ressemblera à ceci:

<Setting Name="SomeTestSetting" Type="System.Int32[]" Scope="User">
  <Value Profile="(Default)" />
</Setting>

Maintenant, enregistrez les modifications et rouvrez les paramètres du projet - voilà! - Nous avons le paramètre SomeTestSetting avec type System.Int32[]qui peut être consulté et modifié via VS Settings Designer (valeurs aussi), ainsi que dans le code.

ranger:

string value = String.Join(",", intArray.Select(i => i.ToString()).ToArray());

pour recréer:

int[] arr = value.Split(',').Select(s => Int32.Parse(s)).ToArray();

Edit: suggestion d'Abel!

Il existe une autre façon d'obtenir ce résultat qui est beaucoup plus propre dans l'utilisation mais qui nécessite plus de code. Mon implémentation d'un type personnalisé et d'un convertisseur de type, le code suivant est possible:

List<int> array = Settings.Default.Testing;
array.Add(new Random().Next(10000));
Settings.Default.Testing = array;
Settings.Default.Save();

Pour ce faire, vous avez besoin d'un type avec un convertisseur de type qui permet la conversion vers et à partir de chaînes. Vous faites cela en décorant le type avec le TypeConverterAttribute:

[TypeConverter(typeof(MyNumberArrayConverter))]
public class MyNumberArray ...

Ensuite, implémentation de ce convertisseur de type en tant que dérivation de TypeConverter:

class MyNumberArrayConverter : TypeConverter
{
    public override bool CanConvertTo(ITypeDescriptorContext ctx, Type type)
    { return (type == typeof(string)); }

    public override bool CanConvertFrom(ITypeDescriptorContext ctx, Type type)
    { return (type == typeof(string)); }

    public override object ConvertTo(ITypeDescriptorContext ctx, CultureInfo ci, object value, Type type)
    {
        MyNumberArray arr = value as MyNumberArray;
        StringBuilder sb = new StringBuilder();
        foreach (int i in arr)
            sb.Append(i).Append(',');
        return sb.ToString(0, Math.Max(0, sb.Length - 1));
    }

    public override object ConvertFrom(ITypeDescriptorContext ctx, CultureInfo ci, object data)
    {
        List<int> arr = new List<int>();
        if (data != null)
        {
            foreach (string txt in data.ToString().Split(','))
                arr.Add(int.Parse(txt));
        }
        return new MyNumberArray(arr);
    }
}

En fournissant des méthodes pratiques sur la classe MyNumberArray, nous pouvons ensuite attribuer en toute sécurité à et à partir de List, la classe complète ressemblerait à quelque chose comme:

[TypeConverter(typeof(MyNumberArrayConverter))]
public class MyNumberArray : IEnumerable<int>
{
    List<int> _values;

    public MyNumberArray() { _values = new List<int>(); }
    public MyNumberArray(IEnumerable<int> values) { _values = new List<int>(values); }

    public static implicit operator List<int>(MyNumberArray arr)
    { return new List<int>(arr._values); }
    public static implicit operator MyNumberArray(List<int> values)
    { return new MyNumberArray(values); }

    public IEnumerator<int> GetEnumerator()
    { return _values.GetEnumerator(); }
    IEnumerator IEnumerable.GetEnumerator()
    { return ((IEnumerable)_values).GetEnumerator(); }
}

Enfin, pour l'utiliser dans les paramètres, vous ajoutez les classes ci-dessus à un assembly et compilez. Dans votre éditeur Settings.settings, cliquez simplement sur l'option "Parcourir" et sélectionnez la classe MyNumberArray et c'est parti.

Encore une fois, c'est beaucoup plus de code; cependant, il peut être appliqué à des types de données beaucoup plus compliqués qu'un simple tableau.

Spécifiez le paramètre en tant que System.Collections.ArrayList, puis:

Settings.Default.IntArray = new ArrayList(new int[] { 1, 2 });

int[] array = (int[])Settings.Default.IntArray.ToArray(typeof(int));

Une solution simple consiste à définir la valeur par défaut d'un paramètre sur null dans la propriété, mais dans le constructeur, vérifiez si la propriété est nulle et, le cas échéant, définissez-la sur sa valeur par défaut réelle. Donc, si vous vouliez un tableau d'entiers:

public class ApplicationSettings : ApplicationSettingsBase
{
    public ApplicationSettings()
    {
        if( this.SomeIntArray == null )
            this.SomeIntArray = new int[] {1,2,3,4,5,6};
    }

    [UserScopedSetting()]
    [DefaultSettingValue("")]
    public int[] SomeIntArray
    {
        get
        {
            return (int[])this["SomeIntArray"];
        }
        set
        {
            this["SomeIntArray"] = (int[])value;
        }
    }
}

Cela semble un peu piraté, mais c'est propre et fonctionne comme vous le souhaitez puisque les propriétés sont initialisées à leurs derniers paramètres (ou par défaut) avant que le constructeur ne soit appelé.

Utilisé System.Object.

Exemple:

byte[] arBytes = new byte[] { 10, 20, 30 };
Properties.Settings.Default.KeyObject = arBytes;

Extrait:

arBytes = (byte[])Properties.Settings.Default.KeyObject;

Je pense que vous avez raison de sérialiser vos paramètres. Voir ma réponse à cette question pour un exemple:

Techniques pour partager une configuration entre deux applications?

Vous auriez une propriété qui est un tableau, comme ceci:

/// <summary>
/// Gets or sets the height.
/// </summary>
/// <value>The height.</value>
[XmlAttribute]
public int [] Numbers { get; set; }

Créez des fonctions qui convertissent un tableau int en une chaîne, mais entre chacune, placez un caractère comme "" (espace).

Donc, si le tableau est {1,34,546,56}, la chaîne serait "1 34 645 56"