如何高效判断Active Directory用户是否属于指定AD组？

你的代码慢的核心原因是多次独立的LDAP查询往返：每次调用GroupPrincipal.FindByIdentity和user.IsMemberOf都会发起一次AD请求，4个组就至少8次往返，延迟自然高。GetAuthorizationGroups慢是因为它会递归枚举用户所有嵌套组，数据量一大就拖慢速度。以下是几个高效的优化方案：

方案1：预缓存目标组SID，内存匹配用户组 #

SID是AD对象的唯一标识，比组名查询更快，且避免名称重复的问题。步骤如下：

1. 一次性获取所有目标组的SID（仅一次LDAP请求）
2. 获取用户的所有组SID（直接/嵌套，按需选择）
3. 在内存中对比SID，判断归属

代码示例：

using (PrincipalContext pc = new PrincipalContext(ContextType.Domain, domain.Text, username.Text, password.Text))
{
    // 定义目标组与对应ID的映射
    var targetGroups = new Dictionary<string, int>
    {
        { group1.Text, 1 },
        { group2.Text, 2 },
        { group3.Text, 3 },
        { group4.Text, 4 }
    };

    HashSet<SecurityIdentifier> targetSids = new HashSet<SecurityIdentifier>();
    foreach (var groupName in targetGroups.Keys)
    {
        var group = GroupPrincipal.FindByIdentity(pc, IdentityType.Name, groupName);
        if (group != null)
            targetSids.Add(group.Sid);
    }

    // 获取用户对象
    UserPrincipal user = UserPrincipal.FindByIdentity(pc, IdentityType.SamAccountName, username.Text);
    if (user == null) return;

    int userGroupTmp = 0;
    // 获取用户的所有授权组SID（含嵌套），仅一次LDAP请求
    foreach (var group in user.GetAuthorizationGroups())
    {
        if (targetSids.Contains(group.Sid))
        {
            userGroupTmp = targetGroups.First(g => g.Key == group.Name).Value;
            break; // 找到第一个匹配的就退出
        }
    }
}

注：如果只需要直接组，替换GetAuthorizationGroups为user.GetGroups()，性能会更好。

方案2：使用DirectoryEntry直接操作LDAP（性能最优） #

System.DirectoryServices的底层API比PrincipalContext开销更小，能直接构造LDAP查询减少往返：

方式A：一次性检查用户是否属于多个组 #

利用LDAP的LDAP_MATCHING_RULE_IN_CHAIN匹配规则，直接查询用户是否属于目标组（含嵌套），一次请求搞定：

// 先预获取目标组的完整DN（可提前缓存）
Dictionary<string, string> groupDns = new Dictionary<string, string>
{
    { group1.Text, "CN=Group1,OU=Groups,DC=yourdomain,DC=com" },
    { group2.Text, "CN=Group2,OU=Groups,DC=yourdomain,DC=com" }
};

using (DirectoryEntry entry = new DirectoryEntry($"LDAP://{domain.Text}", username.Text, password.Text))
{
    using (DirectorySearcher searcher = new DirectorySearcher(entry))
    {
        // 构造查询过滤器：匹配用户属于任意目标组
        string groupFilter = string.Join("|", 
            groupDns.Values.Select(dn => $"(member:1.2.840.113556.1.4.1941:={dn})"));
        searcher.Filter = $"(&(objectClass=user)(sAMAccountName={username.Text})({groupFilter}))";
        searcher.PropertiesToLoad.Add("memberOf");

        SearchResult result = searcher.FindOne();
        if (result != null)
        {
            int userGroupTmp = 0;
            // 解析匹配的组
            foreach (string groupDn in result.Properties["memberOf"])
            {
                string groupName = groupDn.Split(',')[0].Replace("CN=", "");
                if (targetGroups.TryGetValue(groupName, out int groupId))
                {
                    userGroupTmp = groupId;
                    break;
                }
            }
        }
    }
}

方式B：获取用户所有组后内存匹配 #

直接读取用户的tokenGroups属性（一次请求返回所有嵌套组的SID），然后和目标组SID对比：

// 提前缓存目标组SID集合（HashSet<SecurityIdentifier> targetSids）
using (DirectoryEntry userEntry = new DirectoryEntry($"LDAP://{domain.Text}/CN={username.Text},OU=Users,DC=yourdomain,DC=com", 
                                                     username.Text, password.Text))
{
    // 加载tokenGroups属性（包含所有嵌套组的SID）
    userEntry.RefreshCache(new[] { "tokenGroups" });
    int userGroupTmp = 0;

    foreach (byte[] sidBytes in userEntry.Properties["tokenGroups"])
    {
        SecurityIdentifier sid = new SecurityIdentifier(sidBytes, 0);
        if (targetSids.TryGetValue(sid, out int groupId))
        {
            userGroupTmp = groupId;
            break;
        }
    }
}

额外优化建议 #

• 复用连接对象：不要每次查询都新建PrincipalContext或DirectoryEntry，连接池复用能大幅减少连接开销
• 限制返回属性：查询时只加载需要的属性（如SID、名称），避免返回AD对象的冗余属性
• 避免不必要的递归：如果不需要嵌套组，优先用直接组查询（GetGroups或memberOf属性）

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