So serialisieren Sie einen TimeSpan in XML

Ich versuche, ein .NET- TimeSpanObjekt in XML zu serialisieren , und es funktioniert nicht. Eine schnelle Google hat vorgeschlagen, dass es zwar TimeSpanserialisierbar ist, XmlCustomFormatteraber keine Methoden zum Konvertieren von TimeSpanObjekten in und aus XML bietet .

Ein vorgeschlagener Ansatz bestand darin, das TimeSpanfür die Serialisierung zu ignorieren und stattdessen das Ergebnis von TimeSpan.Ticks(und die Verwendung new TimeSpan(ticks)für die Deserialisierung) zu serialisieren . Ein Beispiel hierfür folgt:

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

Während dies in meinen kurzen Tests zu funktionieren scheint - ist dies der beste Weg, um dies zu erreichen?

Gibt es eine bessere Möglichkeit, eine TimeSpan von und nach XML zu serialisieren?

Die Art und Weise, wie Sie bereits gepostet haben, ist wahrscheinlich die sauberste. Wenn Ihnen die zusätzliche Eigenschaft nicht gefällt, können Sie sie implementieren IXmlSerializable, aber dann müssen Sie alles tun , was den Punkt weitgehend zunichte macht. Ich würde gerne den Ansatz verwenden, den Sie veröffentlicht haben. Es ist (zum Beispiel) effizient (kein komplexes Parsen usw.), kulturunabhängige, eindeutige und zeitstempelartige Zahlen sind leicht und allgemein zu verstehen.

Nebenbei füge ich oft hinzu:

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

Dies verbirgt es nur in der Benutzeroberfläche und beim Verweisen auf DLLs, um Verwirrung zu vermeiden.

Dies ist nur eine geringfügige Änderung des in der Frage vorgeschlagenen Ansatzes. In diesem Microsoft Connect-Problem wird jedoch empfohlen, eine Eigenschaft für die Serialisierung wie folgt zu verwenden:

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

Dies würde eine Zeitspanne von 0:02:45 serialisieren als:

<TimeSinceLastEvent>PT2M45S</TimeSinceLastEvent>

Alternativ DataContractSerializerunterstützt das TimeSpan.

In einigen Fällen kann dies funktionieren, indem Sie Ihrer öffentlichen Eigenschaft ein Hintergrundfeld zuweisen, bei dem es sich um eine Zeitspanne handelt. Die öffentliche Eigenschaft wird jedoch als Zeichenfolge angezeigt.

z.B:

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

Dies ist in Ordnung, wenn der Eigenschaftswert hauptsächlich in der enthaltenden Klasse oder in den ererbenden Klassen verwendet und aus der XML-Konfiguration geladen wird.

Die anderen vorgeschlagenen Lösungen sind besser, wenn die öffentliche Eigenschaft ein verwendbarer TimeSpan-Wert für andere Klassen sein soll.

Durch die Kombination einer Antwort aus der Farbserialisierung und dieser ursprünglichen Lösung (die für sich genommen großartig ist) habe ich folgende Lösung erhalten:

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

wo XmlTimeSpanKlasse so ist:

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

Sie können einen Light Wrapper um die TimeSpan-Struktur erstellen:

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

Beispiel für ein serialisiertes Ergebnis:

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

Eine besser lesbare Option wäre, als Zeichenfolge zu serialisieren und die TimeSpan.ParseMethode zum Deserialisieren zu verwenden. Sie können das Gleiche wie in Ihrem Beispiel tun, jedoch TimeSpan.ToString()im Getter und TimeSpan.Parse(value)im Setter verwenden.

Eine andere Möglichkeit wäre, es mit der SoapFormatterKlasse und nicht mit der zu serialisierenXmlSerializer Klasse .

Die resultierende XML-Datei sieht etwas anders aus ... einige "SOAP" -präfixierte Tags usw. ... aber sie kann es.

Hier ist , was SoapFormattereine Zeitspanne von 20 Stunden serialisiert und 28 Minuten serialisiert:

<myTimeSpan>P0Y0M0DT20H28M0S</myTimeSpan>

Um die SOAPFormatter-Klasse zu verwenden, müssen Sie einen Verweis auf System.Runtime.Serialization.Formatters.Soapden gleichnamigen Namespace hinzufügen und diesen verwenden.

Meine Version der Lösung :)

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

Bearbeiten: vorausgesetzt, es ist nullbar ...

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

Zeitspanne in XML als Anzahl von Sekunden gespeichert, aber es ist einfach zu übernehmen, hoffe ich. Manuell serialisierte Zeitspanne (Implementierung von 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));
            }
       }
    }
}

Es gibt ein umfassenderes Beispiel: https://bitbucket.org/njkazakov/timespan-serialization

Schauen Sie sich Settings.cs an. Und es gibt einen kniffligen Code, um XmlElementAttribute zu verwenden.

Für die Serialisierung von Datenverträgen verwende ich Folgendes.

• Wenn Sie die serialisierte Eigenschaft privat halten, bleibt die öffentliche Schnittstelle sauber.
• Durch die Verwendung des öffentlichen Eigenschaftsnamens für die Serialisierung bleibt das XML sauber.

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

Wenn Sie keine Problemumgehungen wünschen, verwenden Sie die DataContractSerializer-Klasse aus System.Runtime.Serialization.dll.

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

Versuche dies :

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