Como serializar um TimeSpan para XML

Question

Eu estou tentando serializar um objeto .NET TimeSpan para XML e ele não está funcionando. Uma rápida no google sugeriu que, enquanto TimeSpan é serializável, o XmlCustomFormatter não fornece métodos para objetos convertido TimeSpan de e para XML.

Uma abordagem sugerida foi ignorar o TimeSpan para serialização e, em vez serializar o resultado de TimeSpan.Ticks (e uso new TimeSpan(ticks) para desserialização). Um exemplo disso seguinte:

[Serializable]
public class MyClass
{
    // Local Variable
    private TimeSpan m_TimeSinceLastEvent;

    // Public Property - XmlIgnore as it doesn't serialize anyway
    [XmlIgnore]
    public TimeSpan TimeSinceLastEvent
    {
        get { return m_TimeSinceLastEvent; }
        set { m_TimeSinceLastEvent = value; }
    }

    // Pretend property for serialization
    [XmlElement("TimeSinceLastEvent")]
    public long TimeSinceLastEventTicks
    {
        get { return m_TimeSinceLastEvent.Ticks; }
        set { m_TimeSinceLastEvent = new TimeSpan(value); }
    }
}

Enquanto isso parece trabalho no meu teste breve - esta é a melhor maneira de conseguir isso

?

Existe uma maneira melhor para serializar um TimeSpan de e para XML?

Answer 1

A maneira como você já postou é provavelmente o mais limpo. Se você não gosta da propriedade extra, você poderia implementar IXmlSerializable, mas então você tem que fazer tudo , que em grande parte vence o ponto. Eu ficaria feliz em usar a abordagem que você postou; é (por exemplo) eficaz independente de cultura (sem análise complexo etc), e não ambígua, e os números do tipo timestamp são facilmente e geralmente compreendido.

Como um aparte, muitas vezes eu adicionar:

[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]

Isso só esconde na interface do usuário e em referência a DLLs, a confusão evitar.

Answer 2

Esta é apenas uma pequena modificação na abordagem sugerida na pergunta, mas este problema Microsoft Connect recomenda o uso de uma propriedade para serialização como esta:

[XmlIgnore]
public TimeSpan TimeSinceLastEvent
{
    get { return m_TimeSinceLastEvent; }
    set { m_TimeSinceLastEvent = value; }
}

// XmlSerializer does not support TimeSpan, so use this property for 
// serialization instead.
[Browsable(false)]
[XmlElement(DataType="duration", ElementName="TimeSinceLastEvent")]
public string TimeSinceLastEventString
{
    get 
    { 
        return XmlConvert.ToString(TimeSinceLastEvent); 
    }
    set 
    { 
        TimeSinceLastEvent = string.IsNullOrEmpty(value) ?
            TimeSpan.Zero : XmlConvert.ToTimeSpan(value); 
    }
}

Este seria serializar um TimeSpan de 0:02:45 como:

<TimeSinceLastEvent>PT2M45S</TimeSinceLastEvent>

Como alternativa, o DataContractSerializer suporta TimeSpan.

Answer 3

Algo que pode funcionar em alguns casos, é dar sua propriedade pública um campo de apoio, que é um TimeSpan, mas a propriedade pública é exposto como uma string.

por exemplo:

protected TimeSpan myTimeout;
public string MyTimeout 
{ 
    get { return myTimeout.ToString(); } 
    set { myTimeout = TimeSpan.Parse(value); }
}

Este é ok se o valor da propriedade é usada principalmente w / na classe que contém ou classes que herdam e é carregada a partir da configuração XML.

As outras soluções propostas são melhores se você quer a propriedade pública para ser um valor TimeSpan utilizável para outras classes.

Answer 4

A combinação de uma resposta de Cor serialização e este solução original (que é grande por si só) Eu tenho esta solução:

[XmlElement(Type = typeof(XmlTimeSpan))]
public TimeSpan TimeSinceLastEvent { get; set; }

onde a classe XmlTimeSpan é assim:

public class XmlTimeSpan
{
    private const long TICKS_PER_MS = TimeSpan.TicksPerMillisecond;

    private TimeSpan m_value = TimeSpan.Zero;

    public XmlTimeSpan() { }
    public XmlTimeSpan(TimeSpan source) { m_value = source; }

    public static implicit operator TimeSpan?(XmlTimeSpan o)
    {
        return o == null ? default(TimeSpan?) : o.m_value;
    }

    public static implicit operator XmlTimeSpan(TimeSpan? o)
    {
        return o == null ? null : new XmlTimeSpan(o.Value);
    }

    public static implicit operator TimeSpan(XmlTimeSpan o)
    {
        return o == null ? default(TimeSpan) : o.m_value;
    }

    public static implicit operator XmlTimeSpan(TimeSpan o)
    {
        return o == default(TimeSpan) ? null : new XmlTimeSpan(o);
    }

    [XmlText]
    public long Default
    {
        get { return m_value.Ticks / TICKS_PER_MS; }
        set { m_value = new TimeSpan(value * TICKS_PER_MS); }
    }
}

