.NET Core 3.1 Identity：如何检查用户单一角色并处理多角色逻辑

这个角色行为优先级的问题很典型，你的当前实现其实完全没问题——尤其是在角色数量不多、逻辑简单的场景下。但如果之后角色会增加、行为逻辑变复杂，确实可以用更优雅、可维护的方式重构，比如策略模式或者基于优先级的规则匹配。下面给你几种可行的方案参考：

1. 优化基础判断：封装逻辑提升可读性 #

如果暂时不想引入复杂模式，先把重复的判断逻辑封装成扩展方法，既能保持代码简洁，又能把角色判断逻辑集中管理，方便后续修改：

public static class UserRoleExtensions
{
    // 封装Role1行为的触发条件
    public static bool ShouldExecuteRole1Behavior(this IPrincipal user)
    {
        return user.IsInRole(Role1.ToString()) && !user.IsInRole(Role2.ToString());
    }

    // 可以继续封装其他角色的判断逻辑
    public static bool ShouldExecuteRole2Behavior(this IPrincipal user)
    {
        return user.IsInRole(Role2.ToString());
    }
}

使用时就会非常简洁：

if (User.ShouldExecuteRole1Behavior())
{
    // 执行Role1特定行为
}
else if (User.ShouldExecuteRole2Behavior())
{
    // 执行Role2覆盖后的行为
}
else
{
    // 兜底的默认行为
}

2. 策略模式：适合复杂行为与可扩展场景 #

如果你的角色行为逻辑比较复杂，或者未来会新增更多角色/行为，策略模式是非常合适的选择——它能很好地遵循开闭原则，新增行为时不用修改原有代码，只需要添加新的策略实现。

步骤1：定义行为接口 #

先抽象出角色行为的通用接口，包含行为执行方法和适用判断方法：

public interface IRoleBehavior
{
    void Execute();
    bool IsApplicable(IPrincipal user);
}

步骤2：实现各角色的行为类 #

为每个角色（或行为场景）实现对应的策略类：

// Role1的专属行为
public class Role1SpecificBehavior : IRoleBehavior
{
    public void Execute()
    {
        // 这里写Role1的特定行为逻辑
    }

    public bool IsApplicable(IPrincipal user)
    {
        // 只有当用户有Role1且没有Role2时适用
        return user.IsInRole(Role1.ToString()) && !user.IsInRole(Role2.ToString());
    }
}

// Role2覆盖后的行为
public class Role2OverrideBehavior : IRoleBehavior
{
    public void Execute()
    {
        // 这里写Role2对应的行为逻辑
    }

    public bool IsApplicable(IPrincipal user)
    {
        // 只要用户有Role2就适用（优先级更高）
        return user.IsInRole(Role2.ToString());
    }
}

// 默认兜底行为
public class DefaultRoleBehavior : IRoleBehavior
{
    public void Execute()
    {
        // 用户没有匹配角色时的默认行为
    }

    public bool IsApplicable(IPrincipal user)
    {
        return true; // 最后兜底匹配
    }
}

步骤3：创建行为选择器 #

用一个选择器类来找到对当前用户适用的行为：

public class RoleBehaviorSelector
{
    private readonly IEnumerable<IRoleBehavior> _behaviors;

    // 推荐用依赖注入注入所有IRoleBehavior实现，避免硬编码
    public RoleBehaviorSelector(IEnumerable<IRoleBehavior> behaviors)
    {
        _behaviors = behaviors;
    }

    public IRoleBehavior GetApplicableBehavior(IPrincipal user)
    {
        // 注意：优先级高的行为要先匹配，比如Role2的判断要在Role1前面
        return _behaviors.FirstOrDefault(b => b.IsApplicable(user)) 
               ?? new DefaultRoleBehavior();
    }
}

步骤4：使用策略模式 #

在业务代码中调用选择器获取行为并执行：

// 实例化选择器（实际项目中推荐依赖注入）
var selector = new RoleBehaviorSelector(new List<IRoleBehavior>
{
    new Role2OverrideBehavior(), // 优先级高的放前面
    new Role1SpecificBehavior(),
    new DefaultRoleBehavior()
});

// 获取适用行为并执行
var applicableBehavior = selector.GetApplicableBehavior(User);
applicableBehavior.Execute();

这种模式的优势在于：新增角色行为时，只需要添加新的IRoleBehavior实现，完全不用修改原有逻辑，代码的扩展性和可维护性大幅提升。

3. 角色优先级匹配：适合明确的层级关系 #

如果你的角色有明确的优先级层级（比如Role2 > Role1 > 其他），可以直接基于优先级排序来匹配行为，逻辑直观易懂：

步骤1：定义角色优先级 #

先给每个角色设置优先级数值（数值越高优先级越高）：

public enum Role
{
    Role1,
    Role2,
    Default
}

public static class RolePriorityConfig
{
    public static readonly Dictionary<Role, int> Priorities = new Dictionary<Role, int>
    {
        { Role.Role2, 2 },
        { Role.Role1, 1 },
        { Role.Default, 0 }
    };
}

步骤2：获取用户的最高优先级角色 #

编写方法找到用户拥有的角色中优先级最高的那个：

public static Role GetUserHighestPriorityRole(IPrincipal user)
{
    var userRoles = Enum.GetValues(typeof(Role))
                        .Cast<Role>()
                        .Where(r => user.IsInRole(r.ToString()));

    // 如果用户没有任何匹配角色，返回默认角色
    return userRoles.OrderByDescending(r => RolePriorityConfig.Priorities[r])
                    .FirstOrDefault() ?? Role.Default;
}

步骤3：根据最高优先级角色执行行为 #

最后根据角色执行对应逻辑：

var highestPriorityRole = GetUserHighestPriorityRole(User);

switch (highestPriorityRole)
{
    case Role.Role2:
        // 执行Role2的行为
        break;
    case Role.Role1:
        // 执行Role1的特定行为
        break;
    default:
        // 执行默认行为
        break;
}

这种方式适合角色层级清晰的场景，代码逻辑简单直接，容易理解和维护。

总结 #

• 如果角色少、逻辑简单：优先选择优化后的基础判断，简单高效；
• 如果行为复杂、需要频繁扩展：推荐使用策略模式，符合开闭原则，扩展性强；
• 如果角色有明确优先级层级：选择优先级匹配方案，逻辑直观易懂。

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