String property wahlweise auch als XmlNode serialisieren

[StehtimSchilf]

Hoi Forum, ich nochmals.

Ich habe eine simple Klasse wie folgt:

Serializable(), XmlRoot(ElementName="ServerResponse")]
public class ServerResponse {
	[XmlElement("Code")]
	public int Code { get; set; }

	[XmlElement("Value")]
	public String Value { get; set; }
}

Bisher habe ich hier nur ints und strings verwendet.

Jetzt wäre es jedoch praktisch, wenn ich in Value wiederum ein XML schreiben könnte, damit ich auf der anderen Seite das XML wieder rauslesen kann.

Nur, wenn ich bspw.:

this.Value = "<TestNode><SubNode1>bla</SubNode1></TestNode>";

erhalte ich (logischerweise) auf nach dem Serialisieren als Inhalt in "Value":
<TestNode><SubNode1>bla</SubNode1></TestNode>

Das möcht ich aber nicht, sondern eben ein nicht HTML kodiertes XML.

Die Klasse ServerResponse wird immer als Kindelement serialisiert:

<Bla1>
	<ServerResponse>
		<Code>1234</Code>
		<Value>Hallo Welt</Value>
	</ServerResponse>
</Bla1>

<Bla2>
	<ServerResponse>
		<Code>133</Code>
		<Value>1111</Value>
	</ServerResponse>
</Bla2>

Nun möchte ich eben eine weiteres ParentElement erstellen, bei dem jedoch Value eine XML-Struktur enthält:

<Bla3>
	<ServerResponse>
		<Code>133</Code>
		<Value>
			<TestNode>
				<SubNode1>1</SubNode1>
				<SubNode2>asdf</SubNode2>
				<SubNode3>12.12.2011</SubNode3>
			</TestNode>
		</Value>
	</ServerResponse>
</Bla3>

Die "andere Seite" weiss also, dass wenn "bla3" daherkommt, ist in in Value eine XML-Struktur enthalten. Natürlich kann ich dann einfach sagen, dann muss man eben Value noch HTML dekodieren. Aber das finde ich nicht schön.

Wie könnt ich das lösen?

ich hab mir natürlich auch überlegt, für "TestNode" wiederum eine Klasse zu machen und diese wieder zu serialisieren, aber das löst das Problem nicht, dass ich einmal einen String haben möchte und einmal eine XML-Struktur.

Auch könnte ich die Klasse "TestNode" direkt als Kindelement an Bla3 anhängen, aber das gefällt mir nicht, da ich dann nicht einfach nur den Wert von Value auslesen muss.

Kann ich den ein Property vom Typ Object erstellen und der Serializier merkt dann, aha, das ist vom Typ String, ich serialisier das mal einfach so, aha das ist vom Typ TestNode, ich serialisier das gemäss den Angaben in der Klasse?

Am allerliebsten wäre mir jedoch, wenn der Serializer mein Value als XmlNode behandelt und nur die Inhalte serialisiert, aber nicht die Xml-Tags.

hmmm... Ideen?

cheerioh & thx
SiS

 

[StehtimSchilf]

4h und 4 Cafés.... aber nun hab ich was gefunden:

Ich habe die Klasse "ServerResponse" nun doch um ein neues Property "AdditionalData" ergänzt (das alte String-Property kann ich dann ja mal entfernen).

Wie erwähnt, habe ich dazu auch eine neue Klasse geschrieben, recht simpel:

[XmlRoot(ElementName="AdditionalData"),
XmlInclude(typeof(String)), XmlInclude(typeof(TestNode))]
public class AdditionalData {
	[XmlElement("Value")]
	public Object Value { get; set; }

	public AdditionalData() {
		// for serialization            
	}
	public AdditionalData(object Value) {
		this.Value = Value;
	}
}

Die ServerResponse-Klasse so:

[Serializable(), XmlRoot(ElementName = "ServerResponse")]
public class ServerResponse{
	[XmlElement("Code")]
	public int Code { get; set; }

	[Obsolete("Retreive Value from AdditionalData/Value")]
	[XmlElement("Value")]
	public String Value { get; set; }

	[XmlElement("AdditionalData")]
	public AdditionalData AdditionalData { get; set; }
}

Jiu und nun kann ich wahlweise:

ServerResponse response = new ServerResponse();
response.Code = bla();
response.AdditionalData = new AdditionalValue("hello World");
string xml = response.Serialize();
...

oder eben:

ServerResponse response = new ServerResponse();
response.Code = bla();
TestNode tn = new TestNode(1, 2, 3, "A", "B", "C");
response.AdditionalData = new AdditionalValue(tn);
string xml = response.Serialize();
...

Ich glaube ich bin so zufrieden, ausser jemand hat Einwände?

cheerioh SiS

 

[Shakie]

Ich hab's nicht ganz kapiert, was du machen willst, aber vielleicht findest du das IXmlSerializable-Interface ganz nützlich.