C# ICollection.Distinct方法代码示例

 /// <summary>
 ///     Searches all available versions of a package in a list of repostiories
 /// </summary>
 /// <param name="repositories">Repositories to search</param>
 /// <param name="packageName">Pacakge identifier</param>
 /// <returns>List of available versions</returns>
 public static ICollection<string> Search(ICollection<string> repositories, string packageName)
 {
     var factory = new PackageRepositoryFactory();
     var globalRepo = new AggregateRepository(factory, repositories.Distinct(), true);
     var packages = globalRepo.FindPackagesById(packageName);
     return packages.Select(x => x.Version)
                    .OrderByDescending(x => x)
                    .Select(x => x.ToString())
                    .ToList()
                    .Distinct().ToList() ;
 }

        /// <summary>
        /// Simulates a fight between the player and the boss using the specified upgrades.
        /// </summary>
        /// <param name="weapon">The weapon to purchase.</param>
        /// <param name="armor">The armor to purchase, if any.</param>
        /// <param name="rings">The rings to purchase, if any.</param>
        /// <returns>
        /// A <see cref="Tuple{T1, T2}"/> that returns whether the human player won and the amount of gold spent.
        /// </returns>
        internal static Tuple<bool, int> Fight(string weapon, string armor, ICollection<string> rings)
        {
            Shop shop = new Shop();
            Human human = new Human();

            int goldSpent = human.Upgrade(shop.PurchaseWeapon(weapon));

            if (!string.IsNullOrEmpty(armor))
            {
                goldSpent += human.Upgrade(shop.PurchaseArmor(armor));
            }

            foreach (string ring in rings.Distinct().Take(2))
            {
                goldSpent += human.Upgrade(shop.PurchaseRing(ring));
            }

            Boss boss = new Boss();

            Player winner = Fight(human, boss);

            return Tuple.Create(winner == human, goldSpent);
        }

        private async Task<IList<UserDocument>> GetAllUserDocumentsFromIdList(ICollection<string> listOfUserIds)
        {
            listOfUserIds = listOfUserIds.Distinct().ToList();

            var query = _documentClient.CreateDocumentQuery<UserDocument>(DocumentCollectionUri)
                .Where(d => d.DocumentType == UserDocument.DocumentTypeIdentifier)
                .Where(d => d.DocumentVersion == _currentDocumentVersion)
                .Where(u => listOfUserIds.Contains(u.Id))
                .AsDocumentQuery();

            var documentResponse = await query.ExecuteNextAsync<UserDocument>();

            return documentResponse.ToList();
        }

 internal static void InvokePreStartInitMethodsCore(ICollection<MethodInfo> methods, Func<IDisposable> setHostingEnvironmentCultures) {
     // Remove dupes 
     var methodsToExecute = methods.Distinct();
     // We want to execute PreApplicationStartmethods in a deterministic order. We'll use a sorted sequence of fully qualified type names and method names. 
     methodsToExecute = methodsToExecute.OrderBy(m => m.DeclaringType.AssemblyQualifiedName, StringComparer.OrdinalIgnoreCase)
                                        .ThenBy(m => m.Name, StringComparer.OrdinalIgnoreCase);
     foreach (var method in methodsToExecute) {
         try {
             // 
             using (setHostingEnvironmentCultures()) {
                 method.Invoke(null, null);
             }
         }
         catch (TargetInvocationException e) {
             string message = (e.InnerException != null ? e.InnerException.Message : String.Empty);
             throw new InvalidOperationException(
                 SR.GetString(SR.Pre_application_start_init_method_threw_exception,
                     method.Name,
                     method.DeclaringType.FullName,
                     message),
                 e.InnerException);
         }
     }
 }

 public static PageBE[] FilterDisallowed(UserBE user, ICollection<PageBE> pages, bool throwException, bool allowApiKey, bool applyBanMask, out PageBE[] filteredOutPages, params Permissions[] actions) {
     IEnumerable<ulong> filtered;
     var pageLookup = pages.Distinct(x => x.ID).ToDictionary(x => x.ID);
     var allowed = FilterDisallowed(user, pages.Select(x => x.ID), throwException, allowApiKey, applyBanMask, out filtered, actions);
     filteredOutPages = filtered.Select(x => pageLookup[x]).ToArray();
     return allowed.Select(x => pageLookup[x]).ToArray();
 }

        private void ProcessUpdates(ICollection<string> modified, ICollection<string> deleted, IEnumerable<string> added)
        {
            #region Modified

            var dict = new Dictionary<ElementUpdateDelegate, HashSet<string>>();
            foreach (var modifiedElementID in modified)
            {
                if (!modifiedCallbacks.ContainsKey(modifiedElementID))
                    continue;

                var k = modifiedCallbacks[modifiedElementID];
                if (!dict.ContainsKey(k))
                    dict[k] = new HashSet<string>();
                dict[k].Add(modifiedElementID);
            }

            foreach (var pair in dict)
                pair.Key(pair.Value);

            OnElementsModified(modified.Distinct());

            #endregion

            #region Deleted

            dict.Clear();
            foreach (var deletedElementID in deleted)
            {
                if (!deletedCallbacks.ContainsKey(deletedElementID))
                    continue;

                var k = deletedCallbacks[deletedElementID];
                if (!dict.ContainsKey(k))
                    dict[k] = new HashSet<string>();
                dict[k].Add(deletedElementID);
            }

            foreach (var pair in dict)
                pair.Key(pair.Value);

            OnElementsDeleted(deleted.Distinct());

            #endregion

            #region Added

            OnElementsAdded(added.Distinct());

            #endregion
        }

 protected virtual string GenerateUsings(ICollection<string> usingLines)
 {
     return string.Join(_fileSystem.NewLine, usingLines.Distinct());
 }