WCF服务代码优化：仅返回基类类型的实现难题

嘿，这个问题我之前在做WCF服务重构的时候也碰到过，刚好有几个实用的方案能帮你绕开把派生类放进共享库的困扰：

WCF的KnownType特性不仅能直接写死类型，还支持通过静态方法动态获取派生类。这样你完全不用把派生类放到共享库，只需要在基类上配置一下，让WCF序列化时能识别服务端的派生类，但客户端只会拿到基类的契约。

示例代码：

[DataContract]
// 用静态方法动态获取当前服务程序集中的所有BaseClass派生类
[KnownType("GetDerivedTypes")]
public class BaseClass
{
    [DataMember]
    public int Id { get; set; }

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

    // 私有静态方法，返回所有需要被识别的派生类型
    private static IEnumerable<Type> GetDerivedTypes()
    {
        // 从当前服务程序集中筛选出BaseClass的非抽象派生类
        return typeof(BaseClass).Assembly.GetTypes()
            .Where(t => t.IsSubclassOf(typeof(BaseClass)) && !t.IsAbstract);
    }
}

// 服务端专属的派生类，完全不用放共享库
internal class DerivedClass : BaseClass
{
    // 这些内部属性不会被序列化，客户端完全看不到
    internal string ServiceInternalProperty { get; set; }
    internal void ServiceOnlyLogic() {}
}

为什么管用？：WCF序列化时会调用GetDerivedTypes获取所有需要处理的派生类，但客户端生成的代理类只会包含基类中标记了[DataMember]的属性，派生类的内部内容对客户端完全透明。

如果需要更精细的序列化控制，可以实现IDataContractSurrogate接口，强制WCF用基类的契约来序列化派生类实例。这个方案适合派生类结构复杂，或者需要自定义序列化逻辑的场景。

示例代码：

// 自定义数据契约代理
public class BaseClassSurrogate : IDataContractSurrogate
{
    // 告诉WCF：如果是BaseClass的派生类，就用BaseClass作为序列化类型
    public Type GetDataContractType(Type type)
    {
        return type.IsSubclassOf(typeof(BaseClass)) ? typeof(BaseClass) : type;
    }

    // 其他接口方法可以用默认实现
    public object GetObjectToSerialize(object obj, Type targetType) => 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(Collection<Type> customDataTypes) { }
    public Type GetReferencedTypeOnImport(string typeName, string typeNamespace, object customData) => null;
    public CodeTypeDeclaration ProcessImportedType(CodeTypeDeclaration typeDeclaration, CodeCompileUnit compileUnit) => typeDeclaration;
}

然后在服务配置中注册这个代理：

// 假设你是代码配置服务端
var serviceHost = new ServiceHost(typeof(MyService));
foreach (var endpoint in serviceHost.Description.Endpoints)
{
    foreach (var operation in endpoint.Contract.Operations)
    {
        var behavior = operation.Behaviors.Find<DataContractSerializerOperationBehavior>();
        if (behavior != null)
        {
            behavior.DataContractSurrogate = new BaseClassSurrogate();
        }
        else
        {
            behavior = new DataContractSerializerOperationBehavior(operation);
            behavior.DataContractSurrogate = new BaseClassSurrogate();
            operation.Behaviors.Add(behavior);
        }
    }
}

优势：完全隔离了服务端的派生类和客户端，甚至可以在序列化时修改数据结构，灵活性拉满。

如果你的派生类和基类结构比较简单，最省事的方法就是在服务返回前，把派生类实例显式转换成基类，或者创建一个新的基类实例复制属性。

示例代码：

public class MyService : IMyService
{
    public BaseClass GetData()
    {
        // 服务内部使用派生类处理逻辑
        var derivedInstance = new DerivedClass
        {
            Id = 1,
            PublicName = "Test",
            ServiceInternalProperty = "Only for server"
        };

        // 直接返回基类类型，WCF只会序列化基类的DataMember属性
        return derivedInstance as BaseClass;

        // 如果需要更严格的隔离，可以新建基类实例复制属性
        // return new BaseClass { Id = derivedInstance.Id, PublicName = derivedInstance.PublicName };
    }
}

注意：这个方法适合属性较少的场景，如果基类属性很多，手动复制会比较繁琐，不如前两个方案高效。

内容的提问来源于stack exchange，提问作者Will E.