[C#] + Serialize enum

[Verwijderd]

Ik heb een klasse persoon en deze wil ik middels serialization naar een xml bestand zetten.
Ik heb echter iets specifieks dat ik niet voor elkaar krijg.

C#:

[Serializable]
    public class Persoon
    {       
        public string naam;
        public string achternaam; 
        public enums.Geslacht geslacht;
      
        public Persoon()
        {

        }        
    }

Wanneer ik dit ga serialiseren dan komt er uit:

XML:

<Persoon>
 <naam>Piet</naam>
 <achternaam>Veerman</achternaam>
 <geslacht>Man</geslacht>
</Persoon>

ik wil echter ipv <geslacht>Man</geslacht>
De value van het enum ook meegeven:
<geslacht id=1>Geslacht</geslacht>

Ik dacht de oplossing te hebben door onderstaande te gebruiken:

C#:

public enum Geslacht
{
    [EnumMember(Value = "1")]
    Man
}

maar dan krijg ik <geslacht>1</geslacht>

[Woy]

mischien kan je hier iets mee http://msdn.microsoft.com/en-us/library/83y7df3e.aspx

[whoami]

Als je echt de structuur van je geserializeerde XML wilt gaan bepalen, denk ik dat je niet veel anders zult kunnen dan ISerializable te implementeren, en zelf voor je serializatie gaan zorgen.
Je kan ook gebruik maken van XmlSerializable, maar dat werkt dan weer iets anders dan de gewone serializatie met soap of binary formatters.

[Verwijderd]

Volgens mij kan je niet 2 attributen aan een item hangen wel?

Ik had het in 1e instantie zoals onderstaand, maar als de klasse wijzigt dan levert dat meer werk op.
Vandaar dat ik het met serialization probeer.

C#:

            string id = ((int)persoon.geslacht).ToString();
            string value = persoon.geslacht.ToString();

            XmlDocument xDoc = new XmlDocument();           
            XmlNode node = xDoc.AppendChild(xDoc.CreateElement("Persoon"));
            
            XmlElement l = xDoc.CreateElement("geslacht");
            l.SetAttribute("id", id);
            l.InnerText = value;
            node.AppendChild(l);

[Haan]

Volgens mij kan je zoveel attributen aan je node hangen als je maar wil (in ieder geval meer dan 1)

Je ziet vaak genoeg iets als

XML:

<Item name="name" value="1" id="1" />

[ Voor 30% gewijzigd door Haan op 23-05-2008 10:53 ]

[Verwijderd]

whoami schreef op vrijdag 23 mei 2008 @ 10:44:
Als je echt de structuur van je geserializeerde XML wilt gaan bepalen, denk ik dat je niet veel anders zult kunnen dan ISerializable te implementeren, en zelf voor je serializatie gaan zorgen.
Je kan ook gebruik maken van XmlSerializable, maar dat werkt dan weer iets anders dan de gewone serializatie met soap of binary formatters.

Ik zal eens een example zoeken op internet, want met ISerializable heb ik nog geen ervaring.
weet ik in ieder geval in welke hoek ik het moet zoeken.

[Verwijderd]

Haan schreef op vrijdag 23 mei 2008 @ 10:52:
Volgens mij kan je zoveel attributen aan je node hangen als je maar wil (in ieder geval meer dan 1)

Je ziet vaak genoeg iets als

XML:

<Item name="name" value="1" id="1" />

Mijn vorige post, was niet helemaal duidelijk.
Dit was een reactie op RWB, die een lijst met attributes to control xml serialization postte.

[MrSleeves]

Haan schreef op vrijdag 23 mei 2008 @ 10:52:
Volgens mij kan je zoveel attributen aan je node hangen als je maar wil (in ieder geval meer dan 1)

Je ziet vaak genoeg iets als

XML:

<Item name="name" value="1" id="1" />

Ja, maar niet als je één element serializeert.

Waarschijnlijk kan het niet standaard, omdat het onwenselijk is. Je slaat twee keer dezelfde informatie op. En wat als die id of de tekst verandert?

[Amras]

MrSleeves schreef op vrijdag 23 mei 2008 @ 10:59:
[...]
Waarschijnlijk kan het niet standaard, omdat het onwenselijk is. Je slaat twee keer dezelfde informatie op. En wat als die id of de tekst verandert?

Inderdaad. Stel je wijzigt het XML-bestand en er staat: <geslacht id="2">Man</geslacht>, welke waarde wordt er dan bij deserialization gebruikt voor geslacht in het persoon object? Daarom zal het waarschijnlijk niet mogelijk zijn om twee van deze attributen op een property te plaatsen.

[Verwijderd]

whoami schreef op vrijdag 23 mei 2008 @ 10:44:
Als je echt de structuur van je geserializeerde XML wilt gaan bepalen, denk ik dat je niet veel anders zult kunnen dan ISerializable te implementeren, en zelf voor je serializatie gaan zorgen.
Je kan ook gebruik maken van XmlSerializable, maar dat werkt dan weer iets anders dan de gewone serializatie met soap of binary formatters.

Bedoel je dan dat ik in de klasse GetObjectData moet gaan gebruiken?

code:

 public class Persoon : ISerializable
    {  
       ...
        public void GetObjectData(SerializationInfo info, StreamingContext context)
        {

[Niemand_Anders]

Ik denk dat je even moet stoppen met vragenstellen, en dit weekend de tijd nemen om over Serialization in de MSDN te lezen. Daarna is waarschijnlijk al een hoop duidelijk.

[MrSleeves]

En antwoord geven op de vraag: waarom wil je dezelfde info twee keer opslaan?

[Verwijderd]

Niemand_Anders schreef op vrijdag 23 mei 2008 @ 11:45:
Ik denk dat je even moet stoppen met vragenstellen, en dit weekend de tijd nemen om over Serialization in de MSDN te lezen. Daarna is waarschijnlijk al een hoop duidelijk.

Ben ik inderdaad nu mee bezig want ander ben je wat aan het freewheelen en doe je maar wat.
Eerdere code slaat dus helemaal nergens op...

[Verwijderd]

Ik ben al een stap verder, namelijk dat ik het Node kan wijzigen.
Node Geslacht wordt nu type.
Dat is me gelukt, nu wil ik echter nog een attribute aan deze gewijzigde node toevoegen.

code:

     XmlElementAttribute myElementAttribute = new XmlElementAttribute();
      myElementAttribute.ElementName = "type";                  

      XmlAttributes myAttributes = new XmlAttributes();
     myAttributes.XmlElements.Add(myElementAttribute);

     XmlAttributeOverrides myOverrides = new XmlAttributeOverrides();
     myOverrides.Add(typeof(T), "geslacht", myAttributes);

     XmlSerializer xs = new XmlSerializer(typeof(Persoon), myOverrides);

[Janoz]

Ik ben nog steeds heel erg benieuwd naar het antwoord op beide vragen die door MrSleeves gesteld zijn.

waarom wil je dezelfde info twee keer opslaan?

en

En wat als die id of de tekst verandert?

[Verwijderd]

Janoz schreef op maandag 26 mei 2008 @ 10:59:
Ik ben nog steeds heel erg benieuwd naar het antwoord op beide vragen die door MrSleeves gesteld zijn.

[...]

en

[...]

Dat is iets wat helaas moet.
Ik moet XML aanleveren aan een webservice van een ander bedrijf.
Deze webservice dient er dus op die manier uit te zien anders krijg ik geen feedback.

En het zijn items die "nooit" wijzigen (man=0/ vrouw=1)

[ Voor 6% gewijzigd door Verwijderd op 26-05-2008 11:15 ]

[Verwijderd]

Ik dacht dat ik er bijna was door het attribute te wijzigen.

code:

XmlAttributeAttribute xAtt = new XmlAttributeAttribute();
xAtt.AttributeName = "id";

XmlAttributes myAttributes = new XmlAttributes();
myAttributes.XmlAttribute = xAtt;

XmlAttributeOverrides myOverrides = new XmlAttributeOverrides();
myOverrides.Add(typeof(persoon), "geslacht", myAttributes);

XmlSerializer xs = new XmlSerializer(typeof(Persoon), myOverrides);

Het resultaat is echter een wijziging op een hoger niveau dan ik had verwacht.
Wat er nu gebeurd is dat geslacht een attribute wordt van persoon met de naam code

code:

<Persoon id="man">
</Persoon>

terwijl ik wil

code:

<persoon>
<geslacht id=>MAN</geslacht>
</persoon>

[Janoz]

Verwijderd schreef op maandag 26 mei 2008 @ 11:14:
[...]


Dat is iets wat helaas moet.
Ik moet XML aanleveren aan een webservice van een ander bedrijf.
Deze webservice dient er dus op die manier uit te zien anders krijg ik geen feedback.

Tja, dat is nogal een onbevredigend antwoord moet ik zeggen. Kun je niet eens naavragen waarom ze voor deze manier gekozen hebt?

En het zijn items die "nooit" wijzigen (man=0/ vrouw=1)

Dat gegevens 'nooit' wijzigen is niet zo relevant. Wat belangrijker is is hoe je serializer er mee om moet gaan. Als de inhoud zegt dat het een mannetje is, maar het attribuut beweerd dat het een vrouwtje is, wat is het dan?

[Verwijderd]

Janoz schreef op maandag 26 mei 2008 @ 11:52:
[...]

Tja, dat is nogal een onbevredigend antwoord moet ik zeggen. Kun je niet eens naavragen waarom ze voor deze manier gekozen hebt?

[...]

Dat gegevens 'nooit' wijzigen is niet zo relevant. Wat belangrijker is is hoe je serializer er mee om moet gaan. Als de inhoud zegt dat het een mannetje is, maar het attribuut beweerd dat het een vrouwtje is, wat is het dan?

De enige reden om het zo te doen is om een leesbare waarde te hebben en een waarde die men gebruikt.

Op dit moment heb ik het voor elkaar door onderstaande oplossing.
Het werkt, maar volgens mij zijn er nettere mogelijkheden.

code:

 StringBuilder sb = new StringBuilder();
TextWriter tw = new StringWriter(sb);

XmlSerializer xs = new XmlSerializer(typeof(T));
xs.Serialize(tw, Object);

XmlDocument doc = new XmlDocument();
doc.LoadXml(sb.ToString());

 XmlNode PropA = doc.SelectSingleNode("//geslacht");
if (PropA != null)
 {
     XmlAttribute Attr = doc.CreateAttribute("id");
     Attr.Value = "hello";

     PropA.Attributes.Append(Attr);
}
return doc.InnerXml;

[DoubleTweak]

Check deze link eens:

http://www.devhood.com/Tu...ails.aspx?tutorial_id=236

Volgens mij vind je daar wat je zoekt... ([XmlAttribute])

Verwijderd schreef op maandag 26 mei 2008 @ 12:12:
[...]


De enige reden om het zo te doen is om een leesbare waarde te hebben en een waarde die men gebruikt.

Op dit moment heb ik het voor elkaar door onderstaande oplossing.
Het werkt, maar volgens mij zijn er nettere mogelijkheden.

code:

 StringBuilder sb = new StringBuilder();
TextWriter tw = new StringWriter(sb);

XmlSerializer xs = new XmlSerializer(typeof(T));
xs.Serialize(tw, Object);

XmlDocument doc = new XmlDocument();
doc.LoadXml(sb.ToString());

 XmlNode PropA = doc.SelectSingleNode("//geslacht");
if (PropA != null)
 {
     XmlAttribute Attr = doc.CreateAttribute("id");
     Attr.Value = "hello";

     PropA.Attributes.Append(Attr);
}
return doc.InnerXml;