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

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

시리얼화한 DTO 클래스가 있다.

Json.Serialize(MyClass)

어떻게 하면 공공재산을 배제할 수 있을까요?

(다른 곳에서 코드로 사용하기 때문에 공개해야 합니다.)

Json을 사용하는 경우.넷 속성[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 를 참조해 주세요.

에서 를 사용하고 있는 경우.NET 프레임워크는 직렬화해서는 안 되는 멤버에 속성을 부여할 수 있습니다.여기서의 예를 참조해 주세요.

다음의 (간단한) 경우를 생각해 봅시다.

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' }

PS. "에 대한 참조를 추가하는 것을 잊지 마십시오.System.Web.Extensions「이것이 기능하기 위해서

죄송합니다. 다른 답변은 복사 붙여넣기가 충분히 되지 않아 다른 답변을 쓰기로 했습니다.

속성을 몇 가지 속성으로 꾸미지 않거나 클래스에 액세스할 수 없는 경우 또는 런타임 중에 직렬화할 항목을 결정하는 경우 등은 다음과 같습니다.제이슨

//short helper class to ignore some properties from serialization
public class IgnorePropertiesResolver : DefaultContractResolver
{
    private readonly HashSet<string> ignoreProps;
    public IgnorePropertiesResolver(IEnumerable<string> propNamesToIgnore)
    {
        this.ignoreProps = new HashSet<string>(propNamesToIgnore);
    }

    protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
    {
        JsonProperty property = base.CreateProperty(member, memberSerialization);
        if (this.ignoreProps.Contains(property.PropertyName))
        {
            property.ShouldSerialize = _ => false;
        }
        return property;
    }
}

사용.

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

주의: 반드시 캐시해 주세요.ContractResolver오브젝트: 이 답변을 사용할 경우 퍼포먼스가 저하될 수 있습니다.

여기에 코드를 공개해 놨어요 혹시라도 더하고 싶은 사람이 있을 때를 대비해서요

https://github.com/jitbit/JsonIgnoreProps

사용할 수 있습니다.[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와 그 다음 이름만 일련화됩니다.

저처럼 Attributes로 코드를 꾸미고 싶지 않다면, 특히 컴파일 시 어떤 일이 일어날지 알 수 없을 때 이것이 저의 해결책입니다.

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그 후 를 사용할 수 있습니다.[JsonIgnore].
FQ:System.Text.Json.Serialization.JsonIgnoreAttribute

공식 Microsoft 문서: Json Ignore Attribute

아래에 기재된 바와 같이:

라이브러리는 의 일부로 내장되어 있습니다.NET Core 3.0 공유 프레임워크
다른 대상 프레임워크의 경우 시스템을 설치합니다.Text.Json NuGet 패키지패키지는 다음을 지원합니다.

• .NET Standard 2.0 이후 버전
• .NET Framework 4.6.1 이후 버전
• .NET Core 2.0, 2.1 및 2.2

#9입니다.[property: JsonIgnore]

using System.Text.Json.Serialization;

public record R(
   string Text2
   [property: JsonIgnore] string Text2)

[JsonIgnore].

using System.Text.Json.Serialization;

public record R
{
   public string Text {get; init; }

   [JsonIgnore] 
   public string Text2 { get; init; }
}

이 경우에도 하실 수 있습니다.[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"}

시스템 추가.닷넷 코어용 Text.Json 버전

컴파일 시간은 위의 답변과 같이 [JsonIgnore]를 추가합니다.

런타임의 경우 옵션에 JsonConverter를 추가해야 합니다.

제외할예: JsonConverter)를 만듭니다.예를 들어 다음과 같습니다.ICollection<LabMethod>

public class LabMethodConverter : JsonConverter<ICollection<LabMethod>>
{
    public override ICollection<LabMethod> Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        //deserialize JSON into a ICollection<LabMethod>
        return null;
    }

    public override void Write(Utf8JsonWriter writer, ICollection<LabMethod> value, JsonSerializerOptions options)
    {
        //serialize a ICollection<LabMethod> object
        writer.WriteNullValue();
    }
}

그런 다음 Json을 직렬화할 때 옵션에 추가

var options = new JsonSerializerOptions();
options.Converters.Add(new LabMethodConverter());
var new_obj = Json(new { rows = slice, total = count }, options);

언급URL : https://stackoverflow.com/questions/10169648/how-to-exclude-property-from-json-serialization