es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

¿Existe alguna forma de determinar si los tipos de JProperty son iguales?

06 Aug, 2023 Programación

Mi entorno es .NET Core 3.1 y estoy utilizando el paquete de nuget Newtonsoft.JSON.

Estoy creando tipos de datos personalizados utilizando JObject basado en un JSON y esos tipos de datos serán utilizados en otras partes de la aplicación. Después de que se cree el tipo de dato, también puedo editar ese JSON para generar un tipo de dato diferente y agregaré una bandera “IsOutdated” para que en cualquier lugar donde se use este tipo de dato se vuelva inválido.

Lo que quiero es que cada vez que alguien guarde ese JSON, si las propiedades tienen los mismos tipos de valores, la bandera “IsOutdated” no se establecerá en verdadero. Así que solo si cambian los valores, no sucederá nada. Solo si agregan/eliminan propiedades o cambian los tipos de valor, “IsOutdated” será verdadero.

Ya estoy utilizando “JToken.DeepEquals” para verificar si el JSON existente es el mismo que el nuevo, pero esto también verifica el valor, no solo el tipo. Quiero algo similar que solo verifique el tipo de las propiedades del JSON.

Entonces, si tengo esto:

{
   "Id": 1,
   "Obj1":
    {
       "Obj2":
       {
          "Name": "Ed",
          "IsYoung": true
       }
    }
}

Y envío esto:

{
   "Id": 1,
   "Obj1":
    {
       "Obj2":
       {
          "Name": "Ed",
          "IsYoung": false
       }
    }
}

No quiero que la bandera “IsOutdated” cambie en este caso. Porque la propiedad “IsYoung” tendrá el mismo tipo.

¿Alguna idea? Gracias.

Tags:  , , , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Una posible solución podría ser comparar los esquemas JSON del JSON original y actualizado utilizando la biblioteca Newtonsoft.Json.Schema (también disponible como un paquete NuGet).

    Puedes crear un esquema para el JSON original utilizando la clase JSchemaGenerator y luego compararlo con el esquema del JSON actualizado utilizando el método JSchema.Parse. Luego, puedes iterar sobre las propiedades de los esquemas y verificar sus tipos de datos, ignorando los valores de las propiedades.

    Aquí tienes un ejemplo de implementación:

    using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Schema;

// crea un esquema para el JSON original
JSchemaGenerator generator = new JSchemaGenerator();
JSchema originalSchema = generator.Generate(typeof(TipoDeDatoOriginal));

// analiza el JSON actualizado y su esquema
JObject updatedJson = JObject.Parse(updatedJsonString);
JSchema updatedSchema = JSchema.Parse(updatedJsonString);

// verifica si los esquemas tienen las mismas propiedades y tipos
bool tiposCoinciden = true;
foreach (JProperty originalProperty in originalSchema.Properties())
{
    JProperty updatedProperty = updatedSchema.Properties().FirstOrDefault(p => p.Name == originalProperty.Name);
    if (updatedProperty == null || !JToken.DeepEquals(originalProperty.Type, updatedProperty.Type))
    {
        tiposCoinciden = false;
        break;
    }
}

// establece la bandera IsOutdated si los tipos no coinciden
if (!tiposCoinciden)
{
    dataType.IsOutdated = true;
}

    Ten en cuenta que TipoDeDatoOriginal debe ser reemplazado por el tipo de dato original que fue creado utilizando JObject.

Comments are closed.