Tạo thuộc tính deserialize nhưng không tuần tự hóa với json.net

Chúng tôi có một số tệp cấu hình được tạo bằng cách tuần tự hóa các đối tượng C # với Json.net.

Chúng tôi muốn di chuyển một thuộc tính của lớp được tuần tự hóa từ một thuộc tính enum đơn giản sang một thuộc tính của lớp.

Một cách dễ dàng để thực hiện điều này, là để thuộc tính enum cũ trên lớp và sắp xếp để Json.net đọc thuộc tính này khi chúng ta tải cấu hình, nhưng không lưu lại khi chúng ta tuần tự hóa đối tượng tiếp theo. Chúng tôi sẽ giải quyết việc tạo lớp mới từ enum cũ một cách riêng biệt.

Có cách nào đơn giản để đánh dấu (ví dụ: với các thuộc tính) thuộc tính của một đối tượng C #, để Json.net CHỈ bỏ qua nó khi tuần tự hóa, nhưng chú ý đến nó khi giải mã không?

Thực tế có một số cách tiếp cận khá đơn giản mà bạn có thể sử dụng để đạt được kết quả như mong muốn.

Ví dụ, giả sử rằng bạn có các lớp của mình hiện được định nghĩa như thế này:

class Config
{
    public Fizz ObsoleteSetting { get; set; }
    public Bang ReplacementSetting { get; set; }
}

enum Fizz { Alpha, Beta, Gamma }

class Bang
{
    public string Value { get; set; }
}

Và bạn muốn làm điều này:

string json = @"{ ""ObsoleteSetting"" : ""Gamma"" }";

// deserialize
Config config = JsonConvert.DeserializeObject<Config>(json);

// migrate
config.ReplacementSetting = 
    new Bang { Value = config.ObsoleteSetting.ToString() };

// serialize
json = JsonConvert.SerializeObject(config);
Console.WriteLine(json);

Để có được điều này:

{"ReplacementSetting":{"Value":"Gamma"}}

Phương pháp 1: Thêm phương pháp ShouldSerialize

Json.NET có khả năng tuần tự hóa các thuộc tính có điều kiện bằng cách tìm kiếm ShouldSerialize phương thức trong lớp.

Để sử dụng tính năng này, hãy thêm một ShouldSerializeBlah()phương thức boolean vào lớp của bạn, nơi Blahđược thay thế bằng tên của thuộc tính mà bạn không muốn tuần tự hóa. Làm cho việc thực hiện phương pháp này luôn quay trở lại false.

class Config
{
    public Fizz ObsoleteSetting { get; set; }

    public Bang ReplacementSetting { get; set; }

    public bool ShouldSerializeObsoleteSetting()
    {
        return false;
    }
}

Lưu ý: nếu bạn thích cách tiếp cận này nhưng bạn không muốn làm xáo trộn giao diện công khai của lớp bằng cách giới thiệu một ShouldSerializephương thức, bạn có thể sử dụng một IContractResolverđể làm điều tương tự theo chương trình. Xem Serialization thuộc tính có điều kiện thuộc trong tài liệu.

Phương pháp 2: Thao tác JSON với JObjects

Thay vì sử dụng JsonConvert.SerializeObjectđể thực hiện tuần tự hóa, hãy tải đối tượng cấu hình vào a JObject, sau đó chỉ cần xóa thuộc tính không mong muốn khỏi JSON trước khi viết ra. Nó chỉ là một vài dòng mã bổ sung.

JObject jo = JObject.FromObject(config);

// remove the "ObsoleteSetting" JProperty from its parent
jo["ObsoleteSetting"].Parent.Remove();

json = jo.ToString();

Cách tiếp cận 3: Sử dụng các thuộc tính thông minh (ab)

1. Áp dụng một [JsonIgnore] thuộc tính cho thuộc tính mà bạn không muốn được tuần tự hóa.
2. Thêm một thay thế, riêng tư thiết lập thuộc tính vào lớp có cùng kiểu với thuộc tính ban đầu. Làm cho việc thực hiện thuộc tính đó đặt thuộc tính ban đầu.
3. Áp dụng một [JsonProperty]thuộc tính cho setter thay thế, đặt tên JSON giống như thuộc tính ban đầu.

Đây là Configlớp đã sửa đổi :

class Config
{
    [JsonIgnore]
    public Fizz ObsoleteSetting { get; set; }

    [JsonProperty("ObsoleteSetting")]
    private Fizz ObsoleteSettingAlternateSetter
    {
        // get is intentionally omitted here
        set { ObsoleteSetting = value; }
    }

    public Bang ReplacementSetting { get; set; }
}

Đối với bất kỳ tình huống nào có thể chấp nhận được việc đánh dấu thuộc tính chỉ deserialization của bạn là nội bộ, có một giải pháp cực kỳ đơn giản mà hoàn toàn không phụ thuộc vào thuộc tính. Chỉ cần đánh dấu thuộc tính là nội bộ nhận được, nhưng đặt công khai:

public class JsonTest {

    public string SomeProperty { internal get; set; }

}

