Array in den Settings möglich

  • VB.NET

Es gibt 10 Antworten in diesem Thema. Der letzte Beitrag () ist von oobdoo.

    Array in den Settings möglich

    Ich habe folgende Klasse und dazu kam mir folgende Frage in den Kopf.

    VB.NET-Quellcode

    1. Public Class Zeichensatz
    2. Public CPCSymbole() As Byte = {255, 195, 195, 195, 195, [...] }
    3. End Class

    Kann man sowas auch in den Settings ablegen?
    Aktuelles Projekt: Z80 Disassembler für Schneider/Amstrad CPC :love:
    @oobdoo Probier mal die ArrayList, die ist allerdings untypisiert.
    Ob das funktioniert, weiß ich nicht.
    Bilder
    • Settings.jpg

      34,8 kB, 580×483, 78 mal angesehen
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    VB-Fragen über PN / Konversation werden ignoriert!
    Dein Array ist ein Byte-Array.
    Wenn du Settings anlegst kannst du ja den Datentyp mittels Combobox bestimmen. Wird Byte-Array da angeboten?

    Meines Wissens nicht.
    Man kann es allerdings ziemlich leicht hacken, aber ich hab vergessen wie das geht.

    Meine Überlegung ist einfach, das Byte() mit Convert.ToBase64String in einen String zu überführen, und den in die Settings tun.
    @oobdoo Dann mach Dir einfach eine eigene serialisierbare Settings-Klasse und pack da rein, was immer Du brauchst.
    Ich hab hier ein Beispiel in C#:
    Settings

    C#-Quellcode

    1. using System.IO;
    2. using System.Xml.Serialization;
    3. namespace MySettings
    4. {
    5. /// <summary>
    6. /// Serialisierbare Klasse, die Parameter hält
    7. /// </summary>
    8. public class MySettings
    9. {
    10. /// <summary>
    11. /// Der Name der Settings
    12. /// </summary>
    13. public string Name { get; set; }
    14. /// <summary>
    15. /// Property 1
    16. /// </summary>
    17. public bool Property1 { get; set; }
    18. /// <summary>
    19. /// Property 2
    20. /// </summary>
    21. public int Property2 { get; set; }
    22. /// <summary>
    23. /// ein Byte-Array
    24. /// </summary>
    25. public int[] MyArray { get; set; }
    26. /// <summary>
    27. /// Standardkonstruktor der Klasse MySettings
    28. /// </summary>
    29. public MySettings()
    30. {
    31. this.Name = "Empty";
    32. this.Property1 = true;
    33. this.Property2 = 42;
    34. this.MyArray = new int[] { 1, 2, 3, 4, 5 };
    35. }
    36. /// <summary>
    37. /// Standardkonstruktor der Klasse MySettings
    38. /// </summary>
    39. /// <param name="name">Name der Settings</param>
    40. public MySettings(string name)
    41. : this()
    42. {
    43. this.Name = name;
    44. }
    45. }
    46. /// <summary>
    47. /// Klasse, die die Settings speichert und lädt
    48. /// </summary>
    49. public static class SettingsHandling
    50. {
    51. /// <summary>
    52. /// Speichern der Settings als XML-Datei
    53. /// </summary>
    54. /// <param name="settings">zu speichernde Settings</param>
    55. /// <param name="path">Pfad zum Speichern</param>
    56. public static void WriteSettings(MySettings settings, string path)
    57. {
    58. if (settings == null)
    59. {
    60. return;
    61. }
    62. // Serialize object to a text file.
    63. using (StreamWriter sw = new StreamWriter(path))
    64. {
    65. XmlSerializer x = new XmlSerializer(settings.GetType());
    66. x.Serialize(sw, settings);
    67. }
    68. }
    69. /// <summary>
    70. /// Laden der Settings
    71. /// </summary>
    72. /// <param name="path">Name der Settings</param>
    73. /// <returns>Pfad zum Laden</returns>
    74. public static MySettings ReadSettings(string path)
    75. {
    76. MySettings settings = new MySettings();
    77. try
    78. {
    79. // Deserialize text file to a new object.
    80. using (StreamReader sr = new StreamReader(path))
    81. {
    82. XmlSerializer x = new XmlSerializer(settings.GetType());
    83. settings = (MySettings)x.Deserialize(sr);
    84. }
    85. }
    86. catch
    87. {
    88. // nix tun, die Settings-Instanz ist nicht valid,
    89. // es werden die Default-Werte zurückgegeben
    90. }
    91. return settings;
    92. }
    93. }
    94. }
    Aufruf

    C#-Quellcode

    1. string path = @"c:\Temp\xxx.xml";
    2. MySettings settings = new MySettings("bla");
    3. SettingsHandling.WriteSettings(settings, path);
    4. // ...
    5. MySettings settings2 = SettingsHandling.ReadSettings(path);
    Bytes werden da als String abgelegt, deswegen ein int-Array.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    VB-Fragen über PN / Konversation werden ignoriert!
    Naja, so wichtig ist es mit der Umsetzung nicht. Wie gesagt, ich wollte nur allgemein Wissen ob es machbar ist.

    Dazu ist mir noch eingefallen, man könnte die Zahlenkolonne 255, 195, 195, 195, 195,... auch als als normalen String in den Settings ablegen und und entsprechend umwandeln.
    Aktuelles Projekt: Z80 Disassembler für Schneider/Amstrad CPC :love:
    jo, das wäre aber langsam, speicherfressend, und v.a. vergleichsweise unsicher.
    Also eine Umwandlung wirst du so oder so coden müssen, und da empfehle ich halt Convert.ToBase64String()/.FromBase64String() - da ist genau definiert, was gemacht wird.
    Selbstgebastelte StringParsereien gehen leicht immer wieder mal ins Auge, auch in diesem einfachen Fall.
    Ich hab's jetzt probiert...
    Bei den Settings-Einstellungen einfach auf <>Code anzeigen gehen und folgende Klasse in Settings.vb erstellen
    Settings.vb

    VB.NET-Quellcode

    1. Imports System.Configuration
    2. Namespace My
    3. Partial Friend NotInheritable Class MySettings
    4. <UserScopedSettingAttribute()> _
    5. Public Property myIntArray As Integer()
    6. Get
    7. Return CType(Me("myIntArray"), Integer())
    8. End Get
    9. Set(ByVal value As Integer())
    10. Me("myIntArray") = value
    11. End Set
    12. End Property
    13. End Class
    14. End Namespace

    Damit erstellt man sich in den Settings die myIntArray-Eigenschaft und kann sie dann verwenden...
    Test

    VB.NET-Quellcode

    1. Private Sub Button_Click(sender As Object, e As EventArgs) Handles Button1.Click
    2. If My.Settings.myIntArray Is Nothing Then
    3. MessageBox.Show("Es gibt noch keine Daten...", "My.Settings.myIntArray")
    4. '
    5. Dim myArray As Integer() = {1, 2, 3}
    6. My.Settings.myIntArray = myArray
    7. MessageBox.Show("jetzt mit Daten gefüllt...", "My.Settings.myIntArray")
    8. Application.Exit()
    9. Else
    10. MessageBox.Show("Neustart: Jetzt gibt es Daten...", "My.Settings.myIntArray")
    11. Dim x = My.Settings.myIntArray
    12. '
    13. Stop
    14. Return
    15. End If
    16. End Sub

    Und die Settings-Daten werden dann im Pfad C:\Users\*****\AppData\Local\My\*****\user.config abgelegt und können nach einem Neustart wieder verwendet und geändert werden...
    user.config.xml

    XML-Quellcode

    1. <?xml version="1.0" encoding="utf-8"?>
    2. <configuration>
    3. <configSections>
    4. <sectionGroup name="userSettings">
    5. <section name="My.MySettings" type="System.Configuration.ClientSettingsSection, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" allowExeDefinition="MachineToLocalUser" requirePermission="false" />
    6. </sectionGroup>
    7. </configSections>
    8. <userSettings>
    9. <My.MySettings>
    10. <setting name="myIntArray" serializeAs="Xml">
    11. <value>
    12. <ArrayOfInt xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
    13. <int>1</int>
    14. <int>2</int>
    15. <int>3</int>
    16. </ArrayOfInt>
    17. </value>
    18. </setting>
    19. </My.MySettings>
    20. </userSettings>
    21. </configuration>