Domanda Serializza solo le proprietà dell'interfaccia su JSON con Json.net


Con una semplice classe / interfaccia come questa

public interface IThing
{
    string Name { get; set; }
}

public class Thing : IThing
{
    public int Id { get; set; }
    public string Name { get; set; }
}

Come posso ottenere la stringa JSON con solo la proprietà "Name" (solo le proprietà dell'interfaccia sottostante)?

In realtà, quando lo faccio:

var serialized = JsonConvert.SerializeObject((IThing)theObjToSerialize, Formatting.Indented);
Console.WriteLine(serialized);

Ottengo l'oggetto completo come JSON (Id + Name);


24
2018-06-15 12:49


origine


risposte:


È possibile utilizzare la serializzazione condizionale. Guarda questo collegamento. In sostanza, è necessario implementare il IContractResolver interfaccia, sovraccaricare il ShouldSerialize metodo e passare il resolver al costruttore di Json Serializer.


9
2018-06-15 13:30



Il metodo che uso,

public class InterfaceContractResolver : DefaultContractResolver
{
    private readonly Type _InterfaceType;
    public InterfaceContractResolver (Type InterfaceType)
    {
        _InterfaceType = InterfaceType;
    }

    protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
    {
        //IList<JsonProperty> properties = base.CreateProperties(type, memberSerialization);
        IList<JsonProperty> properties = base.CreateProperties(_InterfaceType, memberSerialization);
        return properties;
    }
}

// To serialize do this:
var settings = new JsonSerializerSettings() {
     ContractResolver = new InterfaceContractResolver (typeof(IThing))
});
string json = JsonConvert.SerializeObject(theObjToSerialize, settings);

19
2018-01-05 02:23



Ispirato da @ user3161686, ecco una piccola modifica a InterfaceContractResolver:

public class InterfaceContractResolver<TInterface> : DefaultContractResolver where TInterface : class
{
    protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
    {
        IList<JsonProperty> properties = base.CreateProperties(typeof(TInterface), memberSerialization);
        return properties;
    }
}

14
2018-04-03 22:33



Versione migliorata con interfacce nidificate + supporto per oggetti xsd.exe

Ancora un'altra variazione qui. Il codice è venuto http://www.tomdupont.net/2015/09/how-to-only-serialize-interface.html con i seguenti miglioramenti rispetto ad altre risposte qui

  • Gestisce la gerarchia, quindi se ne hai uno Interface2[] all'interno di un Interface1 quindi verrà serializzato.
  • Stavo cercando di serializzare un oggetto proxy WCF e il risultante JSON è apparso come {}. Risolto che tutte le proprietà erano impostate su Ignore=true quindi ho dovuto aggiungere un ciclo per impostarli a non essere ignorati.

    public class InterfaceContractResolver : DefaultContractResolver
    {
        private readonly Type[] _interfaceTypes;
    
        private readonly ConcurrentDictionary<Type, Type> _typeToSerializeMap;
    
        public InterfaceContractResolver(params Type[] interfaceTypes)
        {
            _interfaceTypes = interfaceTypes;
    
            _typeToSerializeMap = new ConcurrentDictionary<Type, Type>();
        }
    
        protected override IList<JsonProperty> CreateProperties(
            Type type,
            MemberSerialization memberSerialization)
        {
            var typeToSerialize = _typeToSerializeMap.GetOrAdd(
                type,
                t => _interfaceTypes.FirstOrDefault(
                    it => it.IsAssignableFrom(t)) ?? t);
    
            var props = base.CreateProperties(typeToSerialize, memberSerialization);
    
            // mark all props as not ignored
            foreach (var prop in props)
            {
                prop.Ignored = false;
            }
    
            return props;
        }
    }
    

6
2018-01-13 04:39



È possibile aggiungere il [JsonIgnore] annotazione per ignorare un attributo.


5
2018-06-15 12:56



