.NET在使用RESTAPI时首选newtonsoft json序列化程序/反序列化程序。
D＆B直接REST实现使用BadgerFish方法（它主要存在于JavaWord（JavestNosiStof）中，JSON中有一些小的变化：D&B BadgerFish。
我想将D&B Badgerfish JSON响应映射到.NET类。
有一个GitHub项目https://github.com/bramstein/xsltjson/支持从xml到json（支持badgerfish）的转换，但是我如何做相反的事情，如下所述：
xsltjson支持几种不同的json输出格式，从紧凑的输出格式到支持badgerfish约定，后者允许xml和json之间的往返。
例如，假设d&b后端rest服务正在转换此xml：

<SalesRevenueAmount CurrencyISOAlpha3Code="USD”>1000000</SalesRevenueAmount>
<SalesRevenueAmount CurrencyISOAlpha3Code="CAD”>1040000</SalesRevenueAmount>

"SalesRevenueAmount": [     {
   "@CurrencyISOAlpha3Code": "USD",
   "$": 1000000
},
{
   "@CurrencyISOAlpha3Code": "CAD",
   "$": 1040000
}
]

最佳答案

我也被要求使用D&B的API，在检查.NET中是否存在Badgerfish的现有解决方案时遇到了这个问题。
和你一样，我只需要担心反序列化到我的.NET模型中。
此外，在阅读了D&B的徽章鱼的变化后，我认为没有必要对它们进行特别的解释。下面的代码似乎可以很好地处理D&B的格式。
为什么是獾鱼？
似乎D&B已经有了一段时间的XML API，他们决定通过将现有的XML直接转换为JSON来生成JSON内容类型，而不是序列化为XML或JSON。
这就需要解决xml和json结构之间的不一致性。在XML中，可以将属性和值与单个元素关联。json中不存在这种范式。json只是键/值。
因此，BadgerFish是解决这两种数据格式之间不一致的标准。当然，它可以通过其他方式解决，这只是众多想法中的一个。
目标
为了解决这个问题，我首先需要弄清楚我的预期结果是什么。
使用您的示例，我决定使用以下json：

"SalesRevenueAmount": [
    {
       "@CurrencyISOAlpha3Code": "USD",
       "$": 1000000
    },
    {
       "@CurrencyISOAlpha3Code": "CAD",
       "$": 1040000
    }
]

public class SalesRevenueAmount {
    public string CurrencyISOAlpha3Code { get; set; }
    public string Value { get; set; }
}

public class SalesRevenueAmount {
    [JsonProperty("@CurrencyISOAlpha3Code")]
    public string CurrencyISOAlpha3Code { get; set; }
    [JsonProperty("$")]
    public string Value { get; set; }
}

public class BadgerFishJsonConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return true;
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        var source = JObject.Load(reader);

        //Since we can't modify the internal collections, first we will get all the paths.
        //Then we will proceed to rename them.
        var paths = new List<string>();
        collectPaths(source, paths);
        renameProperties(source, paths);

        return source.ToObject(objectType);
    }

    private void collectPaths(JToken token, ICollection<string> collection)
    {
        switch (token.Type)
        {
            case JTokenType.Object:
            case JTokenType.Array:
                foreach (var child in token)
                {
                    collectPaths(child, collection);
                }
                break;
            case JTokenType.Property:
                var property = (JProperty)token;

                if (shouldRenameProperty(property.Name))
                {
                    collection.Add(property.Path);
                }

                foreach (var child in property)
                {
                    collectPaths(child, collection);
                }
                break;
            default:
                break;
        }
    }

    private void renameProperties(JObject source, ICollection<string> paths)
    {
        foreach (var path in paths)
        {
            var token = source.SelectToken(path);
            token.Rename(prop => transformPropertyName(prop));
        }
    }

    private bool shouldRenameProperty(string propertyName)
    {
        return propertyName.StartsWith("@") || propertyName.Equals("$");
    }

    private static string transformPropertyName(JProperty property)
    {
        if (property.Name.StartsWith("@"))
        {
            return property.Name.Substring(1);
        }
        else if (property.Name.Equals("$"))
        {
            return "Value";
        }
        else
        {
            return property.Name;
        }
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }
}

var jsonSettings = new JsonSerializerSettings();
jsonSettings.Converters.Add(new BadgerFishJsonConverter());

var obj = JsonConvert.DeserializeObject<SalesRevenueAmounts>(json, jsonSettings); 

public class SalesRevenueAmount
{
    public string CurrencyISOAlpha3Code { get; set; }
    public string Value { get; set; }
}

public class SalesRevenueAmounts
{
    public IEnumerable<SalesRevenueAmount> SalesRevenueAmount { get; set; }
}

public static class Extensions
{
    public static void Rename(this JToken token, string newName)
    {
        token.Rename(prop => newName);
    }

    public static void Rename(this JToken token, Func<JProperty, string> nameProvider)
    {
        if (token == null)
            throw new ArgumentNullException("token", "Cannot rename a null token");

        JProperty property;

        if (token.Type == JTokenType.Property)
        {
            if (token.Parent == null)
                throw new InvalidOperationException("Cannot rename a property with no parent");

            property = (JProperty)token;
        }
        else
        {
            if (token.Parent == null || token.Parent.Type != JTokenType.Property)
                throw new InvalidOperationException("This token's parent is not a JProperty; cannot rename");

            property = (JProperty)token.Parent;
        }

        var newName = nameProvider.Invoke(property);
        var newProperty = new JProperty(newName, property.Value);
        property.Replace(newProperty);
    }
}

关于c# - 如何在C#中将Badgerfish样式的JSON转换为.NET对象或XML？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/39110233/