Answer 5

Você pode criar um invólucro de luz ao redor da estrutura TimeSpan:

namespace My.XmlSerialization
{
    public struct TimeSpan : IXmlSerializable
    {
        private System.TimeSpan _value;

        public static implicit operator TimeSpan(System.TimeSpan value)
        {
            return new TimeSpan { _value = value };
        }

        public static implicit operator System.TimeSpan(TimeSpan value)
        {
            return value._value;
        }

        public XmlSchema GetSchema()
        {
            return null;
        }

        public void ReadXml(XmlReader reader)
        {
            _value = System.TimeSpan.Parse(reader.ReadContentAsString());
        }

        public void WriteXml(XmlWriter writer)
        {
            writer.WriteValue(_value.ToString());
        }
    }
}

Amostra resultado serializados:

<Entry>
  <StartTime>2010-12-06T08:45:12.5</StartTime>
  <Duration>2.08:29:35.2500000</Duration>
</Entry>

Answer 6

A opção mais legível seria serialize como uma string e usar o método TimeSpan.Parse desserializar-lo. Você poderia fazer o mesmo que no seu exemplo, mas usando TimeSpan.ToString() no getter e TimeSpan.Parse(value) na setter.

Answer 7

Outra opção seria para serializar-lo usando a classe SoapFormatter em vez da classe XmlSerializer.

O arquivo XML resultante parece um pouco diferente ... alguns "Soap" tags -prefixed, etc ... mas pode fazê-lo.

Aqui está o que SoapFormatter serializado um período de tempo de 20 horas e 28 minutos serializado para:

<myTimeSpan>P0Y0M0DT20H28M0S</myTimeSpan>

Para usar a classe SoapFormatter, necessidade de adicionar referência a System.Runtime.Serialization.Formatters.Soap e usar o namespace com o mesmo nome.

Answer 8

Minha versão da solução:)

[DataMember, XmlIgnore]
public TimeSpan MyTimeoutValue { get; set; }
[DataMember]
public string MyTimeout
{
    get { return MyTimeoutValue.ToString(); }
    set { MyTimeoutValue = TimeSpan.Parse(value); }
}

Edit: assumindo que é anulável ...

[DataMember, XmlIgnore]
public TimeSpan? MyTimeoutValue { get; set; }
[DataMember]
public string MyTimeout
{
    get 
    {
        if (MyTimeoutValue != null)
            return MyTimeoutValue.ToString();
        return null;
    }
    set 
    {
        TimeSpan outValue;
        if (TimeSpan.TryParse(value, out outValue))
            MyTimeoutValue = outValue;
        else
            MyTimeoutValue = null;
    }
}

Answer 9

Timespan armazenado em xml como o número de segundos, mas é fácil de adotar, espero. Timespan serializado manualmente (implementar IXmlSerializable):

public class Settings : IXmlSerializable
{
    [XmlElement("IntervalInSeconds")]
    public TimeSpan Interval;

    public XmlSchema GetSchema()
    {
        return null;
    }

    public void WriteXml(XmlWriter writer)
    {
        writer.WriteElementString("IntervalInSeconds", ((int)Interval.TotalSeconds).ToString());
    }

    public void ReadXml(XmlReader reader)
    {
        string element = null;
        while (reader.Read())
        {
            if (reader.NodeType == XmlNodeType.Element)
                element = reader.Name;
            else if (reader.NodeType == XmlNodeType.Text)
            {
                if (element == "IntervalInSeconds")
                    Interval = TimeSpan.FromSeconds(double.Parse(reader.Value.Replace(',', '.'), CultureInfo.InvariantCulture));
            }
       }
    }
}

Não há exemplo mais abrangente: https://bitbucket.org/njkazakov/timespan-serialization

Olhe para Settings.cs. E há algum código complicado para uso XmlElementAttribute.

Answer 10

Para a serialização contrato de dados Eu uso o seguinte.

• Manter a propriedade privada serializado mantém a interface pública limpo.
• Usando o nome da propriedade pública para serialização mantém o XML limpo.

Public Property Duration As TimeSpan

<DataMember(Name:="Duration")>
Private Property DurationString As String
    Get
        Return Duration.ToString
    End Get
    Set(value As String)
        Duration = TimeSpan.Parse(value)
    End Set
End Property

Answer 11

Se você não quer nenhuma solução alternativa, use a classe DataContractSerializer de System.Runtime.Serialization.dll.

        using (var fs = new FileStream("file.xml", FileMode.Create))
        {
            var serializer = new DataContractSerializer(typeof(List<SomeType>));
            serializer.WriteObject(fs, _items);
        }

Answer 12

Tente isto:

//Don't Serialize Time Span object.
        [XmlIgnore]
        public TimeSpan m_timeSpan;
//Instead serialize (long)Ticks and instantiate Timespan at time of deserialization.
        public long m_TimeSpanTicks
        {
            get { return m_timeSpan.Ticks; }
            set { m_timeSpan = new TimeSpan(value); }
        }