如何在ASP.NET Web API中通过verbose参数控制JSON字段显隐？

嘿，这个需求在ASP.NET Web API里有几种实用的实现方式，我给你拆解几个靠谱的方案，你可以根据自己的场景选择：

ASP.NET Web API默认使用Json.NET（Newtonsoft.Json），我们可以通过自定义ContractResolver来动态控制字段是否被序列化，完美匹配你的参数需求。

步骤1：创建自定义ContractResolver #

public class DynamicUserContractResolver : DefaultContractResolver
{
    private readonly bool _isVerboseMode;

    public DynamicUserContractResolver(bool isVerboseMode)
    {
        _isVerboseMode = isVerboseMode;
    }

    protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
    {
        var properties = base.CreateProperties(type, memberSerialization);

        // 按照需求过滤字段：verbose=true时移除Suffix和Address
        if (_isVerboseMode)
        {
            properties = properties.Where(p => 
                !(type == typeof(UserDTO) && 
                  (p.PropertyName.Equals("Suffix", StringComparison.OrdinalIgnoreCase) || 
                   p.PropertyName.Equals("Address", StringComparison.OrdinalIgnoreCase)))
            ).ToList();
        }

        return properties;
    }
}

步骤2：在API Action中应用逻辑 #

public IHttpActionResult GetPatient(int Key, bool? verbose = null)
{
    // 模拟从数据源获取用户数据
    var user = new UserDTO
    {
        Key = Key,
        Suffix = "1",
        FirstName = "Dhanu",
        LastName = "Kumar",
        MiddleName = "",
        Address = new Address
        {
            Address1 = "uuu",
            Address2 = "TTT",
            Address3 = "xx",
            City = "yy"
        }
    };

    var serializerSettings = new JsonSerializerSettings();
    // 仅当verbose=true时启用自定义序列化规则
    if (verbose.HasValue && verbose.Value)
    {
        serializerSettings.ContractResolver = new DynamicUserContractResolver(true);
    }

    return Json(user, serializerSettings);
}

如果不想搞复杂的序列化逻辑，直接创建两个DTO类分别对应完整和精简结果，代码可读性更高。

步骤1：定义两个DTO #

// 精简版：verbose=true时返回
public class SimpleUserDTO
{
    public int Key { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string MiddleName { get; set; }
}

// 完整版：无verbose参数时返回
public class FullUserDTO : SimpleUserDTO
{
    public string Suffix { get; set; }
    public Address Address { get; set; }
}

步骤2：在Action中根据参数返回对应DTO #

public IHttpActionResult GetPatient(int Key, bool? verbose = null)
{
    var fullUser = new FullUserDTO
    {
        Key = Key,
        Suffix = "1",
        FirstName = "Dhanu",
        LastName = "Kumar",
        MiddleName = "",
        Address = new Address
        {
            Address1 = "uuu",
            Address2 = "TTT",
            Address3 = "xx",
            City = "yy"
        }
    };

    if (verbose.HasValue && verbose.Value)
    {
        // 转换为精简版DTO返回
        return Ok(fullUser as SimpleUserDTO);
    }

    return Ok(fullUser);
}

如果只是单个Action需要这个逻辑，用匿名类型直接构造返回结果是最快捷的方式：

public IHttpActionResult GetPatient(int Key, bool? verbose = null)
{
    var user = new UserDTO
    {
        Key = Key,
        Suffix = "1",
        FirstName = "Dhanu",
        LastName = "Kumar",
        MiddleName = "",
        Address = new Address
        {
            Address1 = "uuu",
            Address2 = "TTT",
            Address3 = "xx",
            City = "yy"
        }
    };

    if (verbose.HasValue && verbose.Value)
    {
        return Ok(new 
        {
            user = new 
            {
                user.Key,
                user.FirstName,
                user.LastName,
                user.MiddleName
            }
        });
    }

    return Ok(new { user = user });
}

内容的提问来源于stack exchange，提问作者Jayendran