números de serie a un anulable <DateTime> a XML

Question

Estoy tratando de serializar una clase más datos de los miembros son objetos anulables, aquí es un ejemplo

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

Sin embargo en tiempo de ejecución se produce el error

No se puede serialice el miembro 'AccountExpirationDate' de tipo System.Nullable`1 [System.DateTime]. XmlAttribute/XmlText no se puede usar para codificar tipos complejos.

Sin embargo, he comprobado y Nullable es un SerializableAttribute. ¿Qué estoy haciendo mal?

Answer 1

Solo puede serializarlo como XmlElement, no como XmlAttribute, ya que la representación es demasiado compleja para un atributo. Eso es lo que la excepción te está diciendo.

Answer 2

Si lo que desea es que el trabajo , entonces tal vez:

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); 
    } 
} 

Esto sólo incluirá el atributo cuando hay un valor no nulo.

Answer 3

He usado algo como esto muchas veces.

[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; 
    } 
} 

Answer 4

Define un Serializable que encapsula tu funcionalidad.

Aquí hay y ejemplo.

[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 

Answer 5

Me quedé atrapado en el problema similar. Tenía una propiedad datetime (como XmlAttribute) en una clase que se expuso en el servicio WCF.

continuación es lo que me enfrentaba y la solución que trabajó para mí: clase 1) XmlSerializer no se serialising XmlAttribute de anulable tipo

[XmlAttribute] 
public DateTime? lastUpdatedDate { get; set; } 
Exception thrown : Cannot serialize member 'XXX' of type System.Nullable`1. 

2) Algunos mensajes sugieren reemplazar [XmlAttribute] con [XmlElement (IsNullable = verdadero)]. Pero esto serializará el Atributo como un Elemento que es totalmente inútil. Sin embargo, funciona bien para XmlElements

3) Algunos sugieren implementar la interfaz IXmlSerializable en su clase, pero eso no permite que se llame al servicio WCF desde la aplicación que consume WCF. Esto tampoco funciona en este caso.

Solución:

No marque propiedad como anulable, en lugar de utilizar un método ShouldSerializeXXX() para poner su restricción.

[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 
}