如何在DataContract中排除lambda或委托？

1. 自定义递归克隆逻辑（推荐） #

不用依赖DataContractSerializer，自己写递归遍历字典的方法：遇到委托/lambda时先记录位置不克隆，等字典主体克隆完成后，再从原字典把委托复制到克隆后的字典里。这样既保留了原字典的委托，又完成了克隆。

public static Dictionary<string, object> CloneDictionary(Dictionary<string, object> source, out Dictionary<string, Delegate> preservedDelegates)
{
    var clonedDict = new Dictionary<string, object>();
    preservedDelegates = new Dictionary<string, Delegate>();

    foreach (var kvp in source)
    {
        // 遇到委托直接记录，跳过克隆
        if (kvp.Value is Delegate del)
        {
            preservedDelegates[kvp.Key] = del;
            continue;
        }

        // 处理嵌套的递归字典
        if (kvp.Value is Dictionary<string, object> nestedDict)
        {
            clonedDict[kvp.Key] = CloneDictionary(nestedDict, out var nestedDelegates);
            // 合并嵌套字典里的委托记录（按层级路径标记，避免键名冲突）
            foreach (var nestedKvp in nestedDelegates)
            {
                preservedDelegates[$"{kvp.Key}.{nestedKvp.Key}"] = nestedKvp.Value;
            }
        }
        // 处理其他可克隆类型（值类型、可序列化引用类型）
        else
        {
            clonedDict[kvp.Key] = CloneSingleValue(kvp.Value);
        }
    }

    return clonedDict;
}

// 辅助方法：克隆单个值
private static object CloneSingleValue(object value)
{
    if (value == null) return null;
    var type = value.GetType();

    // 值类型和字符串直接返回（本身就是值语义）
    if (type.IsValueType || type == typeof(string))
    {
        return value;
    }

    // 用DataContractSerializer处理其他可序列化引用类型
    using (var ms = new MemoryStream())
    {
        var serializer = new DataContractSerializer(type);
        serializer.WriteObject(ms, value);
        ms.Position = 0;
        return serializer.ReadObject(ms);
    }
}

使用示例 #

// 原字典示例
var originalDict = new Dictionary<string, object>
{
    ["Id"] = 1001,
    ["ExecAction"] = (Action)(() => Console.WriteLine("Run transaction")),
    ["NestedData"] = new Dictionary<string, object> { ["CalcFunc"] = (Func<int, int>)(x => x * 3) }
};

// 克隆字典，同时拿到所有委托的记录
var clonedDict = CloneDictionary(originalDict, out var delegates);

// 把委托注入到克隆后的字典对应位置
foreach (var kvp in delegates)
{
    var pathParts = kvp.Key.Split('.');
    var currentLayer = clonedDict;
    // 逐层找到嵌套字典的位置
    for (int i = 0; i < pathParts.Length - 1; i++)
    {
        currentLayer = currentLayer[pathParts[i]] as Dictionary<string, object>;
    }
    currentLayer[pathParts.Last()] = kvp.Value;
}

2. 用DataContractSerializer+代理类忽略委托 #

如果一定要用DataContractSerializer，可以通过IDataContractSurrogate代理类，在序列化时把委托替换为null（让序列化器忽略），同时记录委托的位置，反序列化后再注入回去。

public class DelegateSkipSurrogate : IDataContractSurrogate
{
    public Dictionary<string, Delegate> SavedDelegates { get; } = new Dictionary<string, Delegate>();
    private string _currentPath = "";

    // 把委托类型替换为object，让序列化器可以处理
    public Type GetDataContractType(Type type)
    {
        return typeof(Delegate).IsAssignableFrom(type) ? typeof(object) : type;
    }

    // 序列化时记录委托，返回null让序列化器忽略
    public object GetObjectToSerialize(object obj, Type targetType)
    {
        if (obj is Delegate del)
        {
            SavedDelegates[_currentPath] = del;
            return null;
        }

        // 处理递归字典，记录当前层级路径
        if (obj is Dictionary<string, object> dict)
        {
            var originalPath = _currentPath;
            foreach (var kvp in dict)
            {
                _currentPath = string.IsNullOrEmpty(originalPath) ? kvp.Key : $"{originalPath}.{kvp.Key}";
                GetObjectToSerialize(kvp.Value, kvp.Value.GetType());
            }
            _currentPath = originalPath;
        }

        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 CodeTypeDeclaration ProcessImportedType(CodeTypeDeclaration typeDeclaration, CodeCompileUnit compileUnit) => typeDeclaration;
}

使用示例 #

var surrogate = new DelegateSkipSurrogate();
var serializer = new DataContractSerializer(
    typeof(Dictionary<string, object>), 
    null, 
    int.MaxValue, 
    false, 
    true, 
    surrogate
);

// 序列化+反序列化得到不含委托的克隆字典
Dictionary<string, object> clonedDict;
using (var ms = new MemoryStream())
{
    serializer.WriteObject(ms, originalDict);
    ms.Position = 0;
    clonedDict = serializer.ReadObject(ms) as Dictionary<string, object>;
}

// 注入委托到克隆字典
foreach (var kvp in surrogate.SavedDelegates)
{
    var pathParts = kvp.Key.Split('.');
    var currentLayer = clonedDict;
    for (int i = 0; i < pathParts.Length - 1; i++)
    {
        currentLayer = currentLayer[pathParts[i]] as Dictionary<string, object>;
    }
    currentLayer[pathParts.Last()] = kvp.Value;
}

注意事项 #

• 委托本身是引用类型，克隆后注入的是原委托的引用。如果你的委托捕获了可变状态，需要额外处理隔离逻辑；事务场景下通常原对象和克隆对象共享委托没问题。
• 递归字典的路径标记可以根据实际结构调整，比如用GUID标识每个嵌套字典，避免不同层级键名重复导致的冲突。

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