Serialisieren eines Nullable<DateTime> XML

Ich versuche zu serialisieren einer Klasse mehrere der Daten-Mitglieder sind Nullable-Objekten, hier ist ein Beispiel

[XmlAttribute("AccountExpirationDate")]
public Nullable<DateTime> AccountExpirationDate 
{ 
  get { return userPrincipal.AccountExpirationDate; } 
  set { userPrincipal.AccountExpirationDate = value; } 
}

Aber zur Laufzeit bekomme ich die Fehlermeldung

Nicht serialisieren Mitglied "- AccountExpirationDate' des Typs System.Nullable`1[System.DateTime]. XmlAttribute/XmlText kann nicht verwendet werden zum codieren komplexer Typen.

Jedoch habe ich überprüft und Nullable ist ein SerializableAttribute. Was mache ich falsch?

InformationsquelleAutor der Frage Scott Chamberlain | 2010-01-15

c#nullable xml-serialization

28

Können Sie nur zu serialisieren als XmlElementnicht als XmlAttributeda die Darstellung zu Komplex für ein Attribut. Das ist es, was die Ausnahme ist, sagen Sie.

InformationsquelleAutor der Antwort David M

Wenn Sie nur wollen, es zu Arbeitdann vielleicht:

using System;
using System.ComponentModel;
using System.Xml.Serialization;
public class Account
{
    //your main property; TODO: your version
    [XmlIgnore]
    public Nullable<DateTime> AccountExpirationDate {get;set;}

    //this is a shim property that we use to provide the serialization
    [XmlAttribute("AccountExpirationDate")]
    [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
    public DateTime AccountExpirationDateSerialized
    {
        get {return AccountExpirationDate.Value;}
        set {AccountExpirationDate = value;}
    }

    //and here we turn serialization of the value on/off per the value
    [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
    public bool ShouldSerializeAccountExpirationDateSerialized()
    {
        return AccountExpirationDate.HasValue;
    }

    //test it...
    static void Main()
    {
        var ser = new XmlSerializer(typeof(Account));
        var obj1 = new Account { AccountExpirationDate = DateTime.Today };
        ser.Serialize(Console.Out, obj1);
        Console.WriteLine();
        var obj2 = new Account { AccountExpirationDate = null};
        ser.Serialize(Console.Out, obj2);
    }
}

Dieser wird nur das Attribut, wenn es eine nicht-null-Wert.

InformationsquelleAutor der Antwort Marc Gravell

Ich habe so etwas wie dies viele Male.

[XmlIgnore]
public Nullable<DateTime> AccountExpirationDate 
{ 
    get { return userPrincipal.AccountExpirationDate; } 
    set { userPrincipal.AccountExpirationDate = value; } 
}

///
///<summary>Used for Xml Serialization</summary>
///
[XmlAttribute("AccountExpirationDate")]
public string AccountExpirationDateString
{
    get
    {
        return AccountExpirationDate.HasValue
            ? AccountExpirationDate.Value.ToString("yyyy/MM/dd HH:mm:ss.fff")
            : string.Empty;
    }
    set
    {
        AccountExpirationDate =
            !string.IsNullOrEmpty(value)
            ? DateTime.ParseExact(value, "yyyy/MM/dd HH:mm:ss.fff")
            : null;
    }
}

InformationsquelleAutor der Antwort fre0n

3

Ich steckte fest in die ähnliche problem.
Ich hatte ein datetime-Eigenschaft (XmlAttribute) in einer Klasse, die wurde ausgesetzt in den WCF-Dienst.

Unten ist das, was ich gestoßen bin und die Lösung, die für mich gearbeitet :
1) XmlSerializer-Klasse war nicht serialising XmlAttribute der nullable-Typ
```
[XmlAttribute]
public DateTime? lastUpdatedDate { get; set; }
Exception thrown : Cannot serialize member 'XXX' of type System.Nullable`1. 
```
2) Einige Beiträge deuten zu ersetzen [XmlAttribute] mit [XmlElement(IsNullable =true)]. Aber das wird die Serialisierung des Attributs als ein Element, das ist völlig nutzlos. Aber es funktioniert gut für XmlElements

3) Einige schlagen vor, IXmlSerializable-Schnittstelle implementieren Sie in der Klasse, aber die, die nicht zulässt, dass der WCF service für Aufruf von WCF-verbrauchende Anwendung.
So auch nicht in diesem Fall.

Lösung :

Nicht markieren-Eigenschaft als null-Werte zulässt, verwenden Sie stattdessen eine ShouldSerializeXXX () - Methode, um Ihre Einschränkung.
```
[XmlAttribute]
public DateTime lastUpdatedDate { get; set; }
public bool ShouldSerializelastUpdatedDate ()
{
   return this.lastUpdatedDate != DateTime.MinValue; 
   //This prevents serializing the field when it has value 1/1/0001       12:00:00 AM
}
```
InformationsquelleAutor der Antwort Pankaj Pawar

Definieren Serializable, kapselt Ihre Funktionalität.

Hier sind und Beispiel.

[XmlAttribute("AccountExpirationDate")]  
public SerDateTime AccountExpirationDate   
{   
  get { return _SerDateTime ; }   
  set { _SerDateTime = value; }   
}  


///<summary>
///Serialize DateTime Class (<i>yyyy-mm-dd</i>)
///</summary>
public class SerDateTime : IXmlSerializable {
    ///<summary>
    ///Default Constructor when time is not avalaible
    ///</summary>
    public SerDateTime() { }
    ///<summary>
    ///Default Constructor when time is avalaible
    ///</summary>
    ///<param name="pDateTime"></param>
    public SerDateTime(DateTime pDateTime) {
        DateTimeValue = pDateTime;
    }

    private DateTime? _DateTimeValue;
    ///<summary>
    ///Value
    ///</summary>
    public DateTime? DateTimeValue {
        get { return _DateTimeValue; }
        set { _DateTimeValue = value; }
    }

    //Xml Serialization Infrastructure
    void IXmlSerializable.WriteXml(XmlWriter writer) {
        if (DateTimeValue == null) {
            writer.WriteString(String.Empty);
        } else {
            writer.WriteString(DateTimeValue.Value.ToString("yyyy-MM-dd"));
            //writer.WriteString(SerializeObject.SerializeInternal(DateTimeValue.Value));
        }
    }

    void IXmlSerializable.ReadXml(XmlReader reader) {
        reader.ReadStartElement();
        String ltValue = reader.ReadString();
        reader.ReadEndElement();
        if (ltValue.Length == 0) {
            DateTimeValue = null;
        } else {                
            //Solo se admite yyyyMMdd
            //DateTimeValue = (DateTime)SerializeObject.Deserialize(typeof(DateTime), ltValue);
            DateTimeValue = new DateTime(Int32.Parse(ltValue.Substring(0, 4)),
                                Int32.Parse(ltValue.Substring(5, 2)),
                                Int32.Parse(ltValue.Substring(8, 2)));                                    
        }
    }

    XmlSchema IXmlSerializable.GetSchema() {
        return (null);
    }
}
#endregion

InformationsquelleAutor der Antwort Rodrigo Perez Burgues

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.