解析 Xml 文档中的指数值

Question

I have an issue when deserializing an object (which I cannot modify). I receive an exponential value for certain xml element and for represent them in my class I used decimal value expect that when I deserialize the xml document it fails.

<fwdRate>-9.72316862724032E-05</fwdRate>

Is there any solution to represent this attribute other than create 2 attributes in my class to represent it (one string and the other a decimal value)?

Can I create a custom deserializtion class for decimal value?

        private void ParseXML(string value)
        {
            XmlSerializer serializer = new XmlSerializer(typeof(SwapDataSynapseResult));
            using (TextReader reader = new StringReader(value))
            {
                _result = serializer.Deserialize(reader) as SwapDataSynapseResult;
            }
        }

As Demand

using System;
using System.IO;
using System.Xml.Serialization;

[XmlRoot(ElementName = "result")]
public class Result
{
    [XmlElement(ElementName = "fwdRate")]
    public decimal FwdRate { get; set; }
}       
public class Program
{
    public static void Main()
    {
         string val = "<result><fwdRate>-9.72316862724032E-05</fwdRate></result>";
         Result response = ParseXML(val);
  }
  static Result ParseXML(string value)
  {
      XmlSerializer serializer = new XmlSerializer(typeof(Result));
      using (TextReader reader = new StringReader(value))
      {
         return serializer.Deserialize(reader) as Result;
      }
  }

}

Answer 1

In XML, decimal values are not allowed to use scientific (exponential) notation (See this link at the 'Restrictions' paragraph).

Either:

• the value is indeed a floating point one: Put a float / double instead of a decimal in the code.
• the XML is corrupted.

In the same way, in C#, by default, Decimal.Parse doesn't accept exponential representation. You can override this behavior by implementing a new struct that wrap a decimal and implement IXmlSerializable and allow exponential representation when de-serialized:

public struct XmlDecimal : IXmlSerializable
{
    public decimal Value { get; private set; }

    public XmlDecimal(decimal value) => Value = value;

    public XmlSchema GetSchema() => null;

    public void ReadXml(XmlReader reader)
    {
        var s = reader.ReadElementContentAsString();
        Value = decimal.TryParse(s, NumberStyles.Number | NumberStyles.AllowExponent,
            NumberFormatInfo.InvariantInfo, out var value)
            ? value
            : 0; // If parse fail the resulting value is 0. Maybe we can throw an exception here.
    }

    public void WriteXml(XmlWriter writer) => writer.WriteValue(Value);

    public static implicit operator decimal(XmlDecimal v) => v.Value;

    public override string ToString() => Value.ToString();
}

The flaw is that you have to use this struct instead of a decimal everywhere in your model.

And sadly you can't make this struct read-only, has explained here .

Answer 2

The proper way is to control how your properties are deserialized by implementing the IXmlSerializable interface:

IXmlSerializable

IXmlSerializable code project example

In the ReadXml method you should convert your number

var yourStringNumber = ...

this.fwdRate = Decimal.Parse(yourStringNumber, System.Globalization.NumberStyles.Float);

But this method will require you to parse of the whole xml manually that is a bit overhead sometimes.

A simple solution (that smells but might be useful) is just to add additional fwdRateDecimal field to your class and fulfill the value after the serialization.

 private void ParseXML(string value)
    {
        XmlSerializer serializer = new XmlSerializer(typeof(SwapDataSynapseResult));
        using (TextReader reader = new StringReader(value))
        {
            _result = serializer.Deserialize(reader) as SwapDataSynapseResult;
            _result.fwdRateDecimal = Decimal.Parse(_result.fwdRate, System.Globalization.NumberStyles.Float)
        }
    }

Also conversion can be implemented in a type directly:

[XmlRoot(ElementName = "result")]
public class Result
{
    [XmlElement(ElementName = "fwdRate")]
    public string FwdRateStr { get; set; }

    private string lastParsedValue = null;
    private decimal fwdRate = 0;

    [XmlIgnore]
    public decimal FwdRate 
    { 
     get 
     {
        if(FwdRateStr != lastParsedValue)
        {
             lastParsedValue = FwdRateStr
             fwdRate = Decimal.Parse(FwdRateStr ,System.Globalization.NumberStyles.Float)
        }

        return fwdRate
     }  
}

Answer 3

This is the solution:

using System;
using System.IO;
using System.Xml.Serialization;

[XmlRoot(ElementName = "result")]
public class Result
{
    [XmlElement(ElementName = "fwdRate")]
    public double FwdRate { get; set; }
}
public class Program
{
    public static void Main()
    {
        string val = "<result><fwdRate>-9.72316862724032E-05</fwdRate></result>";
        Result response = ParseXML(val);
        Console.WriteLine(response.FwdRate);
    }
    static Result ParseXML(string value)
    {
        XmlSerializer serializer = new XmlSerializer(typeof(Result));
        using (TextReader reader = new StringReader(value))
        {
            return serializer.Deserialize(reader) as Result;
        }
    }

}

You can't modify the incoming xml but you can modify how you read its' data.

Read that number as a double instead of decimal and you will have the right decimal precision.

Output:

-9,72316862724032E-05