如何将Entity Framework模型转换为SendGrid模板用的脱敏POCO

一、直接构建目标POCO的常用方法 #

1. 使用AutoMapper（推荐） #

AutoMapper能灵活配置映射规则，满足排除敏感属性、保留非空复杂属性的需求：

• 先定义与EF模型结构匹配但不含敏感属性的DTO类（若嫌手动麻烦，可借助T4模板或代码生成工具自动生成基础DTO，再手动移除敏感属性）
• 配置映射规则：

  var config = new MapperConfiguration(cfg =>
  {
      // 忽略指定敏感属性
      cfg.CreateMap<User, UserDto>()
          .ForMember(dest => dest.Password, opt => opt.Ignore());
      // 仅保留非空的复杂属性
      cfg.CreateMap<Order, OrderDto>()
          .ForMember(dest => dest.Customer, opt => opt.Condition(src => src.Customer != null));
      // 其他模型映射规则同理配置
  });
  
  IMapper mapper = config.CreateMapper();
  // 将EF模型转换为DTO
  var userDto = mapper.Map<UserDto>(dbUser);
  // 转为JSON传给SendGrid
  string json = JsonSerializer.Serialize(userDto);
  

• 优势：类型安全，配置一次可复用，能处理复杂嵌套结构，还可通过Condition过滤空值复杂属性。

2. 手动映射（适合简单模型） #

如果模型结构不复杂，直接手动创建匿名类型或DTO对象：

var safeUser = new
{
    Id = dbUser.Id,
    Name = dbUser.Name,
    Email = dbUser.Email,
    // 仅当Order非空时包含该嵌套对象
    Order = dbUser.Order != null ? new
    {
        OrderId = dbUser.Order.OrderId,
        Amount = dbUser.Order.Amount
    } : null
};
string json = JsonSerializer.Serialize(safeUser);

• 优势：无需额外依赖，代码直观；缺点：模型结构变化时需手动修改代码。

3. 反射动态生成对象 #

通过反射遍历EF模型的属性，动态构建仅包含允许属性的对象：

public static object CreateSafeObject(object source, IEnumerable<string> excludedProperties)
{
    var expando = new ExpandoObject() as IDictionary<string, object>;
    var properties = source.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance);
    
    foreach (var prop in properties)
    {
        if (excludedProperties.Contains(prop.Name))
            continue;
            
        var value = prop.GetValue(source);
        // 处理值类型、字符串等简单属性
        if (prop.PropertyType.IsValueType || prop.PropertyType == typeof(string))
        {
            expando[prop.Name] = value;
        }
        // 处理非空的复杂属性，递归生成安全对象
        else if (value != null)
        {
            expando[prop.Name] = CreateSafeObject(value, excludedProperties);
        }
    }
    
    return expando;
}

// 使用示例
var excludedProps = new List<string> { "Password", "CreditCardNumber" };
var safeObject = CreateSafeObject(dbUser, excludedProps);
string json = JsonSerializer.Serialize(safeObject);

• 优势：无需提前定义DTO，适合动态场景；缺点：性能略差，需处理反射细节（如集合类型、循环引用等）。

二、「模型→JSON→POCO」路径的实现方法 #

这个路径完全可行，核心思路是先将EF模型序列化为过滤后的JSON，再反序列化为动态对象，步骤如下：

1. 序列化时过滤敏感属性和空值 #

使用System.Text.Json或Newtonsoft.Json的配置，排除敏感属性并忽略空的复杂属性：

// System.Text.Json示例
var options = new JsonSerializerOptions
{
    // 忽略所有空值属性（含复杂对象）
    IgnoreNullValues = true,
    // 添加自定义转换器过滤敏感属性
    Converters = { new SensitivePropertyConverter() }
};

// 自定义转换器实现属性过滤
public class SensitivePropertyConverter : JsonConverter<object>
{
    private readonly HashSet<string> _excludedProps = new HashSet<string> { "Password", "CreditCardNumber" };
    
    public override object Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        throw new NotImplementedException();
    }
    
    public override void Write(Utf8JsonWriter writer, object value, JsonSerializerOptions options)
    {
        writer.WriteStartObject();
        var properties = value.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance);
        
        foreach (var prop in properties)
        {
            if (_excludedProps.Contains(prop.Name))
                continue;
                
            var propValue = prop.GetValue(value);
            // 保留简单属性和非空复杂属性
            if ((prop.PropertyType.IsValueType || prop.PropertyType == typeof(string)) || propValue != null)
            {
                writer.WritePropertyName(prop.Name);
                JsonSerializer.Serialize(writer, propValue, options);
            }
        }
        
        writer.WriteEndObject();
    }
}

// 序列化EF模型得到过滤后的JSON
string filteredJson = JsonSerializer.Serialize(dbUser, options);

2. 反序列化为动态POCO #

将过滤后的JSON反序列化为ExpandoObject，即可当作POCO使用：

var dynamicPoco = JsonSerializer.Deserialize<ExpandoObject>(filteredJson, options);
// 此时dynamicPoco就是符合要求的动态POCO，可直接传递给SendGrid模板（SendGrid接受JSON格式，也可直接传入dynamic对象）

• 优势：无需提前定义DTO，通过序列化/反序列化自动处理结构；缺点：丢失类型安全，调试时不如强类型DTO直观。

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