c# - serialize - JSON.Net ignora la propiedad durante la deserialización

jsonproperty class name c#

Question

Tengo una clase configurada de la siguiente manera:

public class Foo
{
    public string string1 { get; set; }
    public string string2 { get; set; }
    public string string3 { get; set; }
}

Estoy usando Json.Net para deserializar la siguiente respuesta de Json:

string json = "[{/"number1/": 1, /"number2/": 12345678901234567890, /"number3/": 3},      
{/"number1/": 9, /"number2/": 12345678901234567890, /"number3/": 8}]";

Código de deserialización:

List<Foo> foos = JsonConvert.DeserializeObject<List<Foo>>(json);

El segundo número excede un int-64, pero realmente no me importa recuperar ese valor. ¿Hay alguna manera de convertir la propiedad ''number2'' en una cadena, o ignorarla por completo durante la deserialización?

He intentado agregar el atributo ''[JsonConverter (typeof (string))] a la propiedad de string2, pero recibo el error:'' Error al crear System.String ''. También he intentado configurar typeof (decimal).

También he intentado usar [JsonIgnore] pero eso no funciona.

Answer 1

Esta es una solución coja pero puede hacer un método para cargar manualmente el json. Si hay demasiados datos para cargar sin un deserializador automático, simplemente elimine los nodos que no desea. Esto es mucho más lento sin embargo.

public static List<Foo> FromJson(string input) {
    var json = JToken.Parse(input);
    json["key"].Remove();
    var foo = JsonConvert.DeserializeObject<List<Foo>>(json.ToString());

}

Este es un problema interesante. Me pregunto si alguien tiene una mejor solución para él.

Answer 2

Aquí está la forma preferida de Newtonsoft Json de ignorar una propiedad sin tener que modificar la clase según http://james.newtonking.com/json/help/index.html?topic=html/ReducingSerializedJSONSize.htm

Este se usa para ignorar las propiedades de referencia perezosas de EF o Linq2Sql

public class DynamicContractResolver : DefaultContractResolver
{
    protected override IList<JsonProperty> CreateProperties(Type type, 
        MemberSerialization memberSerialization)
    {
        Func<Type,bool> includeProperty = t => t.IsValueType || t.Namespace.StartsWith("System") && t.Namespace.StartsWith("System.Data")==false; 
        IList<JsonProperty> properties = base.CreateProperties(type, memberSerialization);
        var allProperties = properties.Select (p => new{p.PropertyName,Including=includeProperty(p.PropertyType), p.PropertyType});//.Dump("props");
        var warnProperties=allProperties.Where (a =>a.Including && a.PropertyType.IsValueType==false && a.PropertyType.Name.IsIgnoreCaseMatch("String")==false) ;

        //linq pad debugging helper
        //var propertyTypesSerializing= allProperties.Where (p => p.Including).Select (p => p.PropertyType).Distinct().OrderBy (p => p.Name).Dump();

        if(warnProperties.Any())
        {
            //LinqPad helper
            //Util.Highlight(warnProperties.ToArray()).Dump("warning flag raised, aborting");
            throw new ArgumentOutOfRangeException();
        }

        properties = properties.Where(p =>includeProperty(p.PropertyType)).ToList();
        return properties;
    }
}

Todas las llamadas .Dump() son solo asistentes de depuración de linqpad, llamadas de método no necesarias.

uso de muestra:

var inactives = from am in Aspnet_Memberships
        join mm in Member_members on am.UserId equals mm.Member_guid
        where mm.Is_active==false && mm.Org_id==1
        select new{am,mm};
        //inactives.Take(4).ToArray().Dump();
        var serialized = JsonConvert.SerializeObject(
            inactives.Skip(1).Select(i => i.mm).First(), 
            new  JsonSerializerSettings()
            {
                ContractResolver = new DynamicContractResolver(), 
                PreserveReferencesHandling = PreserveReferencesHandling.None,
                ReferenceLoopHandling= ReferenceLoopHandling.Ignore
            }); 
            //.Dump();

Answer 3

Similar a la solución de @ Maslow , puede usar otro "ignorante" de propósito general :

var jsonResolver = new IgnorableSerializerContractResolver();
// ignore your specific property
jsonResolver.Ignore(typeof(Foo), "string2");
// ignore single datatype
jsonResolver.Ignore(typeof(System.Data.Objects.DataClasses.EntityObject));
var jsonSettings = new JsonSerializerSettings() { ReferenceLoopHandling = ReferenceLoopHandling.Ignore, ContractResolver = jsonResolver };

Answer 4

Puede usar la propiedad MissingMemberHandling del objeto JsonSerializerSettings .

Ejemplo de uso:

var jsonSerializerSettings = new JsonSerializerSettings();
jsonSerializerSettings.MissingMemberHandling = MissingMemberHandling.Ignore;

JsonConvert.DeserializeObject<YourClass>(jsonResponse, jsonSerializerSettings);

Más información aquí .