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.