Serialisierung der Klasse abgeleitet von List<> mit DataContract

Ich versuche zu serialisieren, die eine abgeleitete Klasse von List<> mit DataContract. Das problem ist, dass die Eigenschaften meiner Klasse nicht serialisiert.

Meine Klassen:

[CollectionDataContract] /*[Serializable]*/ /*[DataContract]*/
public class DownloadRuleCollection : List<DownloadRule> {

    [DataMember(EmitDefaultValue = false)]
    public string SomeProperty { get; set; }
    //this is, in fact, more complex, but this is enough for the example
}

[DataContract]
public class DownloadRule {
    [DataMember(EmitDefaultValue = false)]
    public string Name { get; set; }

    /*
     more properties
     ...
     */
}

Test:

static void Main(string[] args) {

    //fill test collection with some data...
    var col = new DownloadRuleCollection { SomeProperty = "someText" };

    var rule = new DownloadRule { Name = "test01" };
    col.Add(rule);

    rule = new DownloadRule { Name = "test02" };
    col.Add(rule);

    rule = new DownloadRule { Name = "test03" };
    col.Add(rule);

    //serialize
    Console.WriteLine("serializing");

    Serialize(col, "serializationTest.xml");

    Console.WriteLine("serialized");
    Console.ReadLine();
}

Ergebnis:

<?xml version="1.0" encoding="utf-8"?>
<ArrayOfDownloadRule xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.datacontract.org/2004/07/ConsoleApplication1">
  <DownloadRule>
    <Name>test01</Name>
  </DownloadRule>
  <DownloadRule>
    <Name>test02</Name>
  </DownloadRule>
  <DownloadRule>
    <Name>test03</Name>
  </DownloadRule>
</ArrayOfDownloadRule>

Wie Sie sehen können, die Liste der Elemente serialisiert werden (und Deserialisierung) richtig, aber die Liste selbst nicht serialisiert. Ich habe versucht, die unterschiedliche Attribute verwenden:
[Serializable], keine änderung;
[DataContract], wirft Ausnahme, die während der Serialisierung (Sammlungen cant verwenden Sie dieses Attribut)

btw ich bin mit der Serialisierung auch private Felder, so kann ich nicht verwenden XmlSerializer (oder andere Klassen, die nicht serialisiert werden private Felder).

InformationsquelleAutor Markos | 2010-08-07

c#datacontract serialization

Verwenden IList statt. Das sollte serialisieren richtig.

    [CollectionDataContract] /*[Serializable]*/ /*[DataContract]*/
    public class DownloadRuleCollection : IList<DownloadRule> {

Hier ist ein Beispiel, das ich verwenden und funktioniert perfekt:

    [DataContract(Namespace="http://schemas.datacontract.org/2004/07/InboundIntegration.HL7Messaging")]
    public class Message {

        public Message() {
            InsuranceList = new List<Insurance>();
            MessageId = GuidComb.NewGuid();
        }

        [IgnoreDataMember]
        public Guid MessageId { get; private set; }

        #region "Data"
        [DataMember]
        public string MessageTypeIndicator { get; set; }
        [DataMember]
        public MessageConfiguration MessageConfiguration { get; set; }
        [DataMember]
        public Patient Patient { get; set; }
        [DataMember]
        public Encounter Encounter { get; set; }
        [DataMember]
        public IList<Insurance> InsuranceList { get; set; }
        #endregion

Dann Versicherungs-Klasse sieht wie folgt aus:

 [DataContract(Namespace = "http://schemas.datacontract.org/2004/07/InboundIntegration.HL7Messaging")]
    public class Insurance {
        [DataMember]
        public string ExternalPayerId { get; set; } 
        [DataMember]
        public string PayerName { get; set; }
        [DataMember]
        public string GroupNumber { get; set; }
        [DataMember]
        public string MemberIdOfPatient { get; set; }
        [DataMember]
        public string PatientRelationshipToInsuredIndicator { get; set; }
        [DataMember]
        public string CoordinationOfBenefitsPrecedenceIndicator { get; set; }

Nein, das ist nicht das, was ich brauche. Ich habe kein problem mit der Serialisierung der DownloadRule Klasse, ich habe ein problem mit dem serialisieren der DownloadRuleCollection selbst, vor allem seine Eigenschaften.

InformationsquelleAutor Chris Kooken

Ok, also Climber104 die Lösung funktionieren würde, aber ich brauchen würde, zu re-implementieren alle List's Methoden, die macht mich fühle, dass ich das Rad neu erfinden.

JaredPar von Jarek Waliszko thread-schlägt die Verwendung einer wrapper-Klasse.

Das einfachste ist, es zu benutzen, nur um der Serialisierungs-Prozess, so benutzte ich einen geschützten inneren wrapper-Klasse. Dies ermöglicht es mir, meine Ziele zu erreichen, mit nur ein paar Zeilen code benötigt.

public class DownloadRuleCollection : List<DownloadRule> {

    public string SomeProperty { get; set; }

    public void Serialize(string fileName) {
        Serializer.Serialize(
            new DownloadRuleCollection_SerializationWrapper {
                Collection = this,
                SomeProperty = SomeProperty
            }, fileName);
    }

    public static DownloadRuleCollection Deserialize(string fileName) {
        var wrapper = Serializer.Deserialize<DownloadRuleCollection_SerializationWrapper>(fileName);

        var result = wrapper.Collection;
        result.SomeProperty = wrapper.SomeProperty;

        return result;
    }

    [DataContract(Name = "DownloadRuleCollection")]
    private class DownloadRuleCollection_SerializationWrapper {

        [DataMember(EmitDefaultValue = false, Name = "SomeProperty", Order = 0)]
        public string SomeProperty { get; set; }

        [DataMember(EmitDefaultValue = false, Name = "DownloadRules", Order = 1)]
        public DownloadRuleCollection Collection;

    }
}

[DataContract]
public class DownloadRule {
    [DataMember(EmitDefaultValue = false)]
    public string Name { get; set; }
}

public static class Serializer {
    public static void Serialize<T>(T obj, string fileName) {
        using(XmlWriter writer = XmlWriter.Create(fileName, new XmlWriterSettings { Indent = true }))
            new DataContractSerializer(typeof(T)).WriteObject(writer, obj);
    }

    public static T Deserialize<T>(Stream stream) {
        return (T)new DataContractSerializer(typeof(T)).ReadObject(stream);
    }

    public static T Deserialize<T>(string fileName) {
        using(FileStream fs = File.OpenRead(fileName)) {
            return Deserialize<T>(fs);
        }
    }
}

eleganter code Dank !

InformationsquelleAutor Markos

1

Überprüfen, dass die post, ich glaube, es kann Ihnen helfen,

c# Vererbung-generische Erfassung und Serialisierung

InformationsquelleAutor jwaliszko

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.