Điều này dẫn đến việc deserialization chính xác bằng cách sử dụng cài đặt / trình phân giải / v.v. mặc định, nhưng thuộc tính bị tước khỏi đầu ra tuần tự hóa.

Tôi thích gắn bó với các thuộc tính trên cái này, đây là phương pháp tôi sử dụng khi cần giải mã hóa một thuộc tính nhưng không tuần tự hóa nó hoặc ngược lại.

BƯỚC 1 - Tạo thuộc tính tùy chỉnh

public class JsonIgnoreSerializationAttribute : Attribute { }

BƯỚC 2 - Tạo Trình phục hồi hợp đồng tùy chỉnh

class JsonPropertiesResolver : DefaultContractResolver
{
    protected override List<MemberInfo> GetSerializableMembers(Type objectType)
    {
        //Return properties that do NOT have the JsonIgnoreSerializationAttribute
        return objectType.GetProperties()
                         .Where(pi => !Attribute.IsDefined(pi, typeof(JsonIgnoreSerializationAttribute)))
                         .ToList<MemberInfo>();
    }
}

BƯỚC 3 - Thêm thuộc tính khi không cần tuần tự hóa nhưng không cần tuần tự hóa

    [JsonIgnoreSerialization]
    public string Prop1 { get; set; } //Will be skipped when serialized

    [JsonIgnoreSerialization]
    public string Prop2 { get; set; } //Also will be skipped when serialized

    public string Prop3 { get; set; } //Will not be skipped when serialized

BƯỚC 4 - Sử dụng nó

var sweet = JsonConvert.SerializeObject(myObj, new JsonSerializerSettings { ContractResolver = new JsonPropertiesResolver() });

Hi vọng điêu nay co ich! Ngoài ra, điều đáng chú ý là điều này cũng sẽ bỏ qua các thuộc tính khi Deserialization xảy ra, khi tôi đang derserializing, tôi chỉ sử dụng bộ chuyển đổi theo cách thông thường.

JsonConvert.DeserializeObject<MyType>(myString);

Sử dụng thuộc tính setter:

[JsonProperty(nameof(IgnoreOnSerializing))]
public string IgnoreOnSerializingSetter { set { _ignoreOnSerializing = value; } }

[JsonIgnore]
private string _ignoreOnSerializing;

[JsonIgnore]
public string IgnoreOnSerializing
{
    get { return this._ignoreOnSerializing; }
    set { this._ignoreOnSerializing = value; }
}

Hy vọng điều này giúp đỡ.

Sau khi tôi đã dành một thời gian khá dài để tìm kiếm cách gắn cờ một thuộc tính lớp là De-Serializable và NOT Serializable, tôi thấy rằng không có thứ gì để làm điều đó cả; vì vậy tôi đã nghĩ ra một giải pháp kết hợp hai thư viện hoặc kỹ thuật tuần tự hóa khác nhau (System.Runtime.Serialization.Json & Newtonsoft.Json) và nó hoạt động với tôi như sau:

• gắn cờ tất cả các lớp và lớp con của bạn là "DataContract".
• gắn cờ tất cả các thuộc tính của lớp và các lớp con của bạn là "DataMember".
• gắn cờ tất cả các thuộc tính của lớp và các lớp con của bạn là "JsonProperty" ngoại trừ những thuộc tính mà bạn muốn chúng không được tuần tự hóa.
• bây giờ gắn cờ các thuộc tính mà bạn KHÔNG muốn nó được tuần tự hóa thành "JsonIgnore".

• sau đó Serialize bằng cách sử dụng "Newtonsoft.Json.JsonConvert.SerializeObject" và De-Serialize bằng "System.Runtime.Serialization.Json.DataContractJsonSerializer".

  using System;
  using System.Collections.Generic;
  using Newtonsoft.Json;
  using System.Runtime.Serialization;
  using System.IO;
  using System.Runtime.Serialization.Json;
  using System.Text;
  
  namespace LUM_Win.model
  {
      [DataContract]
      public class User
      {
          public User() { }
          public User(String JSONObject)
          {
              MemoryStream stream = new MemoryStream(Encoding.Unicode.GetBytes(JSONObject));
              DataContractJsonSerializer dataContractJsonSerializer = new DataContractJsonSerializer(typeof(User));
  
              User user = (User)dataContractJsonSerializer.ReadObject(stream);
              this.ID = user.ID;
              this.Country = user.Country;
              this.FirstName = user.FirstName;
              this.LastName = user.LastName;
              this.Nickname = user.Nickname;
              this.PhoneNumber = user.PhoneNumber;
              this.DisplayPicture = user.DisplayPicture;
              this.IsRegistred = user.IsRegistred;
              this.IsConfirmed = user.IsConfirmed;
              this.VerificationCode = user.VerificationCode;
              this.Meetings = user.Meetings;
          }
  
          [DataMember(Name = "_id")]
          [JsonProperty(PropertyName = "_id")]
          public String ID { get; set; }
  
          [DataMember(Name = "country")]
          [JsonProperty(PropertyName = "country")]
          public String Country { get; set; }
  
          [DataMember(Name = "firstname")]
          [JsonProperty(PropertyName = "firstname")]
          public String FirstName { get; set; }
  
          [DataMember(Name = "lastname")]
          [JsonProperty(PropertyName = "lastname")]
          public String LastName { get; set; }
  
          [DataMember(Name = "nickname")]
          [JsonProperty(PropertyName = "nickname")]
          public String Nickname { get; set; }
  
          [DataMember(Name = "number")]
          [JsonProperty(PropertyName = "number")]
          public String PhoneNumber { get; set; }
  
          [DataMember(Name = "thumbnail")]
          [JsonProperty(PropertyName = "thumbnail")]
          public String DisplayPicture { get; set; }
  
          [DataMember(Name = "registered")]
          [JsonProperty(PropertyName = "registered")]
          public bool IsRegistred { get; set; }
  
          [DataMember(Name = "confirmed")]
          [JsonProperty(PropertyName = "confirmed")]
          public bool IsConfirmed { get; set; }
  
          [JsonIgnore]
          [DataMember(Name = "verification_code")]
          public String VerificationCode { get; set; }
  
          [JsonIgnore]
          [DataMember(Name = "meeting_ids")]
          public List<Meeting> Meetings { get; set; }
  
          public String toJSONString()
          {
              return JsonConvert.SerializeObject(this, new JsonSerializerSettings() { NullValueHandling = NullValueHandling.Ignore });
          }
      }
  }

