Come si ignora la serializzazione di array JavaScript predefinita per i tipi IEnumerable in Json.Net?

Question

Alcuni tipi personalizzati che implementano IEnumerable non hanno necessariamente raccolte di backup. Potrebbero essere generati dinamicamente, ad esempio usando "yield" o LINQ. Ecco un esempio:

public class SOJsonExample 
{ 
    public class MyCustomEnumerable : IEnumerable<KeyValuePair<int,float>> 
    { 
     public List<int> Keys { get; set; } 
     public List<float> Values { get; set; } 

     public MyCustomEnumerable() 
     { 
      Keys = new List<int> { 1, 2, 3 }; 
      Values = new List<float> { 0.1f, 0.2f, 0.3f }; 
     } 

     public IEnumerator<KeyValuePair<int, float>> GetEnumerator() 
     { 
      var kvps = 
       from key in Keys 
       from value in Values 
       select new KeyValuePair<int, float>(key, value); 

      return kvps.GetEnumerator(); 
     } 

     IEnumerator IEnumerable.GetEnumerator() 
     { 
      return this.GetEnumerator(); 
     } 
    } 
} 

ho scoperto che la serializzazione predefinita Json.NET è di enumerare ogni valore e memorizzare i valori in un array JavaScript (che io non voglio). Il deserializzatore predefinito non riuscirà quindi a deserializzare la raccolta in quanto non può essere popolata. In questi casi, preferirei che Json.NET salti la serializzazione predefinita degli array JavaScript e memorizzi solo i membri della classe.

Tutto quello che voglio sono le mie chiavi e valori - c'è qualche modo di scelta rapida per fare questo, o devo implementare il mio serializzatore personalizzato?

Controllato this e this, nessuno dei quali è esattamente la mia domanda. Scansionato anche the documentation, ma non ho trovato quello che stavo cercando (forse ho cercato nel posto sbagliato).

(Modifica # 1 - una maggiore chiarezza)

(Edit # 2 - ha risposto alla mia domanda ... vedi sotto)

Answer 1

risposto alla mia domanda - vedi l'ottimo documentation on IEnumerable, Lists, and Arrays:

Gli elenchi .NET (tipi che ereditano da IEnumerable) e .NET vengono convertiti in array JSON. Poiché gli array JSON supportano solo un intervallo di valori e non proprietà, eventuali proprietà aggiuntive e campi dichiarati su raccolte .NET non vengono serializzati. Nelle situazioni in cui non è richiesto un array JSON, JsonObjectAttribute può essere inserito in un tipo .NET che implementa IEnumerable per forzare il tipo a essere serializzato come un oggetto JSON.

Quindi, per il mio esempio:

[JsonObject] 
public class MyCustomEnumerable : IEnumerable<KeyValuePair<int,float>> 
{ 
    ... 
}