c# Newtonsoft json: how to deserialize json and get raw strings for float fields

Question

Consider json string:

var json = "{\"myfield\":5e-0000006}";

I want deserialize that json, and get field "myfield" as a raw string. Example:

JToken tok = <Deserialize> // how do this??
var val = tok["myfield"].ToString(); // need get "5e-0000006"

I need get EXACT string value that was in origin string ("5e-0000006" in example, but it may be any valid float string).

Answer 1

Since you want an exact string and the json you have actually is a number (which means 5e-0000006 will equal 5e-6) I would suggest using regex:

string json = "{\"myfield\":5e-0000006}";
Regex regex = new Regex("(?<=:)[^}]+");
string result = regex.Match(json).Value;

Explanation:

(?<=:) look behind for a colon (:)

[^}]+ match any character not being a right curly brace (}), one or more times.

That should give you the value as an exact string.

Update:

If you want to match based on the myfield variable, you can expand the regex to contain that information:

string json = "{\"myfield\":5e-0000006}";
Regex regex = new Regex("(?<=\"myfield\":)[^}]+");
string result = regex.Match(json).Value;

Now you will only get the line where you have \"myfield\" in front - in case you have many lines.

You can of course replace \"myfield\" with a variable, like this:

string json = "{\"myfield\":5e-0000006}";
string myvar = "myfield";
Regex regex = new Regex("(?<=\"" + myvar + "\":)[^}]+");
string result = regex.Match(json).Value;

Answer 2

With some info, and inspiration, from:

• You don't need to write any converters, just use the JRaw type as follows:
• Docs: This sample deserializes JSON to an object.

        static void Main(string[] args)
        {
            var json = "{\"myfield\":5e-0000006}";

            MyJson j = JsonConvert.DeserializeObject<MyJson>(json);
            string mf = j.myfield;
            Console.WriteLine(mf);
        }

        public class MyJson 
        {
            [JsonProperty("myfield")]
            public string myfield { get; set; }
        }

This will output: 5e-0000006

And I am still wondering why I am not using JRaw ...

Answer 3

I ended up by creating a simple wrapper around a System.Text.Json

class MyJToken {

        JsonElement cur;
        string fieldName;
        public bool IsNull { get; private set; }

        public MyJToken(JsonElement cur, string fieldName) {
            this.cur = cur;
            this.fieldName = fieldName;
        }
        public MyJToken() {
            IsNull = true;
        }

        public override string ToString() {
            if (IsNull) {
                return "null";
            }
            return cur.ToString();
        }

        public static MyJToken Parse(string json) {
            JsonDocument doc = JsonDocument.Parse(json);
            return new MyJToken(doc.RootElement, "root");
        }

        public IEnumerable<(string, MyJToken)> EnumKeyVal() {
            foreach(var elem in cur.EnumerateObject()) {
                yield return (elem.Name, new MyJToken(elem.Value, elem.Name));
            }
            yield break;
        }

        public IEnumerable<MyJToken> EnumList() {
            foreach (var elem in cur.EnumerateArray()) {
                yield return new MyJToken(elem, "");
            }
            yield break;
        }

        public MyJToken get(string name) {
            return this[name];
        }

        public MyJToken this[string key] {
            get {
                if (!cur.TryGetProperty(key, out var value))
                    return new MyJToken();
                return new MyJToken(value, key);
            }
        }

        public MyJToken this[int key] {
            get => new MyJToken(cur[key], key.ToString());
        }

        void SayNotFound() {
            throw new Exception($"Filed {fieldName} not found");
        }

        public string STR() {
            if (IsNull) SayNotFound();
            return cur.GetString();
        }
        public string STR(string def) {
            if (IsNull) return def;
            return STR();
        }

        public string RAW() {
            if (IsNull) SayNotFound();
            return cur.GetRawText();
        }
        public string RAW(string def) {
            if (IsNull) return def;
            return RAW();
        }

        public decimal DEC() {
            if (IsNull) SayNotFound();
            return cur.GetDecimal();
        }
        public decimal DEC(decimal def) {
            if (IsNull) return def;
            return DEC();
        }

        public long LONG() {
            if (IsNull) SayNotFound();
            return cur.GetInt64();
        }
        public long LONG(long def) {
            if (IsNull) return def;
            return LONG();
        }
    }

Now I can get whatever I want:

    var json = "{\"myfield\":5e-0000006}";
    var root = MyJToken.Parse(json);
    var tok = root["myfield"];
    Console.WriteLine($"num={tok.DEC()} raw={tok.RAW()}");