Cómo excluir propiedades de la serialización Json

Tengo una clase DTO que serializo

Json.Serialize(MyClass)

¿Cómo puedo excluir una propiedad pública de la misma?

(Tiene que ser público, ya que lo uso en mi código en otro lugar)

Si está utilizando System.Web.Script.Serializationen .NET Framework , puede poner un ScriptIgnoreatributo en los miembros que no se debe serializar. Vea el ejemplo tomado de aquí :

Considere el siguiente caso (simplificado):

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

En este caso, solo se serializarán las propiedades Id y Nombre, por lo que el objeto JSON resultante se vería así:

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

PD. No olvide agregar una referencia a " System.Web.Extensions" para que esto funcione

Si está utilizando el atributo Json.Net[JsonIgnore] , simplemente ignorará el campo / propiedad mientras se serializa o deserializa.

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

O puede usar el atributo DataContract y DataMember para serializar / deserializar selectivamente propiedades / campos.

[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; }
}

Consulte http://james.newtonking.com/archive/2009/10/23/efficient-json-with-json-net-reducing-serialized-json-size para obtener más detalles

Puedes usar [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); }
    }
}

Referencia aquí

En este caso, el Id y el nombre solo se serializarán

Lo siento, decidí escribir otra respuesta ya que ninguna de las otras respuestas es lo suficientemente pegable.

Si no desea decorar propiedades con algunos atributos, o si no tiene acceso a la clase, o si desea decidir qué serializar durante el tiempo de ejecución, etc., etc., así es como lo hace en 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;
    }
}

Uso

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

He publicado el código aquí en caso de que alguien quiera agregar algo

https://github.com/jitbit/JsonIgnoreProps

ACTUALIZACIÓN IMPORTANTE: asegúrese de guardar en caché el ContractResolverobjeto si decide usar esta respuesta, de lo contrario, el rendimiento puede verse afectado.

Si no está tan interesado en tener que decorar el código con Atributos como yo, especialmente cuando no puede decir en tiempo de compilación lo que sucederá aquí es mi solución.

Usando el serializador Javascript

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

Si está usando, System.Text.Jsonentonces puede usar [JsonIgnore].
FQ:System.Text.Json.Serialization.JsonIgnoreAttribute

Documentos oficiales de Microsoft: JsonIgnoreAttribute

Como se indica aquí :

La biblioteca está integrada como parte del marco compartido .NET Core 3.0.
Para otros marcos de destino, instale el paquete System.Text.Json NuGet. El paquete admite:

• .NET Standard 2.0 y versiones posteriores
• .NET Framework 4.6.1 y versiones posteriores
• .NET Core 2.0, 2.1 y 2.2

También puedes usar el [NonSerialized]atributo

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

De los documentos de MS :

Indica que un campo de una clase serializable no debe serializarse. Esta clase no puede heredarse.

Si está utilizando Unity, por ejemplo ( esto no es solo para Unity ), entonces esto funciona conUnityEngine.JsonUtility

using UnityEngine;

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