C#中如何根据外部条件控制REST响应字段序列化？

针对你这个在WCF REST服务里根据flag或者fields请求参数动态返回Response类字段子集的需求，我整理了几个实用的方案，结合你的场景给你详细说说：

方案一：利用DataContractSerializer的条件序列化（推荐） #

你提到的EmitDefaultValue确实只能基于默认值控制序列化，但WCF的DataContractSerializer支持一种更灵活的方式——ShouldSerialize{PropertyName}命名约定方法，它可以让你自定义属性是否被序列化的逻辑。

步骤1：在Response类中添加条件判断方法 #

修改你的Response类，为需要控制的属性添加对应的ShouldSerialize方法，比如针对name字段：

[DataContract]
public class Response 
{
    [DataMember] 
    public string id { get; set; } 

    [DataMember] 
    public string href { get; set; } 

    [DataMember] 
    public string name { get; set; }

    // 用于控制name字段是否序列化
    public bool ShouldSerializename()
    {
        // 这里可以根据flag或者解析后的fields参数来判断
        // 假设flag是类的一个属性，或者你从上下文获取到了fields参数的结果
        return !flag; // flag为true时返回false，不序列化name；flag为false时返回true，序列化name
    }
}

原理很简单：DataContractSerializer会自动查找符合ShouldSerialize{PropertyName}格式的方法，根据方法返回的bool值决定是否序列化对应属性，完全不受默认值限制。

结合fields请求参数的扩展 #

你的接口已经定义了fieldsParam，可以在服务方法里解析这个参数，把需要保留的字段列表传给Response实例，再在ShouldSerialize方法里判断：

// 先给Response类加一个内部属性用来传递需要包含的字段
[DataContract]
public class Response 
{
    // 内部属性，不参与序列化，仅用于传递字段列表
    internal List<string> IncludedFields { get; set; }

    [DataMember] 
    public string id { get; set; } 

    [DataMember] 
    public string href { get; set; } 

    [DataMember] 
    public string name { get; set; }

    public bool ShouldSerializename()
    {
        // 如果没有指定fields，或者name在包含列表里，就序列化
        return IncludedFields == null || IncludedFields.Contains("name", StringComparer.OrdinalIgnoreCase);
    }

    // 如果你需要控制id和href，也可以添加对应的ShouldSerialize方法
    public bool ShouldSerializeid()
    {
        return IncludedFields == null || IncludedFields.Contains("id", StringComparer.OrdinalIgnoreCase);
    }
}

// 服务实现方法
public Response GetResponse(string id, string fieldsParam)
{
    var response = new Response 
    { 
        id = id, 
        href = $"http://your-domain.com/{id}", 
        name = "Sample Name" 
    };

    // 解析fields参数，比如fields=id,href
    var includedFields = string.IsNullOrEmpty(fieldsParam) 
        ? null 
        : fieldsParam.Split(',', StringSplitOptions.RemoveEmptyEntries)
                     .Select(f => f.Trim())
                     .ToList();

    response.IncludedFields = includedFields;
    return response;
}

这种方式既支持flag的二元判断，也支持任意字段组合的fields参数，非常灵活。

方案二：自定义序列化器（复杂场景适用） #

如果你的需求更复杂（比如需要动态修改字段名、处理嵌套对象等），可以自定义IDataContractSurrogate或者继承DataContractSerializer来实现完全自定义的序列化逻辑。

示例：自定义IDataContractSurrogate #

public class DynamicResponseSurrogate : IDataContractSurrogate
{
    private readonly List<string> _includedFields;

    public DynamicResponseSurrogate(List<string> includedFields)
    {
        _includedFields = includedFields ?? new List<string>();
    }

    public Type GetDataContractType(Type type) => type;

