El problema
Recibo un paquete JSON de un servidor en el formato {"A": 'Pelle', "B": 55, "C": 5.5} que debe asignarse a una clase de entidad en el formato:
class EntityAttributes { public string Name { get; set; } public int Level { get; set; } public float Strength { get; set; } }Los nombres de atributo en JSON, "A", "B" y "C" deben asignarse de acuerdo con la siguiente clase:
class Constants { public const byte NAME = 65; // ASCII "A" public const byte LEVEL = 66; // ASCII "B" public const byte STRENGTH = 67; // ASCII "C" }donde 65 es la representación de bytes ASCII de "A", 66 de "B" y 67 de "C".
Donde estoy atascado (no tengo idea si este es el camino correcto a seguir):
He estado tratando de usar JSON NET FOR UNITY , que le permite deserializar el JSON en una clase usando nombres personalizados:
class EntityAttributes { [[JsonProperty("A")]] public string Name { get; set; } [[JsonProperty("B")]] public int Level { get; set; } [[JsonProperty("C")]] public float Strength { get; set; } }Sin embargo, no quiero codificar "A", "B" y "C" en la anotación, ya que podrían cambiar en el futuro. Tampoco es posible (afaik) convertir de byte a cadena en un decorador ya que solo se permiten expresiones constantes .
¿Alguna idea de cómo debo abordar este problema?
Parece un poco que el problema principal es que los nombres de los campos deben ser constantes, lo que no desea.
Dado que sus atributos son lo suficientemente simples/básicos, podría usar SimpleJson que fue escrito por alguien en la comunidad de Units hace mucho tiempo;) Simplemente cree ese archivo en cualquier parte de su proyecto.
La gran ventaja: puede usar nombres de campo completamente dinámicos para que pueda hacerlo fácilmente, por ejemplo
public static class Constants { public const byte NAME = 65; public const byte LEVEL = 66; public const byte STRENGTH = 67; }y luego hacer por ejemplo
class EntityAttributes { public readonly string Name {get;set;}; public readonly int Level {get;set}; public readonly float Strength {get;set}; public EntityAttributes(string name, int level, float strength) { Name = name; Level = level; Strength = strength; } }Ahora, donde sea que haya analizado originalmente su JSON directamente en ese tipo, ya no lo hará. En su lugar, haces algo como, por ejemplo
var root = JSON.Parse(jsonString); var item = new EntityAttributes ( root[Encoding.ASCII.GetString(new [](Constants.NAME})].Value, root[Encoding.ASCII.GetString(new []{Constants.LEVEL})].AsInt(), root[Encoding.ASCII.GetString(new []{Constants.STRENGTH})].AsFloat() );Sin embargo, tenga en cuenta que de cualquier manera, por supuesto, todavía tiene que establecer estos valores de bytes constantes correctamente.
Entonces, en mi opinión personal, sigo pensando que podrías/deberías simplemente usar
public static class Constants { public const string NAME = "A"; public const string LEVEL = "B"; public const string STRENGTH = "C"; }Entonces ni siquiera tendrías ese problema. O su servidor tiene que proporcionar la estructura que el cliente espera o, al revés, el cliente tiene que lidiar con lo que proporcione el servidor. De cualquier manera, si se realizan cambios en un lado, el otro lado también debe cambiarse.
Nota: escrito en el teléfono inteligente, pero espero que la idea se aclare
Podría crear un JsonConverter personalizado para resolver este problema:
class EntityAttributesConverter : JsonConverter { public override bool CanConvert(Type objectType) { return objectType == typeof(EntityAttributes); } public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { JObject jo = JObject.Load(reader); return new EntityAttributes { Name = GetValue<string>(jo, Constants.NAME), Level = GetValue<int>(jo, Constants.LEVEL), Strength = GetValue<float>(jo, Constants.STRENGTH) }; } private static T GetValue<T>(JObject jo, byte b) { JToken val = jo[Encoding.ASCII.GetString(new byte[] { b })]; return val != null ? val.ToObject<T>() : default(T); } public override bool CanWrite => false; public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { throw new NotImplementedException(); } } Luego simplemente marque su clase EntityAttributes con un atributo [JsonConverter] como este:
[JsonConverter(typeof(EntityAttributesConverter))] class EntityAttributes { public string Name { get; set; } public int Level { get; set; } public float Strength { get; set; } }Y deserialice como lo haría normalmente:
var attributes = JsonConvert.DeserializeObject<EntityAttributes>(json);Aquí hay una demostración funcional (en una aplicación de consola): https://dotnetfiddle.net/VPfbdy
Use JsonUtility.FromJson para deserializar un archivo JSON y convertirlo simplemente a System.Text.Encoding.UTF8.GetBytes(myString) si desea un byte.