如果你不像我一样热衷于用属性装饰代码，尤其是当你不能在编译时告诉你会发生什么，这是我的解决方案。

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

为dotnet核心添加System.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);

如果你不像我一样热衷于用属性装饰代码，尤其是当你不能在编译时告诉你会发生什么，这是我的解决方案。

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

你可以使用[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和名称只会被序列化

如果你在。net框架中使用System.Web.Script.Serialization，你可以把ScriptIgnore属性放在不应该被序列化的成员上。请看下面的例子:

考虑以下(简化)情况: 公共类用户{ 公共int Id{获取;设置;} 公共字符串名称{获取;设置;} (ScriptIgnore) public bool IsComplete ｛ string.IsNullOrEmpty(Name);} } } 在这种情况下，只有Id和Name属性会被序列化，因此生成的JSON对象看起来像这样: {Id: 3，名称:'测试用户'}

另外，不要忘记添加对“System.Web”的引用。扩展”

对于c# 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; }
}