如何标记C#对象属性为必填/可选/忽略？求高效实现方案

方案一：自定义规则配置类（推荐，兼顾可读性与维护性） #

这种方式比零散的字典更结构化，规则集中管理，后续扩展新类型或属性更方便。

步骤1：定义属性状态枚举 #

先明确属性的三种状态：

public enum PropertyStatus
{
    Required,
    Optional,
    Ignored
}

步骤2：创建规则配置类 #

用静态类提前初始化每种classtype对应的属性规则，避免运行时重复计算：

public static class PropertyRuleConfig
{
    private static readonly Dictionary<classtype, Dictionary<string, PropertyStatus>> _typeRules = new()
    {
        {
            classtype.A, new Dictionary<string, PropertyStatus>
            {
                { nameof(example.a), PropertyStatus.Required },
                { nameof(example.b), PropertyStatus.Optional },
                { nameof(example.c), PropertyStatus.Required },
                { nameof(example.d), PropertyStatus.Ignored }
            }
        },
        {
            classtype.B, new Dictionary<string, PropertyStatus>
            {
                { nameof(example.a), PropertyStatus.Ignored },
                { nameof(example.b), PropertyStatus.Required },
                { nameof(example.c), PropertyStatus.Optional },
                { nameof(example.d), PropertyStatus.Required }
            }
        }
        // 后续添加type.C、type.D的规则只需在这里扩展
    };

    public static PropertyStatus GetPropertyStatus(classtype type, string propertyName)
    {
        if (_typeRules.TryGetValue(type, out var propRules) && propRules.TryGetValue(propertyName, out var status))
        {
            return status;
        }
        // 默认返回忽略，可根据业务调整
        return PropertyStatus.Ignored;
    }
}

步骤3：改造DoSomething方法 #

遍历对象属性时，通过配置类直接获取属性状态，按规则处理：

public static void DoSomething(List<example> examples)
{
    foreach (example ex in examples)
    {
        foreach (PropertyInfo prop in ex.GetType().GetProperties())
        {
            // 跳过type属性本身，只处理业务属性a/b/c/d
            if (prop.Name == nameof(example.type))
                continue;

            var status = PropertyRuleConfig.GetPropertyStatus(ex.type, prop.Name);
            switch (status)
            {
                case PropertyStatus.Required:
                    DoSomethingElse(prop, ex); // 传入实例方便获取属性值
                    break;
                case PropertyStatus.Optional:
                    DoThis(prop, ex);
                    break;
                case PropertyStatus.Ignored:
                    // 忽略处理
                    break;
            }
        }
    }
}

// 示例辅助方法（根据实际需求实现）
private static void DoSomethingElse(PropertyInfo prop, example ex)
{
    var value = prop.GetValue(ex);
    // 处理必填属性逻辑，比如校验非空
}

private static void DoThis(PropertyInfo prop, example ex)
{
    var value = prop.GetValue(ex);
    // 处理可选属性逻辑，比如有值才处理
}

方案二：表达式树缓存（高性能场景） #

如果你的方法需要高频调用，追求极致性能，可以提前缓存属性访问器，避免反射的重复开销：

public static class PropertyAccessorCache
{
    private static readonly Dictionary<(classtype, string), (Func<example, object> Getter, PropertyStatus Status)> _accessorCache = new();

    static PropertyAccessorCache()
    {
        // 初始化所有类型的属性访问器和状态
        foreach (var type in Enum.GetValues<classtype>())
        {
            if (!PropertyRuleConfig._typeRules.TryGetValue(type, out var propRules))
                continue;

            foreach (var (propName, status) in propRules)
            {
                var prop = typeof(example).GetProperty(propName);
                if (prop == null) continue;

                // 用表达式树构建属性访问器，编译后直接调用
                var param = Expression.Parameter(typeof(example), "ex");
                var propAccess = Expression.Property(param, prop);
                var convert = Expression.Convert(propAccess, typeof(object));
                var getter = Expression.Lambda<Func<example, object>>(convert, param).Compile();

                _accessorCache.Add((type, propName), (getter, status));
            }
        }
    }

    public static (Func<example, object> Getter, PropertyStatus Status) GetAccessor(classtype type, string propName)
    {
        _accessorCache.TryGetValue((type, propName), out var result);
        return result;
    }
}

改造后的DoSomething方法：

public static void DoSomething(List<example> examples)
{
    foreach (example ex in examples)
    {
        if (!PropertyRuleConfig._typeRules.TryGetValue(ex.type, out var propRules))
            continue;

        foreach (var propName in propRules.Keys)
        {
            var (getter, status) = PropertyAccessorCache.GetAccessor(ex.type, propName);
            if (getter == null) continue;

            switch (status)
            {
                case PropertyStatus.Required:
                    var reqValue = getter(ex);
                    DoSomethingElse(reqValue);
                    break;
                case PropertyStatus.Optional:
                    var optValue = getter(ex);
                    DoThis(optValue);
                    break;
            }
        }
    }
}

方案对比 #

• 方案一：实现简单，规则直观易维护，适合绝大多数业务场景。
• 方案二：性能更优，提前缓存访问器避免重复反射，适合高频调用的性能敏感场景。

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