Eigenschaft von Serialisierung über benutzerdefiniertes Attribut ausschließen (json.net)

Ich in der Lage sein müssen zu kontrollieren, wie/ob bestimmte Eigenschaften in einer Klasse serialisiert werden. Der einfachste Fall ist [ScriptIgnore]. Jedoch, ich will nur diese Attribute geehrt werden, für dieses eine bestimmte Serialisierung situation, in der ich arbeite - wenn andere Module downstream in der Anwendung serialisieren möchten diese Objekte, keines dieser Attribute sollten in die Quere kommen.

Also mein Gedanke ist, verwenden Sie ein benutzerdefiniertes Attribut MyAttribute auf die Eigenschaften, und initialisieren Sie die spezifische Instanz von JsonSerializer mit einem Haken, der weiß, dass zu sehen, dass für das Attribut.

Auf den ersten Blick sehe ich keine der verfügbaren Haken Punkte in JSON.NET wird die PropertyInfo für die current-Eigenschaft zu tun, einer Prüfung - nur der Wert der Eigenschaft. Bin ich etwas fehlt? Oder einen besseren Weg, um diesen Ansatz?

InformationsquelleAutor der Frage Rex M | 2012-11-27

c#custom-attributes json.net serialization

Haben Sie ein paar Optionen. Ich empfehle Ihnen, Lesen Sie die Json.Net Dokumentation Artikel zum Thema vor, unten zu Lesen.

Der Artikel stellt zwei Methoden:

Erstellen Sie eine Methode, die zurückgibt einen bool Wert basiert auf einer Namenskonvention, Json.Net Folgen werden, um zu bestimmen, ob oder nicht zu serialisieren der Eigenschaft.
Erstellen Sie eine benutzerdefinierte Vertrag resolver ignoriert, dass die Eigenschaft.

Den beiden, ich bevorzuge die letztere. Überspringen Attribute zusammen -- nur verwenden, Sie zu ignorieren-Eigenschaften über alle Formen der Serialisierung. Erstellen Sie stattdessen eine benutzerdefinierte Vertrag resolver ignoriert, dass die Eigenschaft in Frage, und verwenden Sie nur den Vertrag resolver-wenn Sie möchten, ignorieren Sie die Eigenschaft, so dass andere Benutzer der Klasse frei zu serialisieren der Eigenschaft oder nicht an Ihrer eigenen Lust und Laune.

Bearbeiten Zu vermeiden, link rot, ich bin Entsendung der in Frage stehenden code aus dem Artikel

public class ShouldSerializeContractResolver : DefaultContractResolver
{
   public new static readonly ShouldSerializeContractResolver Instance =
                                 new ShouldSerializeContractResolver();

   protected override JsonProperty CreateProperty( MemberInfo member,
                                    MemberSerialization memberSerialization )
   {
      JsonProperty property = base.CreateProperty( member, memberSerialization );

      if( property.DeclaringType == typeof(Employee) &&
            property.PropertyName == "Manager" )
      {
         property.ShouldSerialize = instance =>
         {
            //replace this logic with your own, probably just  
            //return false;
            Employee e = (Employee)instance;
            return e.Manager != e;
         };
      }

      return property;
   }
}

InformationsquelleAutor der Antwort Randolpho

Hier ist eine generische wiederverwendbare "ignore" resolver basierend auf die akzeptierte Antwort:

///<summary>
///Special JsonConvert resolver that allows you to ignore properties.  See https://stackoverflow.com/a/13588192/1037948
///</summary>
public class IgnorableSerializerContractResolver : DefaultContractResolver {
    protected readonly Dictionary<Type, HashSet<string>> Ignores;

    public IgnorableSerializerContractResolver() {
        this.Ignores = new Dictionary<Type, HashSet<string>>();
    }

    ///<summary>
    ///Explicitly ignore the given property(s) for the given type
    ///</summary>
    ///<param name="type"></param>
    ///<param name="propertyName">one or more properties to ignore.  Leave empty to ignore the type entirely.</param>
    public void Ignore(Type type, params string[] propertyName) {
        //start bucket if DNE
        if (!this.Ignores.ContainsKey(type)) this.Ignores[type] = new HashSet<string>();

        foreach (var prop in propertyName) {
            this.Ignores[type].Add(prop);
        }
    }

    ///<summary>
    ///Is the given property for the given type ignored?
    ///</summary>
    ///<param name="type"></param>
    ///<param name="propertyName"></param>
    ///<returns></returns>
    public bool IsIgnored(Type type, string propertyName) {
        if (!this.Ignores.ContainsKey(type)) return false;

        //if no properties provided, ignore the type entirely
        if (this.Ignores[type].Count == 0) return true;

        return this.Ignores[type].Contains(propertyName);
    }

