วิธีการแยกคุณสมบัติออกจาก Json Serialization

ฉันมีคลาส DTO ที่ฉันเป็นอันดับ

Json.Serialize(MyClass)

ฉันจะยกเว้นทรัพย์สินสาธารณะของมันได้อย่างไร

(มันจะต้องเป็นสาธารณะในขณะที่ฉันใช้มันในรหัสของฉันที่อื่น)

หากคุณกำลังใช้งานSystem.Web.Script.Serializationใน. NET Frameworkคุณสามารถใส่แอScriptIgnoreททริบิวในสมาชิกที่ไม่ควรทำเป็นอันดับ ดูตัวอย่างที่นำมาจากที่นี่ :

พิจารณากรณี (แบบง่าย ๆ ) ต่อไปนี้:

public class User {
    public int Id { get; set; }
    public string Name { get; set; }
    [ScriptIgnore]
    public bool IsComplete
    {
        get { return Id > 0 && !string.IsNullOrEmpty(Name); }
    } 
} 

ในกรณีนี้เฉพาะคุณสมบัติ Id และชื่อเท่านั้นที่จะถูกทำให้เป็นอนุกรมดังนั้นวัตถุ JSON ที่ได้จะเป็นดังนี้:

{ Id: 3, Name: 'Test User' }

PS อย่าลืมเพิ่มการอ้างอิงถึง " System.Web.Extensions" เพื่อให้สิ่งนี้ใช้งานได้

หากคุณกำลังใช้แอททริบิวต์Json.Net[JsonIgnore]จะไม่สนใจฟิลด์ / คุณสมบัติในขณะที่ซีเรียลไลซ์หรือดีซีเรียลไลซ์

public class Car
{
  // included in JSON
  public string Model { get; set; }
  public DateTime Year { get; set; }
  public List<string> Features { get; set; }

  // ignored
  [JsonIgnore]
  public DateTime LastModified { get; set; }
}

หรือคุณสามารถใช้แอตทริบิวต์ DataContract และ DataMember เพื่อเลือกคุณสมบัติ / เขตข้อมูลซีเรียลไลซ์ / เขตข้อมูล

[DataContract]
public class Computer
{
  // included in JSON
  [DataMember]
  public string Name { get; set; }
  [DataMember]
  public decimal SalePrice { get; set; }

  // ignored
  public string Manufacture { get; set; }
  public int StockCount { get; set; }
  public decimal WholeSalePrice { get; set; }
  public DateTime NextShipmentDate { get; set; }
}

ดูhttp://james.newtonking.com/archive/2009/10/23/efficient-json-with-json-net-reducing-serialized-json-sizeสำหรับรายละเอียดเพิ่มเติม

คุณสามารถใช้[ScriptIgnore]:

public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    [ScriptIgnore]
    public bool IsComplete
    {
        get { return Id > 0 && !string.IsNullOrEmpty(Name); }
    }
}

อ้างอิงที่นี่

ในกรณีนี้รหัสและชื่อจะถูกทำให้เป็นอนุกรมเท่านั้น

ขออภัยฉันตัดสินใจที่จะเขียนคำตอบอื่นเนื่องจากไม่มีคำตอบอื่นใดที่สามารถคัดลอกได้อย่างเพียงพอ

หากคุณไม่ต้องการตกแต่งคุณสมบัติที่มีคุณสมบัติบางอย่างหรือถ้าคุณไม่สามารถเข้าถึงชั้นเรียนหรือถ้าคุณต้องการตัดสินใจว่าจะทำให้เป็นอันดับระหว่างรันไทม์ ฯลฯ ฯลฯ นี่คือวิธีที่คุณทำใน Newtonsoft.Json

//short helper class to ignore some properties from serialization
public class IgnorePropertiesResolver : DefaultContractResolver
{
    private IEnumerable<string> _propsToIgnore;
    public IgnorePropertiesResolver(IEnumerable<string> propNamesToIgnore)
    {
        _propsToIgnore = propNamesToIgnore;
    }
    protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
    {
        JsonProperty property = base.CreateProperty(member, memberSerialization);
        property.ShouldSerialize = (x) => { return !_propsToIgnore.Contains(property.PropertyName); };
        return property;
    }
}

การใช้

JsonConvert.SerializeObject(YourObject, new JsonSerializerSettings()
    { ContractResolver = new IgnorePropertiesResolver(new[] { "Prop1", "Prop2" }) };);

ฉันได้เผยแพร่โค้ดที่นี่ในกรณีที่ทุกคนต้องการเพิ่มอะไร

https://github.com/jitbit/JsonIgnoreProps