Hy vọng rằng sẽ giúp ...

có tham chiếu đến giải pháp của @ ThoHo, sử dụng setter thực sự là tất cả những gì cần thiết, không có thẻ bổ sung.

Đối với tôi, trước đây tôi có một Id tham chiếu duy nhất, tôi muốn tải và thêm vào bộ sưu tập Id tham chiếu mới. Bằng cách thay đổi định nghĩa của Id tham chiếu để chỉ chứa một phương thức setter, phương thức này đã thêm giá trị vào bộ sưu tập mới. Json không thể ghi lại giá trị nếu Thuộc tính không có giá trị nhận; phương pháp.

// Old property that I want to read from Json, but never write again. No getter.
public Guid RefId { set { RefIds.Add(value); } }

// New property that will be in use from now on. Both setter and getter.
public ICollection<Guid> RefIds { get; set; }

Lớp này hiện tương thích ngược với phiên bản trước và chỉ lưu các RefIds cho các phiên bản mới.

Để xây dựng dựa trên câu trả lời của Tho Ho, điều này cũng có thể được sử dụng cho các lĩnh vực.

[JsonProperty(nameof(IgnoreOnSerializing))]
public string IgnoreOnSerializingSetter { set { IgnoreOnSerializing = value; } }

[JsonIgnore]
public string IgnoreOnSerializing;

Tùy thuộc vào nơi trong ứng dụng này diễn ra và nếu nó chỉ là một thuộc tính, một tay cách bạn có thể làm điều này là bằng cách thiết lập giá trị tài sản để null và sau đó trên mô hình, bạn có thể xác định rằng tài sản được bỏ qua nếu giá trị là null:

[JsonProperty(NullValueHandling = NullValue.Ignore)]
public string MyProperty { get; set; }

Nếu bạn đang làm việc trên một ứng dụng web ASP.NET Core, bạn có thể đặt điều này trên toàn cầu cho tất cả các thuộc tính trong tất cả các mô hình bằng cách đặt điều này trong tệp Startup.cs của bạn:

public void ConfigureServices(IServiceCollection services) {
    // other configuration here
    services.AddMvc()
        .AddJsonOptions(options => options.SerializerSettings.NullValueHandling = NullValueHandling.Ignore);
}

Nếu bạn sử dụng JsonConvert, thì lờ đi là ok. Thư viện tiêu chuẩn của tôi không phải là refrence Newton.Json, và tôi sử dụng [ignoreDataMember] để kiểm soát tuần tự hóa đối tượng.

Từ tài liệu trợ giúp Newton.net .

Có cách nào đơn giản để đánh dấu (ví dụ: với các thuộc tính) thuộc tính của một đối tượng C #, để Json.net CHỈ bỏ qua nó khi tuần tự hóa, nhưng chú ý đến nó khi giải mã không?

Cách dễ nhất mà tôi tìm thấy khi viết bài này là đưa logic này vào IContractResolver của bạn .

Mã mẫu từ liên kết trên được sao chép vào đây cho hậu thế:

public class Employee
{
    public string Name { get; set; }
    public Employee Manager { get; set; }

    public bool ShouldSerializeManager()
    {
        // don't serialize the Manager property if an employee is their own manager
        return (Manager != this);
    }
}

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 =>
                {
                    Employee e = (Employee)instance;
                    return e.Manager != e;
                };
        }

        return property;
    }
}

Tất cả các câu trả lời đều tốt nhưng cách tiếp cận này có vẻ là cách sạch sẽ nhất. Tôi thực sự đã triển khai điều này bằng cách tìm kiếm một thuộc tính trên thuộc tính cho SkipSerialize và SkipDeserialize để bạn có thể đánh dấu bất kỳ lớp nào bạn kiểm soát. Câu hỏi tuyệt vời!