    public object GetObjectToSerialize(object obj, Type targetType)
    {
        if (obj is Response response)
        {
            // 动态构建只包含需要字段的对象
            var dynamicObj = new ExpandoObject() as IDictionary<string, object>;
            
            // 判断每个字段是否需要包含
            if (_includedFields.Count == 0 || _includedFields.Contains("id", StringComparer.OrdinalIgnoreCase))
                dynamicObj["id"] = response.id;
            
            if (_includedFields.Count == 0 || _includedFields.Contains("href", StringComparer.OrdinalIgnoreCase))
                dynamicObj["href"] = response.href;
            
            if (_includedFields.Count == 0 || _includedFields.Contains("name", StringComparer.OrdinalIgnoreCase))
                dynamicObj["name"] = response.name;

            return dynamicObj;
        }
        return obj;
    }

    // 其他接口方法返回默认实现即可
    public object GetDeserializedObject(object obj, Type targetType) => obj;
    public object GetCustomDataToExport(Type clrType, Type dataContractType) => null;
    public object GetCustomDataToExport(MemberInfo memberInfo, Type dataContractType) => null;
    public void GetKnownCustomDataTypes(System.Collections.ObjectModel.Collection<Type> customDataTypes) {}
    public Type GetReferencedTypeOnImport(string typeName, string typeNamespace, object customData) => null;
    public System.CodeDom.CodeTypeDeclaration ProcessImportedType(System.CodeDom.CodeTypeDeclaration typeDeclaration, System.CodeDom.CodeCompileUnit compileUnit) => typeDeclaration;
}

在服务方法中使用自定义序列化器 #

因为WCF默认会自动序列化返回值，所以需要手动序列化并返回Stream：

public Stream GetResponse(string id, string fieldsParam)
{
    var response = new Response 
    { 
        id = id, 
        href = $"http://your-domain.com/{id}", 
        name = "Sample Name" 
    };

    var includedFields = string.IsNullOrEmpty(fieldsParam) 
        ? null 
        : fieldsParam.Split(',', StringSplitOptions.RemoveEmptyEntries)
                     .Select(f => f.Trim())
                     .ToList();

    // 使用自定义Surrogate创建序列化器
    var serializer = new DataContractSerializer(
        typeof(Response), 
        null, 
        int.MaxValue, 
        false, 
        false, 
        new DynamicResponseSurrogate(includedFields)
    );

    var stream = new MemoryStream();
    serializer.WriteObject(stream, response);
    stream.Position = 0;

    // 设置响应类型
    WebOperationContext.Current.OutgoingResponse.ContentType = "application/json";
    return stream;
}

这种方式自由度极高，但实现起来相对复杂，适合有特殊序列化需求的场景。

方案三：使用DTO类（直观简单） #

如果你的字段组合比较固定（比如只有两种情况：返回基础字段/返回全部字段），可以直接创建不同的DTO类，根据条件返回对应的实例：

// 基础字段DTO
[DataContract]
public class ResponseBasic
{
    [DataMember] public string id { get; set; }
    [DataMember] public string href { get; set; }
}

// 包含全部字段的DTO，继承基础DTO
[DataContract]
public class ResponseFull : ResponseBasic
{
    [DataMember] public string name { get; set; }
}

// 服务实现方法
public object GetResponse(string id, string fieldsParam)
{
    var fullResponse = new ResponseFull 
    { 
        id = id, 
        href = $"http://your-domain.com/{id}", 
        name = "Sample Name" 
    };

    // 根据fieldsParam判断flag：比如如果fields不包含name，就返回基础DTO
    bool flag = !string.IsNullOrEmpty(fieldsParam) && !fieldsParam.Contains("name", StringComparer.OrdinalIgnoreCase);

    if (flag)
    {
        // 转换为基础DTO
        return new ResponseBasic { id = fullResponse.id, href = fullResponse.href };
    }
    else
    {
        return fullResponse;
    }
}

这种方式最直观，代码可读性高，适合字段组合固定的场景，但如果需要支持任意字段组合，就会产生大量DTO类，不够灵活。

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