การปรับปรุงที่สำคัญ:ให้แน่ใจว่าคุณแคชContractResolverวัตถุถ้าคุณตัดสินใจที่จะใช้คำตอบนี้มิฉะนั้นประสิทธิภาพอาจประสบ

หากคุณไม่กระตือรือร้นที่จะต้องตกแต่งโค้ดด้วยแอททริบิวต์อย่างที่ฉันเป็นโดยเฉพาะเมื่อคุณไม่สามารถบอกได้ในเวลาคอมไพล์สิ่งที่จะเกิดขึ้นที่นี่คือทางออกของฉัน

การใช้ Javascript Serializer

    public static class JsonSerializerExtensions
    {
        public static string ToJsonString(this object target,bool ignoreNulls = true)
        {
            var javaScriptSerializer = new JavaScriptSerializer();
            if(ignoreNulls)
            {
                javaScriptSerializer.RegisterConverters(new[] { new PropertyExclusionConverter(target.GetType(), true) });
            }
            return javaScriptSerializer.Serialize(target);
        }

        public static string ToJsonString(this object target, Dictionary<Type, List<string>> ignore, bool ignoreNulls = true)
        {
            var javaScriptSerializer = new JavaScriptSerializer();
            foreach (var key in ignore.Keys)
            {
                javaScriptSerializer.RegisterConverters(new[] { new PropertyExclusionConverter(key, ignore[key], ignoreNulls) });
            }
            return javaScriptSerializer.Serialize(target);
        }
    }


public class PropertyExclusionConverter : JavaScriptConverter
    {
        private readonly List<string> propertiesToIgnore;
        private readonly Type type;
        private readonly bool ignoreNulls;

        public PropertyExclusionConverter(Type type, List<string> propertiesToIgnore, bool ignoreNulls)
        {
            this.ignoreNulls = ignoreNulls;
            this.type = type;
            this.propertiesToIgnore = propertiesToIgnore ?? new List<string>();
        }

        public PropertyExclusionConverter(Type type, bool ignoreNulls)
            : this(type, null, ignoreNulls){}

        public override IEnumerable<Type> SupportedTypes
        {
            get { return new ReadOnlyCollection<Type>(new List<Type>(new[] { this.type })); }
        }

        public override IDictionary<string, object> Serialize(object obj, JavaScriptSerializer serializer)
        {
            var result = new Dictionary<string, object>();
            if (obj == null)
            {
                return result;
            }
            var properties = obj.GetType().GetProperties();
            foreach (var propertyInfo in properties)
            {
                if (!this.propertiesToIgnore.Contains(propertyInfo.Name))
                {
                    if(this.ignoreNulls && propertyInfo.GetValue(obj, null) == null)
                    {
                         continue;
                    }
                    result.Add(propertyInfo.Name, propertyInfo.GetValue(obj, null));
                }
            }
            return result;
        }

        public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer)
        {
            throw new NotImplementedException(); //Converter is currently only used for ignoring properties on serialization
        }
    }

หากคุณกำลังใช้แล้วคุณสามารถใช้System.Text.Json FQ:[JsonIgnore]
System.Text.Json.Serialization.JsonIgnoreAttribute

เอกสารอย่างเป็นทางการของ Microsoft: JsonIgnoreAttribute

ตามที่ระบุไว้ที่นี่ :

ไลบรารีมีอยู่แล้วภายในเป็นส่วนหนึ่งของ. NET Core 3.0 ที่ใช้ร่วมกันกรอบ
สำหรับเฟรมเวิร์กเป้าหมายอื่น ๆ ให้ติดตั้งแพ็คเกจ System.Text.Json NuGet แพคเกจรองรับ:

• .NET Standard 2.0 และรุ่นที่ใหม่กว่า
• .NET Framework 4.6.1 และรุ่นที่ใหม่กว่า
• .NET Core 2.0, 2.1 และ 2.2

คุณยังสามารถใช้[NonSerialized]คุณสมบัติ

[Serializable]
public struct MySerializableStruct
{
    [NonSerialized]
    public string hiddenField;
    public string normalField;
}

จากเอกสาร MS :

บ่งชี้ว่าฟิลด์ของคลาสที่สามารถทำให้เป็นอนุกรมไม่ควรถูกทำให้เป็นอนุกรม คลาสนี้ไม่สามารถสืบทอดได้

หากคุณกำลังใช้ความสามัคคีเช่น ( นี้ไม่ได้เป็นเพียงเพื่อความสามัคคี ) แล้วงานนี้กับUnityEngine.JsonUtility

using UnityEngine;

MySerializableStruct mss = new MySerializableStruct 
{ 
    hiddenField = "foo", 
    normalField = "bar" 
};
Debug.Log(JsonUtility.ToJson(mss)); // result: {"normalField":"bar"}