Wywołanie rekursywnie JsonSerializer w JsonConverter

Question

Piszę JsonConverter, aby wykonać niektóre zadania konwersji, które muszę wykonać podczas odczytu/zapisu. W szczególności zajmuję się istniejącym zachowaniem serializacji i sczepieniem pewnych dodatkowych właściwości podczas zapisu/odczytu tych dodatkowych właściwości podczas odczytu.

Wewnątrz JsonConverter, chciałbym skorzystać z przekazanej instancji JsonSerializer, aby wykonać większość funkcji konwersji. Jednakże, gdy to zrobię, kończę pętlę rekursywną, w której serializator wywołuje mój konwerter, który dzwoni do serializatora, który wywołuje konwerter itp.

Widziałem ludzi, którzy robili takie rzeczy, jak używanie JsonConvert.SerializeObject, przekazywanie wszystkich konwerterów z instancji serializera z wyjątkiemthis. Nie zadziała to jednak dla mnie, ponieważ pomija wszystkie inne dostosowania, które wykonałem w moim serializatorze, takie jak niestandardowy resolver umowy i obsługa DateTime.

Czy istnieje sposób mogę albo:

1. Zastosowanie instancja serializer przeszedł do mnie, ale jakoś wykluczyć mój konwertera lub
2. sklonować serializer przeszedł do mnie (bez ręcznego konstruowania nowego i kopiowanie własności według właściwości) i usunięcie mojego konwertera?

Answer 1

Jest to bardzo częsty problem. Używanie "JsonConvert.SerializeObject" nie jest złym pomysłem. Jednak jedną sztuczką, którą można wykorzystać w niektórych okolicznościach (zazwyczaj kolekcje), jest rzutowanie na interfejs podczas zapisu i deserializacji do prostej pochodnej podczas czytania.

Poniżej znajduje się prosty konwerter, który zajmuje się słownikami, które mogły zostać serializacji jako zbiór KVPS zamiast patrząc jak przedmiot (widocznych w moim wieku tutaj :))

Note „WriteJson” rzuca do IDictionary < K , V> i "ReadJson" używa "DummyDictionary". Kończysz właściwą rzeczą, ale używasz serializera przekazanego bez powodowania rekursji.

/// <summary> 
/// Converts a <see cref="KeyValuePair{TKey,TValue}"/> to and from JSON. 
/// </summary> 
public class DictionaryAsKVPConverter<TKey, TValue> : JsonConverter 
{ 
    /// <summary> 
    /// Determines whether this instance can convert the specified object type. 
    /// </summary> 
    /// <param name="objectType">Type of the object.</param> 
    /// <returns> 
    ///  <c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>. 
    /// </returns> 
    public override bool CanConvert(Type objectType) 
    { 
     if (!objectType.IsValueType && objectType.IsGenericType) 
      return (objectType.GetGenericTypeDefinition() == typeof(Dictionary<,>)); 

     return false; 
    } 

    /// <summary> 
    /// Writes the JSON representation of the object. 
    /// </summary> 
    /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param> 
    /// <param name="value">The value.</param> 
    /// <param name="serializer">The calling serializer.</param> 
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) 
    { 
     var dictionary = value as IDictionary<TKey, TValue>; 
     serializer.Serialize(writer, dictionary); 
    } 

    /// <summary> 
    /// Reads the JSON representation of the object. 
    /// </summary> 
    /// <param name="reader">The <see cref="JsonReader"/> to read from.</param> 
    /// <param name="objectType">Type of the object.</param> 
    /// <param name="existingValue">The existing value of object being read.</param> 
    /// <param name="serializer">The calling serializer.</param> 
    /// <returns>The object value.</returns> 
    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) 
    { 
     Dictionary<TKey, TValue> dictionary; 

     if (reader.TokenType == JsonToken.StartArray) 
     { 
      dictionary = new Dictionary<TKey, TValue>(); 
      reader.Read(); 
      while (reader.TokenType == JsonToken.StartObject) 
      { 
       var kvp = serializer.Deserialize<KeyValuePair<TKey, TValue>>(reader); 
       dictionary[kvp.Key] = kvp.Value; 
       reader.Read(); 
      } 
     } 
     else if (reader.TokenType == JsonToken.StartObject) 
      // Use DummyDictionary to fool JsonSerializer into not using this converter recursively 
      dictionary = serializer.Deserialize<DummyDictionary>(reader); 
     else 
      dictionary = new Dictionary<TKey, TValue>(); 

     return dictionary; 
    } 

    /// <summary> 
    /// Dummy to fool JsonSerializer into not using this converter recursively 
    /// </summary> 
    private class DummyDictionary : Dictionary<TKey, TValue> { } 
} 

Answer 2

Przepraszam, ale może jestem zagmatwany. Użyłem tej metody serializacji moje obiekty:

using System; 
 
using Newtonsoft.Json; 
 

 
namespace Utilities 
 
{ 
 
    public static class serializer 
 
    { 
 
     public static string SerializeObject(object objectModel) { 
 
      return JsonConvert.SerializeObject(objectModel); 
 
     } 
 
     public static object DeserializeObject<T>(string jsonObject) 
 
     { 
 
      try 
 
      { 
 
       return JsonConvert.DeserializeObject<T>(jsonObject); 
 
      } 
 
      catch (Exception ex) { return null; } 
 
      
 
     } 
 
    } 
 
}

i użyłem tego kodu:

userLoged = (modelUser)serializer.DeserializeObject<modelUser>((string)Session["userLoged"]);

Mam nadzieję, że to był pomocny.