c# - ¿Cómo puedo serializar y deserializar un tipo con un miembro de cadena que contiene JSON "sin procesar", sin escapar del JSON en el proceso

serialization deserialization

Question

Quiero deserializar JSON en objeto, pero no quiero deserializar JSON anidado, anidado de JSON anidado debería convertirse en una lista JSON (compruebe " Mi salida esperada " para una idea clara) ...

// Supongamos que tengo datos JSON debajo, aquí he anidado JSON para la entidad "Dirección"

String jsonEmployees =
"{"Employees":
[{"EmpId":1, "EmpName":"ABC", "Address":[{"AddressId":1, "Address":"Something"},{"AddressId":2, "Address":"Anything"}]},
{"EmpId":2, "EmpName":"XYZ", "Address":[{"AddressId":1, "Address":"Something"},{"AddressId":2, "Address":"Anything"}]}]
}"

public class Employee
{
    public int EmpId { get; set; }
    public string EmpName { get; set; }
    // **Note** : I''m not using List<Address> data type for Address, instead of I want list of address in JSON string
    public string Address { get; set; }
}

public class RootObject
{
    public List<Employee> Employees { get; set; }
}

var Employees = JsonConvert.DeserializeObject<RootObject>(jsonEmployees);

// Mi salida esperada

Employees[0].EmpId = 1;
Employees[0].EmpName = "ABC";
Employees[0].Address = "[{"AddressId":1, "Address":"Something"},{"AddressId":2, "Address":"Anything"}]";

Employees[1].EmpId = 2;
Employees[1].EmpName = "XYZ";
Employees[1].Address = "[{"AddressId":1, "Address":"Something"},{"AddressId":2, "Address":"Anything"}]";

Sugiérame la mejor manera de resolver este problema ...

Answer 1

Creo que tendrá que reconstruir su lista de Empleados:

        RootObject Employees = JsonConvert.DeserializeObject<RootObject>(jsonEmployees);

        List<Employee> EmployeesNew = new List<Employee>();

        foreach (var item in Employees.Employees)
        {
            string StringAddress = JsonConvert.SerializeObject(item.Address, Formatting.None, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore });
            EmployeesNew.Add(new Employee { EmpId = item.EmpId, EmpName = item.EmpName, AddressString = StringAddress });

        }

Tu clase:

    public class Employee
    {
        public int EmpId { get; set; }
        public string EmpName { get; set; }
        // **Note** : I''m not using List<Address> data type for Address, instead of I want list of address in JSON string
        public List<AddressItems> Address { get; set; }
        public string AddressString { get; set; }
    }

    public class RootObject
    {
        public List<Employee> Employees { get; set; }
    }

    public class AddressItems
    {
        public int AddressId { get; set; }
        public string Address { get; set; }
    }

Answer 2

En JSON, las llaves {} son la notación para un objeto, y los corchetes [] son para matrices.

Siempre y cuando su matriz esté encapsulada en las llaves así, tendrá que usar otro objeto que contenga. Si puede deshacerse del sufijo {"Employees": prefijo y } , debería poder convertir el JSON en una lista de empleados directamente.

EDITAR: Lo siento, no entendí la pregunta.

Hacer lo que quiere es muy simple o muy difícil, dependiendo de si puede controlar el JSON.

Si puede controlar el JSON, todo lo que necesita hacer es agregar comillas simples alrededor del valor de la dirección para que se vea así:

[{"EmpId":1, "EmpName":"ABC", "Address":''[{"AddressId":1, "Address":"Something"},{"AddressId":2, "Address":"Anything"}]''},

¡Y eso es! ahora el serializador lo convertirá en cadena.

Si no puede, debe deserializar el JSON usted mismo, ficha por ficha. O puede hacer una solución alternativa, crear una clase de dirección correspondiente y dejar que el serializador se convierta a ella. Luego agregue una propiedad calculada y use el serializador para deserializar las direcciones de nuevo a JSON.
(Feo, lo sé, pero será mucho más rápido de implementar).

Answer 3

Su pregunta es, ¿cómo puedo serializar y deserializar un tipo con un miembro de string que contiene JSON "en bruto", sin escapar del JSON en el proceso?

Esto se puede hacer a través de un JsonConverter personalizado que lee y escribe JSON sin JsonWriter.WriteRawValue() utilizando JsonWriter.WriteRawValue() y JRaw.Create() :

public class RawConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        throw new NotImplementedException();
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        if (reader.TokenType == JsonToken.Null)
            return null;
        var raw = JRaw.Create(reader);
        return raw.ToString();
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        var s = (string)value;
        writer.WriteRawValue(s);
    }
}

Luego aplíquelo a su tipo de la siguiente manera:

public class Employee
{
    public int EmpId { get; set; }
    public string EmpName { get; set; }
    // **Note** : I''m not using List<Address> data type for Address, instead of I want list of address in JSON string
    [JsonConverter(typeof(RawConverter))]
    public string Address { get; set; }
}

public class RootObject
{
    public List<Employee> Employees { get; set; }
}

fiddle muestra.

Tenga en cuenta que la cadena JSON sin formato debe representar un JSON válido. Si no lo hace, entonces el JSON creado será ilegible. Si desea garantizar que el literal JSON sea válido, puede mantener el JSON en un estado analizado internamente:

public class Employee
{
    public int EmpId { get; set; }
    public string EmpName { get; set; }

    [JsonProperty("Address")]
    JToken AddressToken { get; set; }

    [JsonIgnore]
    public string Address
    {
        get
        {
            if (AddressToken == null)
                return null;
            return AddressToken.ToString(Formatting.Indented); // Or Formatting.None if you prefer
        }
        set
        {
            if (value == null)
                AddressToken = null;
            else
                // Throw an exception if value is not valid JSON.
                AddressToken = JToken.Parse(value);
        }
    }
}

No se necesita un convertidor para esta implementación.