C# 控制台应用程序通过输入用户名和集合url打印特定用户的广告和TFS组 命名空间TFSGroupMembersFast { 班级计划 { 静态词典 m_恒等式= 新词典 （IdentityDescriptorComparer.Instance）； 静态列表m

控制台应用程序通过输入用户名和集合url打印特定用户的广告和TFS组

命名空间TFSGroupMembersFast
{
班级计划
{
静态词典
m_恒等式=
新词典
（IdentityDescriptorComparer.Instance）；
静态列表m_组=新建
List（）；
静态字符串uname；
静态身份管理服务；
静态列表grname=新列表（）；
静态void Main（字符串[]参数）
{
WriteLine（“输入TFS服务器或项目集合Url”）；
控制台。写（“例如。http://localhost:8080/tfs/defaultcollection: ");
Console.WriteLine（）；
字符串地址=Console.ReadLine（）；
Console.WriteLine（）；
WriteLine（“为项目范围输入团队项目Uri，否则
空字符串“）；
控制台。写（“例如。vstfs:///Classification/TeamProject/****: ");
字符串projectUri=Console.ReadLine（）；
Console.WriteLine（）；
Console.WriteLine（“输入用户名：”）；
uname=Console.ReadLine（）；
DateTime startTime=DateTime.Now；
TfsTeamProjectCollection tfs=TfsTeamProjectCollectionFactory.GetTeamProjectCollection（TfsTeamProjectCollection.GetFullyQualifiedUriForName（地址））；
_ims=tfs.GetService（）；
if（string.IsNullOrEmpty（projectUri））
{
TeamFoundationIdentity组=
_ims.ReadIdentity（GroupWellKnownDescriptors.EveryoneGroup，
MembershipQuery.Direct、ReadIdentityOptions.None）；
m_标识[group.Descriptor]=组；
m_组。添加（组）；
//获取“有效用户”组的扩展成员资格，即
此主机中的身份
组=
_ims.ReadIdentity（GroupWellKnownDescriptors.EveryoneGroup，
MembershipQuery.Expanded，ReadIdentityOptions.None）；
获取身份（组成员）；
}
其他的
{
//获取此项目中的所有组
TeamFoundationIdentity[]项目组=
_ims.listApplicationGroup（projectUri、ReadIdentityOptions.None）；
Dictionary descSet=新字典（IdentityDescriptorComparer.Instance）；
foreach（项目组中的TeamFoundationIdentity项目组）
{
descSet[projectGroup.Descriptor]=projectGroup.Descriptor；
}
//扩大项目组成员
projectGroups=\u ims.readIdentifies（descSet.Keys.ToArray（），
MembershipQuery.Expanded，ReadIdentityOptions.None）；
//收集所有描述符
foreach（项目组中的TeamFoundationIdentity项目组）
{
foreach（projectGroup.Members中的IdentityDescriptor mem）
{
descSet[mem]=mem；
}
}
fetchIdentifies（descSet.Keys.ToArray（））；
}
//现在输出组及其成员。
foreach（m_组中的TeamFoundationIdentity）
{
书写（身份）；
}
Console.WriteLine（String.Format（“================已完成读取{0}
{1}分钟内的标识“，
m_identies.Count，（DateTime.Now-startTime.TotalMinutes））；
for（int i=0；ibatchSizeLimit）
{
int batchNum=0；
整数余数=描述符。长度；
IdentityDescriptor[]批描述符=新建
IdentityDescriptor[batchSizeLimit]；
而（余数>0）
{
int startAt=batchNum*batchSizeLimit；
int length=batchSizeLimit；
如果（长度>余数）
{
长度=余数；
batchDescriptors=新标识符描述符[长度]；
}
Copy（描述符，startAt，批描述符，0，长度）；
标识=_ims.readIdentifies（批描述符，
MembershipQuery.Direct、ReadIdentityOptions.None）；
实体（身份）；
余数-=长度；
}
}
其他的
{
标识=_ims.readIdentifies（描述符，
MembershipQuery.Direct、ReadIdentityOptions.None）；
实体（身份）；
}
}
静态无效SORTID实体（TeamFoundationIdentity[]标识）
{
foreach（身份中的TeamFoundationIdentity）
{
m_恒等式[identity.Descriptor]=恒等式；
if（identity.IsContainer）
{
m_组。添加（标识）；
}
}
}
静态无效写入（TeamFoundationIdentity组）
{
//输出此组的成员资格
WriteLine（“组的成员：{0}”，group.DisplayName）；
Console.WriteLine（“============================”）；
foreach（组成员中的IdentityDescriptor memDesc）
{
Console.WriteLine（m_标识[memDesc].DisplayName）；
如果（m_ide
namespace TFSGroupMembersFast
{
    class Program
    {
        static Dictionary<IdentityDescriptor, TeamFoundationIdentity> 
        m_identities =
        new Dictionary<IdentityDescriptor, TeamFoundationIdentity> 
        (IdentityDescriptorComparer.Instance);
        static List<TeamFoundationIdentity> m_groups = new 
        List<TeamFoundationIdentity>();
        static string uname;
        static IIdentityManagementService _ims;
        static List<string> grname = new List<string>();
        static void Main(string[] args)
        {
            Console.WriteLine("Enter TFS server or project collection Url");
            Console.Write("e.g. http://localhost:8080/tfs/defaultcollection: ");
            Console.WriteLine();
            string address = Console.ReadLine();
            Console.WriteLine();

            Console.WriteLine("Enter Team Project Uri for project scope, else 
            empty string");
            Console.Write("e.g. vstfs:///Classification/TeamProject/****: ");
            string projectUri = Console.ReadLine();
            Console.WriteLine();
            Console.WriteLine("Enter user name:");
            uname = Console.ReadLine();

            DateTime startTime = DateTime.Now;

            TfsTeamProjectCollection tfs = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(TfsTeamProjectCollection.GetFullyQualifiedUriForName(address));
            _ims = tfs.GetService<IIdentityManagementService>();

            if (string.IsNullOrEmpty(projectUri))
            {
                TeamFoundationIdentity group = 
                _ims.ReadIdentity(GroupWellKnownDescriptors.EveryoneGroup, 
                MembershipQuery.Direct, ReadIdentityOptions.None);
                m_identities[group.Descriptor] = group;
                m_groups.Add(group);

                // Get expanded membership of the Valid Users group, which is all 
                identities in this host             
                group = 
                _ims.ReadIdentity(GroupWellKnownDescriptors.EveryoneGroup, 
                MembershipQuery.Expanded, ReadIdentityOptions.None);
                FetchIdentities(group.Members);
            }
            else
            {
                // Get all groups in this project
                TeamFoundationIdentity[] projectGroups = 
                _ims.ListApplicationGroups(projectUri, ReadIdentityOptions.None);

                Dictionary<IdentityDescriptor, object> descSet = new Dictionary<IdentityDescriptor, object>(IdentityDescriptorComparer.Instance);

                foreach (TeamFoundationIdentity projectGroup in projectGroups)
                {
                    descSet[projectGroup.Descriptor] = projectGroup.Descriptor;
                }

                // Expanded membership of project groups
                projectGroups = _ims.ReadIdentities(descSet.Keys.ToArray(), 
                MembershipQuery.Expanded, ReadIdentityOptions.None);

                // Collect all descriptors
                foreach (TeamFoundationIdentity projectGroup in projectGroups)
                {
                    foreach (IdentityDescriptor mem in projectGroup.Members)
                    {
                        descSet[mem] = mem;
                    }
                }

                FetchIdentities(descSet.Keys.ToArray());
            }

            // Now output groups and their members.
            foreach (TeamFoundationIdentity identity in m_groups)
            {
                Write(identity);
            }

            Console.WriteLine(String.Format("======= Finished reading {0} 
            identities in {1} minutes",
                m_identities.Count, (DateTime.Now - startTime).TotalMinutes));

            for (int i = 0; i < grname.Count; i++)
            {
                Console.WriteLine(grname[i]);
            }
            Console.ReadLine();
        }

        static void FetchIdentities(IdentityDescriptor[] descriptors)
        {
            TeamFoundationIdentity[] identities;

            // If total membership exceeds batch size limit for Read, break it up
            int batchSizeLimit = 100000;

            if (descriptors.Length > batchSizeLimit)
            {
                int batchNum = 0;
                int remainder = descriptors.Length;
                IdentityDescriptor[] batchDescriptors = new 
                IdentityDescriptor[batchSizeLimit];

                while (remainder > 0)
                {
                    int startAt = batchNum * batchSizeLimit;
                    int length = batchSizeLimit;
                    if (length > remainder)
                    {
                        length = remainder;
                        batchDescriptors = new IdentityDescriptor[length];
                    }

                    Array.Copy(descriptors, startAt, batchDescriptors, 0,length);
                    identities = _ims.ReadIdentities(batchDescriptors, 
                    MembershipQuery.Direct, ReadIdentityOptions.None);
                    SortIdentities(identities);
                    remainder -= length;
                }
            }
            else
            {
                identities = _ims.ReadIdentities(descriptors, 
                MembershipQuery.Direct, ReadIdentityOptions.None);
                SortIdentities(identities);
            }
        }

        static void SortIdentities(TeamFoundationIdentity[] identities)
        {
            foreach (TeamFoundationIdentity identity in identities)
            {
                m_identities[identity.Descriptor] = identity;

                if (identity.IsContainer)
                {
                    m_groups.Add(identity);
                }
            }
        }

        static void Write(TeamFoundationIdentity group)
        {
            // Output this group's membership
            Console.WriteLine("Members of group: {0}", group.DisplayName);
            Console.WriteLine("=================");

            foreach (IdentityDescriptor memDesc in group.Members)
            {
                Console.WriteLine(m_identities[memDesc].DisplayName);
                if (m_identities[memDesc].DisplayName == uname)
                {
                    grname.Add(group.DisplayName);

                }
            }
            Console.WriteLine();
        }
    }
}

using Microsoft.TeamFoundation.Client;
using Microsoft.TeamFoundation.Server;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace GetUser
{
    class Program
    {
        static void Main(string[] args)
        {
            TfsTeamProjectCollection tfs = new TfsTeamProjectCollection(new Uri("http://server:8080/tfs/DefaultCollection"));
            tfs.EnsureAuthenticated();

            IGroupSecurityService gss = tfs.GetService<IGroupSecurityService>();

            Identity SIDS = gss.ReadIdentity(SearchFactor.AccountName, "Project Collection Valid Users", QueryMembership.Expanded);

            Identity[] UserId = gss.ReadIdentities(SearchFactor.Sid, SIDS.Members, QueryMembership.Direct);

            foreach (Identity user in UserId)
            {
                if (user != null)
                {
                    Console.WriteLine(user.AccountName);
                    Console.WriteLine(user.Domain);
                }
            }
            Console.ReadKey();
        }
    }
}