private void GetUsers(TfsTeamProjectCollection tpc)
        {
            IIdentityManagementService2 identityManagementService = tpc.GetService <IIdentityManagementService2>();
            var validUsers = identityManagementService.ReadIdentities(IdentitySearchFactor.AccountName, new[] { "Project Collection Valid Users" }, MembershipQuery.Expanded, ReadIdentityOptions.None)[0][0].Members;
            var users      = identityManagementService.ReadIdentities(validUsers, MembershipQuery.None, ReadIdentityOptions.None).Where(x => !x.IsContainer).ToArray();
            var userNames  = users.Select(u => u.DisplayName).ToList();

            userNames.Sort();

            UICommon.AddToProperties("Users", userNames);
        }
//		private static readonly HashSet<string> st_commiterImageCache = new HashSet<string>();

        private static void DownloadAvatars(IIdentityManagementService2 identityService, string outputAvatarsDir, IEnumerable <string> commiters)
        {
            var invalidFileChars = new [] { '\\', ',', '/', '<', '>', '?', '|', ':', '*' };

            var searchCommiters1 = new string[1];

            foreach (var commiter in commiters)
            {
                if (string.IsNullOrEmpty(commiter) || commiter.IndexOfAny(invalidFileChars) >= 0)
                {
                    continue;
                }

                var imagePath = Path.Combine(outputAvatarsDir, commiter + ".png");
                if (File.Exists(imagePath))
                {
                    if ((DateTime.Now - File.GetLastWriteTime(imagePath)).TotalHours < 24)
                    {
                        continue;
                    }

                    // File is expired
                    File.Delete(imagePath);
                }

                searchCommiters1[0] = commiter;
                var identities = identityService.ReadIdentities(IdentitySearchFactor.DisplayName,
                                                                searchCommiters1, MembershipQuery.Expanded, ReadIdentityOptions.ExtendedProperties);

                if (identities == null || !identities.Any())
                {
                    continue;
                }

                foreach (var identity in identities[0])
                {
                    object imageData;
                    if (!identity.TryGetProperty("Microsoft.TeamFoundation.Identity.Image.Data", out imageData))
                    {
                        continue;
                    }

                    var imageBytes = imageData as byte[];
                    if (imageBytes == null)
                    {
                        continue;
                    }

                    //			var imageFormat = GetImageFormat(imageBytes);
                    //			Trace.WriteLine(imageFormat);
                    File.WriteAllBytes(imagePath, imageBytes);

                    break;
                }
            }
        }
        public IEnumerable <ITeamFoundationIdentity> ReadIdentities(
            IEnumerable <IIdentityDescriptor> descriptors,
            MembershipQuery queryMembership)
        {
            if (descriptors == null)
            {
                throw new ArgumentNullException(nameof(descriptors));
            }

            var rawDescriptors = descriptors.Select(
                descriptor => new Microsoft.TeamFoundation.Framework.Client.IdentityDescriptor(
                    descriptor.IdentityType,
                    descriptor.Identifier))
                                 .ToArray();

            var identities =
                _identityManagementService2.ReadIdentities(
                    rawDescriptors,
                    (Microsoft.TeamFoundation.Framework.Common.MembershipQuery)queryMembership,
                    ReadIdentityOptions.IncludeReadFromSource);

            // TODO: Use configuration options from IWorkItemStore to control proxy creation
            return(identities.Select(identity => identity?.AsProxy()));
        }