Pat*_*ick 2 .net c# serialization json json.net
我在找出以特定格式反序列化某些 JSON 数据的干净（尽可能）方法时遇到了一些麻烦。我想将数据反序列化为强类型数据对象类，这在细节方面非常灵活。以下是数据外观的示例：
{
"timestamp": 1473730993,
"total_players": 945,
"max_score": 8961474,
"players": {
"Player1Username": [
121,
"somestring",
679900,
5,
4497,
"anotherString",
"thirdString",
"fourthString",
123,
22,
"YetAnotherString"],
"Player2Username": [
886,
"stillAstring",
1677,
1,
9876,
"alwaysAstring",
"thirdString",
"fourthString",
876,
77,
"string"]
}
}
我不确定的具体部分是：
假设我有一个这样的顶级课程：
public class ScoreboardResults
{
public int timestamp { get; set; }
public int total_players { get; set; }
public int max_score { get; set; }
public List<Player> players { get; set; }
}
如果 Player 对象基本上是一个以用户名作为键的键/值，并且该值是混合整数和字符串的集合，那么它会是什么样子？每个玩家元素的数据总是以相同的顺序排列，所以我知道集合中的第一个值是他们的 UniqueID，第二个值是玩家描述，等等。我希望玩家类是这样的：
public class Player
{
public string Username { get; set; }
public int UniqueID { get; set; }
public string PlayerDescription { get; set; }
....
....
.... Following this pattern for all of the values in each player element
....
....
}
我确信这是使用 JSON.NET 做的一件非常简单的事情，这就是为什么我想避免我对如何实现这一点的任何想法。我想出的东西是不优雅的，并且可能在序列化过程中在某种程度上容易出错。
编辑
以下是根据snow_FFFFFF 的建议使用过去作为 JSON 类时生成的类：
public class Rootobject
{
public int timestamp { get; set; }
public int total_players { get; set; }
public int max_score { get; set; }
public Players players { get; set; }
}
public class Players
{
public object[] Player1Username { get; set; }
public object[] Player2Username { get; set; }
}
我不清楚的是如何将“players”元素中的 JSON 数据反序列化为 List，其中 Player1Username 是 Player 对象上的一个简单字符串属性。至于混合字符串和整数的集合，我相信我可以毫无问题地将它们放入 Player 对象的各个属性中。
一个好的开始方法是让 Visual Studio 基于 JSON 生成您的类。打开一个空白类文件，然后转到“编辑”->“特殊粘贴”->“将 JSON 粘贴为类”。
这将生成一个包含序列化/反序列化 JSON 所需类的文件。
在 Visual Basic .NET 中反序列化 JSON的转换器应该可以满足您的需求，从 VB.NET 适当地转换为 c#：
public class ObjectToArrayConverter<T> : JsonConverter
{
public override bool CanConvert(Type objectType)
{
return typeof(T) == objectType;
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var objectType = value.GetType();
var contract = serializer.ContractResolver.ResolveContract(objectType) as JsonObjectContract;
if (contract == null)
throw new JsonSerializationException(string.Format("invalid type {0}.", objectType.FullName));
writer.WriteStartArray();
foreach (var property in SerializableProperties(contract))
{
var propertyValue = property.ValueProvider.GetValue(value);
if (property.Converter != null && property.Converter.CanWrite)
property.Converter.WriteJson(writer, propertyValue, serializer);
else
serializer.Serialize(writer, propertyValue);
}
writer.WriteEndArray();
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var contract = serializer.ContractResolver.ResolveContract(objectType) as JsonObjectContract;
if (contract == null)
throw new JsonSerializationException(string.Format("invalid type {0}.", objectType.FullName));
if (reader.MoveToContentAndAssert().TokenType == JsonToken.Null)
return null;
if (reader.TokenType != JsonToken.StartArray)
throw new JsonSerializationException(string.Format("token {0} was not JsonToken.StartArray", reader.TokenType));
// Not implemented: JsonObjectContract.CreatorParameters, serialization callbacks,
existingValue = existingValue ?? contract.DefaultCreator();
using (var enumerator = SerializableProperties(contract).GetEnumerator())
{
while (true)
{
switch (reader.ReadToContentAndAssert().TokenType)
{
case JsonToken.EndArray:
return existingValue;
default:
if (!enumerator.MoveNext())
{
reader.Skip();
break;
}
var property = enumerator.Current;
object propertyValue;
// TODO:
// https://www.newtonsoft.com/json/help/html/Properties_T_Newtonsoft_Json_Serialization_JsonProperty.htm
// JsonProperty.ItemConverter, ItemIsReference, ItemReferenceLoopHandling, ItemTypeNameHandling, DefaultValue, DefaultValueHandling, ReferenceLoopHandling, Required, TypeNameHandling, ...
if (property.Converter != null && property.Converter.CanRead)
propertyValue = property.Converter.ReadJson(reader, property.PropertyType, property.ValueProvider.GetValue(existingValue), serializer);
else
propertyValue = serializer.Deserialize(reader, property.PropertyType);
property.ValueProvider.SetValue(existingValue, propertyValue);
break;
}
}
}
}
static IEnumerable<JsonProperty> SerializableProperties(JsonObjectContract contract)
{
return contract.Properties.Where(p => !p.Ignored && p.Readable && p.Writable);
}
}
public static partial class JsonExtensions
{
public static JsonReader ReadToContentAndAssert(this JsonReader reader)
{
return reader.ReadAndAssert().MoveToContentAndAssert();
}
public static JsonReader MoveToContentAndAssert(this JsonReader reader)
{
if (reader == null)
throw new ArgumentNullException();
if (reader.TokenType == JsonToken.None) // Skip past beginning of stream.
reader.ReadAndAssert();
while (reader.TokenType == JsonToken.Comment) // Skip past comments.
reader.ReadAndAssert();
return reader;
}
public static JsonReader ReadAndAssert(this JsonReader reader)
{
if (reader == null)
throw new ArgumentNullException();
if (!reader.Read())
throw new JsonReaderException("Unexpected end of JSON stream.");
return reader;
}
}
接下来，将转换器添加到您的Player类中，并使用JsonPropertyAttribute.Order以下命令指示每个属性的顺序：
[JsonConverter(typeof(ObjectToArrayConverter<Player>))]
public class Player
{
[JsonProperty(Order = 1)]
public int UniqueID { get; set; }
[JsonProperty(Order = 2)]
public string PlayerDescription { get; set; }
// Other fields as required.
}
最后，按如下方式声明您的根对象：
public class ScoreboardResults
{
public int timestamp { get; set; }
public int total_players { get; set; }
public int max_score { get; set; }
public Dictionary<string, Player> players { get; set; }
}
请注意，我已经感动Username了的Player阶级和进入词典，作为重点。
请注意，可以使用数据协定属性代替 Newtonsoft 属性来指定顺序：
[JsonConverter(typeof(ObjectToArrayConverter<Player>))]
[DataContract]
public class Player
{
[DataMember(Order = 1)]
public int UniqueID { get; set; }
[DataMember(Order = 2)]
public string PlayerDescription { get; set; }
// Other fields as required.
}