Ignorer les membres de classe qui lèvent des exceptions lors de la sérialisation en JSON
J'utilise le sérialiseur JSON de Newtonsoft et il fonctionne pour la plupart des objets.
Malheureusement, j'obtiens un JsonSerializationException lorsque j'essaie de sérialiser un gros objet, dont l'un des membres lance un NullReferenceException.
Existe-t-il de toute façon d'ignorer le membre incriminé et de sérialiser le reste de l'objet?
Je pense peut-être dans le JsonSerializerSettings?
Voici une version simplifiée de ce que je veux faire:
private class TestExceptionThrowingClass
{
public string Name { get { return "The Name"; } }
public string Address { get { throw new NullReferenceException(); } }
public int Age { get { return 30; } }
}
[Test]
public void CanSerializeAClassWithAnExceptionThrowingMember()
{
// Arrange
var toSerialize = new TestExceptionThrowingClass();
// Act
var serializerSettings = new Newtonsoft.Json.JsonSerializerSettings();
serializerSettings.MaxDepth = 5;
serializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
serializerSettings.MissingMemberHandling = Newtonsoft.Json.MissingMemberHandling.Ignore;
serializerSettings.NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore;
serializerSettings.ObjectCreationHandling = Newtonsoft.Json.ObjectCreationHandling.Reuse;
serializerSettings.DefaultValueHandling = Newtonsoft.Json.DefaultValueHandling.Ignore;
var result = Newtonsoft.Json.JsonConvert.SerializeObject(toSerialize);
// Assert
Assert.That(result, Is.EqualTo(@"{""Name"":""The Name"",""Age"":30}"));
}
Et voici la trace de la pile:
at Newtonsoft.Json.Serialization.DynamicValueProvider.GetValue(Object target)
at Newtonsoft.Json.Serialization.JsonSerializerInternalWriter.CalculatePropertyValues(JsonWriter writer, Object value, JsonContainerContract contract, JsonProperty member, JsonProperty property, JsonContract& memberContract, Object& memberValue)
at Newtonsoft.Json.Serialization.JsonSerializerInternalWriter.SerializeObject(JsonWriter writer, Object value, JsonObjectContract contract, JsonProperty member, JsonContainerContract collectionContract, JsonProperty containerProperty)
at Newtonsoft.Json.Serialization.JsonSerializerInternalWriter.SerializeValue(JsonWriter writer, Object value, JsonContract valueContract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerProperty)
at Newtonsoft.Json.Serialization.JsonSerializerInternalWriter.Serialize(JsonWriter jsonWriter, Object value, Type objectType)
at Newtonsoft.Json.JsonSerializer.SerializeInternal(JsonWriter jsonWriter, Object value, Type objectType)
at Newtonsoft.Json.JsonConvert.SerializeObject(Object value, Type type, Formatting formatting, JsonSerializerSettings settings)
at Newtonsoft.Json.JsonConvert.SerializeObject(Object value)
at AspectsProject.Aspects.CachingPolicy.CachingPolicyCacheKeyCreatorTests.CanSerializeAClassWithAnExceptionThrowingMember() in D:\Dev\test.cs:line 169
--NullReferenceException
at AspectsProject.Aspects.CachingPolicy.CachingPolicyCacheKeyCreatorTests.TestExceptionThrowingClass.get_Address() in D:\Dev\test.cs:line 149
at GetAddress(Object )
at Newtonsoft.Json.Serialization.DynamicValueProvider.GetValue(Object target)
Je suis heureux d'utiliser un sérialiseur JSON différent si quelqu'un en connaît un qui le fera.
Si vous ne contrôlez pas le code source, vous pouvez utiliser un ContractResolver personnalisé pour injecter une méthode "ShouldSerialize" pour la propriété problématique pendant la sérialisation. Vous pouvez faire en sorte que cette méthode retourne toujours false, ou éventuellement implémenter une logique qui détectera les situations dans lesquelles la propriété lèvera et retournera false uniquement dans ce cas.
Par exemple, supposons que votre classe ressemble à ceci:
class Problematic
{
public int Id { get; set; }
public string Name { get; set; }
public object Offender
{
get { throw new NullReferenceException(); }
}
}
De toute évidence, si nous essayons de sérialiser ce qui précède, cela ne fonctionnera pas car la propriété Offender lèvera toujours une exception lorsque le sérialiseur essaie d'y accéder. Étant donné que nous connaissons le nom de classe et de propriété à l'origine du problème, nous pouvons écrire un ContractResolver personnalisé (dérivé du DefaultContractResolver) pour supprimer la sérialisation de ce membre spécifique.
class CustomResolver : DefaultContractResolver
{
protected override JsonProperty CreateProperty(MemberInfo member,
MemberSerialization memberSerialization)
{
JsonProperty property = base.CreateProperty(member, memberSerialization);
if (property.DeclaringType == typeof(Problematic) &&
property.PropertyName == "Offender")
{
property.ShouldSerialize = instanceOfProblematic => false;
}
return property;
}
}
Voici une démo montrant comment l'utiliser:
class Program
{
static void Main(string[] args)
{
Problematic obj = new Problematic
{
Id = 1,
Name = "Foo"
};
JsonSerializerSettings settings = new JsonSerializerSettings();
settings.ContractResolver = new CustomResolver();
string json = JsonConvert.SerializeObject(obj, settings);
Console.WriteLine(json);
}
}
Production:
{"Id":1,"Name":"Foo"}
Une solution plus générique
Dans vos commentaires, vous avez indiqué que de nombreux types d'objets pouvaient générer une exception lors de l'accès à l'une des propriétés. À cette fin, nous avons besoin de quelque chose de plus générique. Voici un résolveur qui pourrait fonctionner dans ce cas, mais vous devrez le tester de manière approfondie dans votre propre environnement. Il ne dépend pas d'une classe ou d'un nom de propriété particulier, mais crée un prédicat ShouldSerialize pour chaque propriété qui lui parvient. Dans ce prédicat, il utilise la réflexion pour obtenir la valeur de la propriété dans un try/catch; s'il réussit, il renvoie vrai, sinon faux.
class CustomResolver : DefaultContractResolver
{
protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
{
JsonProperty property = base.CreateProperty(member, memberSerialization);
property.ShouldSerialize = instance =>
{
try
{
PropertyInfo prop = (PropertyInfo)member;
if (prop.CanRead)
{
prop.GetValue(instance, null);
return true;
}
}
catch
{
}
return false;
};
return property;
}
}
Voici une démo:
class Program
{
static void Main(string[] args)
{
List<MightThrow> list = new List<MightThrow>
{
new MightThrow { Flags = ThrowFlags.None, Name = "none throw" },
new MightThrow { Flags = ThrowFlags.A, Name = "A throws" },
new MightThrow { Flags = ThrowFlags.B, Name = "B throws" },
new MightThrow { Flags = ThrowFlags.Both, Name = "both throw" },
};
JsonSerializerSettings settings = new JsonSerializerSettings();
settings.ContractResolver = new CustomResolver();
settings.Formatting = Formatting.Indented;
string json = JsonConvert.SerializeObject(list, settings);
Console.WriteLine(json);
}
}
[Flags]
enum ThrowFlags
{
None = 0,
A = 1,
B = 2,
Both = 3
}
class MightThrow
{
public string Name { get; set; }
public ThrowFlags Flags { get; set; }
public string A
{
get
{
if ((Flags & ThrowFlags.A) == ThrowFlags.A)
throw new Exception();
return "a";
}
}
public string B
{
get
{
if ((Flags & ThrowFlags.B) == ThrowFlags.B)
throw new Exception();
return "b";
}
}
}
Production:
[
{
"Name": "none throw",
"Flags": 0,
"A": "a",
"B": "b"
},
{
"Name": "A throws",
"Flags": 1,
"B": "b"
},
{
"Name": "B throws",
"Flags": 2,
"A": "a"
},
{
"Name": "both throw",
"Flags": 3
}
]
Un moyen plus simple d'ignorer les erreurs:
JsonSerializerSettings settings = new JsonSerializerSettings();
settings.Error = (serializer,err) => {
err.ErrorContext.Handled = true;
}
ou
settings.Error = (serializer,err) => err.ErrorContext.Handled = true;