Un'alternativa a [JsonIgnore] sono i [DataContract] e [DataMember] attributi. Se la tua classe è taggata con [DataContract] il serializzatore elaborerà solo le proprietà contrassegnate con [DataMember] attributo (JsonIgnore è un modello di "opt-out" mentre DataContract è "op-in").

[DataContract]
public class Thing : IThing
{
    [DataMember]
    public int Id { get; set; }

    public string Name { get; set; }
}

La limitazione di entrambi gli approcci è che devono essere implementati nella classe, non è possibile aggiungerli alla definizione dell'interfaccia.


5
2017-08-06 17:00



oltre alla risposta fornita da @monrow puoi utilizzare il [DataContract] e [DataMember] predefiniti dai un'occhiata a questo

http://james.newtonking.com/archive/2009/10/23/efficient-json-with-json-net-reducing-serialized-json-size.aspx


2
2018-06-15 13:00



Finalmente ho capito quando non funzionerà ... Se si desidera avere all'interno di un altro oggetto complesso, non verrà serializzato correttamente.

Così ho creato la versione che estrarrà solo i dati memorizzati in un assembly specifico e per i tipi che hanno la stessa interfaccia di base.

Quindi è realizzato come .Net Core JsonContractResolver.

Oltre all'estrazione dei dati, risolve:
a) conversione di camelCase prima di inviare i dati al client
b) utilizza la maggior parte dell'interfaccia dell'intervallo consentito (dall'assemblaggio) c) corregge l'ordine dei campi: il campo della maggior parte della classe base verrà elencato per primo e l'oggetto nidificato soddisferà anche questa regola.

public class OutputJsonResolver : DefaultContractResolver
{
    #region Static Members
    private static readonly object syncTargets = new object();
    private static readonly Dictionary<Type, IList<JsonProperty>> Targets = new Dictionary<Type, IList<JsonProperty>>();

    private static readonly Assembly CommonAssembly = typeof(ICommon).Assembly;
    #endregion

    #region Override Members
    protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
    {
        if (type.Assembly != OutputJsonResolver.CommonAssembly)
            return base.CreateProperties(type, memberSerialization);

        IList<JsonProperty> properties;
        if (OutputJsonResolver.Targets.TryGetValue(type, out properties) == false)
        {
            lock (OutputJsonResolver.syncTargets)
            {
                if (OutputJsonResolver.Targets.ContainsKey(type) == false)
                {
                    properties = this.CreateCustomProperties(type, memberSerialization);

                    OutputJsonResolver.Targets[type] = properties;
                }
            }
        }

        return properties;
    }
    protected override string ResolvePropertyName(string propertyName)
    {
        return propertyName.ToCase(Casing.Camel);
    }
    #endregion

    #region Assistants
    private IList<JsonProperty> CreateCustomProperties(Type type, MemberSerialization memberSerialization)
    {
        // Hierarchy
        IReadOnlyList<Type> types = this.GetTypes(type);

        // Head
        Type head = types.OrderByDescending(item => item.GetInterfaces().Length).FirstOrDefault();

        // Sources
        IList<JsonProperty> sources = base.CreateProperties(head, memberSerialization);

        // Targets
        IList<JsonProperty> targets = new List<JsonProperty>(sources.Count);

        // Repository
        IReadOnlyDistribution<Type, JsonProperty> repository = sources.ToDistribution(item => item.DeclaringType);

        foreach (Type current in types.Reverse())
        {
            IReadOnlyPage<JsonProperty> page;
            if (repository.TryGetValue(current, out page) == true)
                targets.AddRange(page);
        }

        return targets;
    }
    private IReadOnlyList<Type> GetTypes(Type type)
    {
        List<Type> types = new List<Type>();

        if (type.IsInterface == true)
            types.Add(type);

        types.AddRange(type.GetInterfaces());

        return types;
    }
    #endregion
}

1
2018-06-23 01:04