Wie kann ich ein Attribut in einer abgeleiteten Klasse "un-JsonIgnore"?

Question

Ich verwende Newtonsoft's JsonSerializer, um einige Klassen zu serialisieren.

Als ich ein Feld meiner Klasse in der Serialisierung verzichten wollte, erklärte ich es wie folgt:

[JsonIgnore] 
public int ParentId { get; set; } 

Das funktionierte, aber ich bin jetzt ein neues Problem: In einer abgeleiteten Klasse I möchte, dass dieses Feld angezeigt wird (und tun Sie dies nur in dieser spezifischen abgeleiteten Klasse).

Ich habe in der Dokumentation und im Internet nach einer Möglichkeit gesucht, diese Einstellung in untergeordneten Klassen zu überschreiben (ich denke, ich brauche etwas wie [JsonStopIgnore], aber ich konnte nichts in der Nähe finden).

---

• Gibt es für mich eine Möglichkeit, JsonSerializer zu zwingen, wieder dieses Attribut zu holen?
• Ist es möglich, ein Attribut explizit als [JsonIgnore], aber nur in der Basisklasse zu markieren?

Answer 1

Sie können dies tun, indem Sie eine benutzerdefinierte DefaultContractResolver Erstellen und Überschreiben seine CreateProperty Methode.

Zum Beispiel gegeben eine Foo Basis und eine abgeleitete Bar:

public class Foo 
{ 
    [JsonIgnore] 
    public string Name { get; set; } 
    public int Age { get; set; } 
} 

public class Bar : Foo 
{ } 

Sie können folgende Vertrags Resolver erstellen:

public class MyTypeContractResolver<T> : DefaultContractResolver 
{ 
    protected override JsonProperty CreateProperty(MemberInfo member, 
                MemberSerialization 
                 memberSerialization) 
    { 
     var property = base.CreateProperty(member, memberSerialization); 

     property.Ignored = false; 
     property.ShouldSerialize = propInstance => property.DeclaringType != typeof (T); 
     return property; 
    } 
} 

Diese alle Eigenschaften Ignored = false gesetzt wird, und dann analysieren durch das gegebene Prädikat:

propInstance => property.DeclaringType != typeof (T); 

Was in unserem Fall bedeutet "Sie sollten nur serialisieren, wenn sie nicht vom Typ Foo sind" (da Foo der DeclaryingType ist).

Und dann, wenn Sie deserialisieren möchten, können Sie eine Instanz des Vertrages Resolver JsonSerializerSettings passieren:

var bar = new Bar(); 
var result = JsonConvert.SerializeObject(bar, 
    new JsonSerializerSettings {ContractResolver = new MyTypeContractResolver<Bar>()}); 

Answer 2

Sie können wahrscheinlich ParentId in der abgeleiteten Klasse einfach überschreiben.

public new int ParentId 
{ 
    get { return base.ParentId; } 
    set { base.ParentId = value; } 
} 

Answer 3

Die einzige Möglichkeit, das Verhalten des [JsonIgnore] Attribut auf „Override“ ist ein Vertrag Resolver zu verwenden, wie @ Yuval Itzchakov in seiner Antwort schön erklärt.

Allerdings gibt es eine weitere mögliche Lösung, die für Sie arbeiten könnte: stattdessen ein [JsonIgnore] Attribut zu verwenden, können Sie eine ShouldSerializeParentId() Methode in Klassen implementieren zu steuern, ob die ParentId Eigenschaft serialisiert wird. Geben Sie in der Basisklasse diese Methode false zurück; Überschreiben Sie dann die Methode in der abgeleiteten Klasse, um true zurückzugeben. (Diese Funktion ist in Json.Net als conditional property serialization bekannt.

)

public class Base 
{ 
    public int Id { get; set; } 
    public int ParentId { get; set; } 

    public virtual bool ShouldSerializeParentId() 
    { 
     return false; 
    } 
} 

public class Derived : Base 
{ 
    public override bool ShouldSerializeParentId() 
    { 
     return true; 
    } 
} 

Fiddle: https://dotnetfiddle.net/65sCSz

Answer 4

Ich löste das gleiche Problem mit dem neuen Schlüsselwort auf der Eigenschaft der abgeleiteten Klasse.

public class Foo 
{ 
    [JsonIgnore] 
    public int ParentId { get; set; } 
} 

public class Bar: Foo 
{ 
    [JsonProperty("ParentId")] 
    public new int ParentId { get; set; } 
} 

Answer 5

Ich löste das gleiche Problem mit einem Geister Eigenschaft:

public class Foo 
{ 
    [JsonIgnore] 
    public int ParentId { get; set; } 

    [NotMapped] 
    public int FooParent { get; set; } 
} 

Wenn ich ziemlich immer versteckt diese Eigenschaft zeigen wollen, ich bevölkern es, ein anderes Mal ist es null:

Foos.ForEach(x => x.FooParent = ParentId);