Typen mit dem XmlSerializer (de-)serialisieren

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216

public class Test : PropertyBase
{
	[XmlIgnore()]
	public Color Farbe
	{
		set 
		{ 
			Serializer.Set<Color>(value); 
		}
		get 
		{ 
			return Serializer.Get<Color>(); 
		}
	}
	[XmlIgnore()]
	public Color Farbe1
	{
		get 
		{ 
			return (Color)new ColorConverter().ConvertFromString(Serializer.GetProperty("Farbe1")); 
		}
		set 
		{ 
			Serializer.SetProperty("Farbe", new ColorConverter().ConvertToString(value)); 
		}
	}
	[XmlIgnore()]
	public Font Schriftart
	{
		set
		{
			Serializer.Set<Font>(value);
		}
		get
		{
			return Serializer.Get<Font>();
		}
	}
	[XmlIgnore()]
	public Rectangle Viereck
	{
		get { return Serializer.Get<Rectangle>(); }
		set { Serializer.Set<Rectangle>(value); }
			
	}
	[XmlIgnore()]
	public string Zeichenkette
	{
		get { return Serializer.Get<string>(); }
		set { Serializer.Set<string>(value); }
	}
	[XmlIgnore()]
	public int Zahl
	{
		get { return Serializer.Get<int>(); }
		set { Serializer.Set<int>(value); }
	}
	[XmlIgnore()]
	public DateTime Datum
	{
		get { return Serializer.Get<DateTime>(); }
		set { Serializer.Set<DateTime>(value); }
	}

	public Test()
	{ }
}

[Serializable]
public abstract class PropertyBase
{
	public PropertySerializer Serializer { get; set; }
	public PropertyBase()
	{
		Serializer = new PropertySerializer();
	}
}

[Serializable]
public class Property
{
	[XmlAttribute()]
	public string Name;
	[XmlAttribute()]
	public string Value;
	public Property()
	{ }
	public Property(string name, string value)
	{
		Name = name;
		Value = value;
	}
	public override string ToString()
	{
		return Name + " : " + Value;
	}
}
[Serializable]
public class PropertySerializer
{
	/// <summary>
	/// Die Liste mit den Eigenschaften und deren Werten.
	/// </summary>
	public List<Property> Properties { get; set; }
	/// <summary>
	/// Initialisiert eine neue Instanz dieser Klasse.
	/// </summary>
	public PropertySerializer()
	{
		Properties = new List<Property>();
	}

	/// <summary>
	/// Trägt die Eigenschaft und deren Wert in die Liste <see cref="Properties"/> ein.
	/// Nicht vorhandene Eigenschaften werden hinzugefügt, vorhandene aktualisiert.
	/// </summary>
	/// <param name="name">Der Name der Eigenschaft.</param>
	/// <param name="value">Der Wert der Eigenschaft</param>
	public void SetProperty(string name, string value)
	{
		int i = Properties.FindIndex(x => x.Name == name);

		if (i > -1)
		{
			Properties[i].Value = value;
		}
		else
		{
			Properties.Add(new Property(name, value));
		}
	}
	/// <summary>
	/// Ruft den Wert der angegebenen Eigenschaft ab.
	/// </summary>
	/// <param name="name">Der Name der Eigenschaft.</param>
	/// <returns>Den Wert der Eigenschaft, oder eine leere Zeichenkette, wenn die
	/// Eigenschaft nicht vorhanden ist.</returns>
	public string GetProperty(string name)
	{
		int i = Properties.FindIndex(x => x.Name == name);
		if (i > -1)
		{
			return Properties[i].Value;
		}
		else
		{
			return String.Empty;
		}
	}
	/// <summary>
	/// Legt den Wert einer Eigenschaft fest.
	/// </summary>
	/// <typeparam name="T">Der Typ der Eigenschaft.</typeparam>
	/// <param name="value">Der Wert der Eigenschaft.</param>
	public void Set<T>(T value)
	{
		string s = new StackTrace(System.Threading.Thread.CurrentThread, true)
		.GetFrame(1)
		.GetMethod().Name;

		s = s.Substring(4, s.Length - 4);

		SetProperty(s, TypeDescriptor.GetConverter(typeof(T)).ConvertToString(value));
	}
	/// <summary>
	/// Ruft den Wert einer Eigenschaft ab.
	/// </summary>
	/// <typeparam name="T">Der Typ der Eigenschaft.</typeparam>
	/// <returns>Den Wert der Eigenschaft.</returns>
	public T Get<T>()
	{
		string s = new StackTrace(System.Threading.Thread.CurrentThread, true)
		.GetFrame(1)
		.GetMethod().Name;

		s = s.Substring(4, s.Length - 4);

		string value = GetProperty(s);

		return (T)TypeDescriptor.GetConverter(typeof(T)).ConvertFromString(value);
	}

	/// <summary>
	/// Speichert eine Klasse.
	/// </summary>
	/// <typeparam name="T">Der Typ der zu ladenden Klasse.</typeparam>
	/// <param name="candidate">Die zu speichernde Klasse.</param>
	/// <param name="path">Der vollqualifizierte Name der Zieldatei.</param>
	public static void Save<T>(T candidate, string path) where T : PropertyBase
	{
		XmlSerializer ser = new XmlSerializer(typeof(T));
		using (FileStream str = new FileStream(path, FileMode.Create))
		{
			ser.Serialize(str, candidate);
		}
	}
	/// <summary>
	/// Läd eine Klasse.
	/// </summary>
	/// <typeparam name="T">Der Typ der zu ladenden Klasse.</typeparam>
	/// <param name="path">Der vollqualifizierte Name der Quelldatei.</param>
	/// <returns>Die geladene Instanz der Klasse.</returns>
	public static T Load<T>(string path) where T :PropertyBase
	{
		XmlSerializer xser = new XmlSerializer(typeof(T));
		T ps;

		using (StreamReader sr = new StreamReader(path))
		{
			ps = (T)xser.Deserialize(sr);
			sr.Close();
		}

		return ps;
	}
}