Json Serialization에서 속성을 제외하는 방법

직렬화하는 DTO 클래스가 있습니다.

Json.Serialize(MyClass)

공공 재산을 어떻게 제외시킬 수 있습니까?

(어딘가에서 내 코드에서 사용하기 때문에 공개되어야합니다)

System.Web.Script.Serialization.NET 프레임 워크에서 사용 하는 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 및 Name 속성 만 직렬화되므로 결과 JSON 객체는 다음과 같습니다.

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

추신. 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); }
    }
}

여기 참조

이 경우 ID와 이름은 일련 화됩니다.

죄송합니다. 다른 답변을 충분히 복사하여 붙여 넣을 수 없으므로 다른 답변을 작성하기로 결정했습니다.

일부 속성으로 속성을 장식하고 싶지 않거나 클래스에 액세스 할 수 없거나 런타임 중 직렬화 할 항목 등을 결정하려는 경우 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 이 답변을 사용하기로 결정한 경우 객체 를 캐시해야합니다 . 그렇지 않으면 성능이 저하 될 수 있습니다.

내가 속성을 사용하여 코드를 장식 해야하는 것에 관심이 없다면 컴파일 타임에 여기서 일어날 수있는 일을 할 때 esp가 내 솔루션입니다.

자바 스크립트 시리얼 라이저 사용

    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경우을 사용할 수 있습니다 [JsonIgnore].
FQ :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 문서에서 :

직렬화 가능 클래스의 필드를 직렬화하지 않아야 함을 나타냅니다. 이 클래스는 상속 될 수 없습니다.

예를 들어 Unity를 사용하는 경우 ( 이것은 Unity에만 해당되는 것이 아닙니다 )UnityEngine.JsonUtility

using UnityEngine;

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