    ///<summary>
    ///The decision logic goes here
    ///</summary>
    ///<param name="member"></param>
    ///<param name="memberSerialization"></param>
    ///<returns></returns>
    protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization) {
        JsonProperty property = base.CreateProperty(member, memberSerialization);

        if (this.IsIgnored(property.DeclaringType, property.PropertyName)
        //need to check basetype as well for EF -- @per comment by user576838
        || this.IsIgnored(property.DeclaringType.BaseType, property.PropertyName)) {
            property.ShouldSerialize = instance => { return false; };
        }

        return property;
    }
}

Und Verwendung:

var jsonResolver = new IgnorableSerializerContractResolver();
//ignore single property
jsonResolver.Ignore(typeof(Company), "WebSites");
//ignore single datatype
jsonResolver.Ignore(typeof(System.Data.Objects.DataClasses.EntityObject));
var jsonSettings = new JsonSerializerSettings() { ReferenceLoopHandling = ReferenceLoopHandling.Ignore, ContractResolver = jsonResolver };

InformationsquelleAutor der Antwort drzaus

Verwenden Sie die JsonIgnore Attribut.

Beispielsweise ausschließen Id:

public class Person {
    [JsonIgnore]
    public int Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

InformationsquelleAutor der Antwort ramonesteban78

Hier ist eine Methode, basierend auf drzaus' ausgezeichnete serializer Vertrages verwendet lambda-Ausdrücke. Einfach fügen Sie Sie der gleichen Klasse. Nachdem alle, die nicht lieber dem compiler zu tun, der die Prüfung für Sie?

public IgnorableSerializerContractResolver Ignore<TModel>(Expression<Func<TModel, object>> selector)
{
    MemberExpression body = selector.Body as MemberExpression;

    if (body == null)
    {
        UnaryExpression ubody = (UnaryExpression)selector.Body;
        body = ubody.Operand as MemberExpression;

        if (body == null)
        {
            throw new ArgumentException("Could not get property name", "selector");
        }
    }

    string propertyName = body.Member.Name;
    this.Ignore(typeof (TModel), propertyName);
    return this;
}

Können Sie jetzt ignorieren, die Eigenschaften leicht und fließend:

contract.Ignore<Node>(node => node.NextNode)
    .Ignore<Node>(node => node.AvailableNodes);

InformationsquelleAutor der Antwort Steve Rukuts

I don ' T care zu setzen, die Namen der Eigenschaft als String, falls Sie es jemals ändern würde brechen meine anderen code.

Hatte ich verschiedene "view modes" auf die Objekte, die ich brauchte, um serialisiert, so landete ich tun so etwas wie dieses, die im Vertrag resolver (Ansicht-Modus zur Verfügung gestellt von Konstruktor-argument):

protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
{
    JsonProperty property = base.CreateProperty(member, memberSerialization);
    if (viewMode == ViewModeEnum.UnregisteredCustomer && member.GetCustomAttributes(typeof(UnregisteredCustomerAttribute), true).Length == 0)
    {
        property.ShouldSerialize = instance => { return false; };
    }

    return property;
}

Wo meine Objekte so Aussehen:

public interface IStatement
{
    [UnregisteredCustomer]
    string PolicyNumber { get; set; }

    string PlanCode { get; set; }

    PlanStatus PlanStatus { get; set; }

    [UnregisteredCustomer]
    decimal TotalAmount { get; }

    [UnregisteredCustomer]
    ICollection<IBalance> Balances { get; }

    void SetBalances(IBalance[] balances);
}

Der Nachteil wäre, das bit der Reflexion, der resolver, aber ich denke es lohnt sich es zu haben, mehr wartbar code.

InformationsquelleAutor der Antwort frattaro

Hatte ich gute Ergebnisse mit der Kombination der beiden drzaus und Steve Rukuts Antworten. Allerdings habe ich vor einem problem, wenn ich JsonPropertyAttribute mit einem anderen Namen oder caps für die Eigenschaft. Zum Beispiel:

[JsonProperty("username")]
public string Username { get; set; }

Gehören UnderlyingName Berücksichtigung löst das problem:

protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
{
    JsonProperty property = base.CreateProperty(member, memberSerialization);

    if (this.IsIgnored(property.DeclaringType, property.PropertyName)
        || this.IsIgnored(property.DeclaringType, property.UnderlyingName)
        || this.IsIgnored(property.DeclaringType.BaseType, property.PropertyName)
        || this.IsIgnored(property.DeclaringType.BaseType, property.UnderlyingName))
    {
        property.ShouldSerialize = instance => { return false; };
    }

    return property;
}

InformationsquelleAutor der Antwort Baron Ch'ng

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.