C# IEnumerable.Except方法代码示例

 public void Int(IEnumerable<int> first, IEnumerable<int> second, IEqualityComparer<int> comparer, IEnumerable<int> expected)
 {
     if (comparer == null)
     {
         Assert.Equal(expected, first.Except(second));
     }
     Assert.Equal(expected, first.Except(second, comparer));
 }

 public void String(IEnumerable<string> first, IEnumerable<string> second, IEqualityComparer<string> comparer, IEnumerable<string> expected)
 {
     if (comparer == null)
     {
         Assert.Equal(expected, first.Except(second));
     }
     Assert.Equal(expected, first.Except(second, comparer));
 }

            /// <summary>
            /// Determines whether the given folder contains only the given files, and no others
            /// </summary>
            /// <returns></returns>
            protected bool FolderContainsExclusive(string relFolderPath, IEnumerable<string> filenames, Anomalies anomalies = null)
            {
                var dirPath = Path.Combine(this.TargetDir, relFolderPath);
                var exists = Directory.Exists(dirPath);
                if (!exists)
                {
                    return false;
                }
                else
                {
                    var folderFiles = new DirectoryInfo(dirPath).GetFiles();

                    var filesInFolder = folderFiles.Select(f => f.Name).Except(filenames).ToList();
                    var expectedFiles = filenames.Except(folderFiles.Select(f => f.Name)).ToList();

                    if (anomalies != null)
                    {
                        anomalies.ExpectedFiles.AddRange(expectedFiles);
                        anomalies.UnexpectedFiles.AddRange(filesInFolder);
                    }

                    return !(filesInFolder.Any())
                        && !(expectedFiles.Any());
                }
            }

        static Types()
        {
            BuiltIn = new[]
                          {
                              typeof (Boolean),
                              typeof (Byte),
                              typeof (SByte),
                              typeof (Char),
                              typeof (Single),
                              typeof (Double),
                              typeof (Decimal),
                              typeof (Int16),
                              typeof (Int32),
                              typeof (Int64),
                              typeof (UInt16),
                              typeof (UInt32),
                              typeof (UInt64),
                              typeof (String),
                              typeof (Object)
                          };

            Simple = BuiltIn.Except(new[] { typeof(String), typeof(Object) }).ToArray();
            Comparable = Simple.Except(new[] { typeof(Boolean) }).ToArray();
            Empty = Enumerable.Empty<Type>();
        }

        public IEnumerable<PositionResultsViewModel> GetDetailedItems(long portfolioID, IEnumerable<StockDataItem> items)
        {
            try
            {
                var results = new List<PositionResultsViewModel>();

                var positions = _portRepo.GetAllPositions(portfolioID);
                if (!positions.Any()) return new List<PositionResultsViewModel>();

                var tickers = positions.Select(p => p.Ticker).Distinct();
                var stockData = _stockRepo.GetStockQuotes(tickers);

                foreach (var position in positions)
                {
                    var ticker = position.Ticker;
                    var tickerStockData = stockData.Single(stock => stock.Ticker == ticker);
                    var stockItems = GetStockItems(items, tickerStockData);
                    var remainingItemsToGet = items.Except(stockItems.Keys);
                    stockItems.AddRange(CalculateItems(remainingItemsToGet, position, tickerStockData));

                    var positionResults = new PositionResultsViewModel(position.ID ?? -1);
                    positionResults.Items = stockItems;

                    results.Add(positionResults);
                }
                return results;
            }
            catch (Exception ex)
            {
                Log.Error("GetDetailedItems", ex.ToString());
                throw;
            }
        }

        public async Task UpdateEndpointSubscriptions(string endpoint, IEnumerable<Subscription> subscriptions)
        {
            // lazy initialization, ensures only one thread runs the initialize function
            await this.initializationTask.Value;

            var storedSubscriptions = await this.store.GetByEndpoint(endpoint);

            var subscriptionsToAdd = subscriptions.Except(storedSubscriptions);
            var subscriptionsToRemove = storedSubscriptions.Except(subscriptions);

            var tasks = new List<Task>();

            foreach (var subscription in subscriptionsToAdd)
            {
                tasks.Add(this.AddSubscription(subscription));
            }

            foreach (var subscription in subscriptionsToRemove)
            {
                tasks.Add(this.RemoveSubscription(subscription));
            }

            if (tasks.Count > 0)
            {
                await Task.WhenAll(tasks.ToArray());
            }
        }

        public IEnumerable<Card> Match(IEnumerable<Card> cardsToMatch)
        {
            var nofAKind = new NofAKind();
            var threeOfAKind = nofAKind.Find(cardsToMatch, 3);

            if (threeOfAKind != null)
            {
                var restOfTheCards = cardsToMatch.Except(threeOfAKind);

                IEnumerable<Card> currentPair, highestPair = null;

                while ((currentPair = nofAKind.Find(restOfTheCards, 2)) != null)
                {
                    if (highestPair == null
                        || currentPair.First().Rank > highestPair.First().Rank)
                    {
                        highestPair = currentPair;
                        restOfTheCards = restOfTheCards.Except(currentPair);
                    }
                }

                return highestPair != null ? threeOfAKind.Union(highestPair) : null;
            }

            return null;
        }

        private void GetNextSteps(Stack<Node> currentChain, IEnumerable<Node> greyList, Node currentNode)
        {
            currentChain.Push(currentNode);

            var newGreyList =
                greyList
                    .Except(currentNode.Antecedents())
                    .Except(currentNode.Descendents())
                    .Distinct();

            if (newGreyList.Count() == 0)
            {
                ConcurrencyChains.Add(currentChain.ToList());

                MaxConcurrency = Math.Max(MaxConcurrency, (int) currentChain.Count);
            }

            foreach (var newPossible in newGreyList)
            {
                if (_previouslySeenRoots.Contains(newPossible)) continue;

                GetNextSteps(currentChain, newGreyList, newPossible);
            }

            currentChain.Pop();
        }

		public MergeWritingSystemDlg(FdoCache cache, IWritingSystem ws, IEnumerable<IWritingSystem> wss, IHelpTopicProvider helpTopicProvider)
		{
			m_cache = cache;
			m_ws = ws;

			//
			// Required for Windows Form Designer support
			//
			InitializeComponent();

			Icon infoIcon = SystemIcons.Information;
			m_infoPictureBox.Image = infoIcon.ToBitmap();
			m_infoPictureBox.Size = infoIcon.Size;

			foreach (IWritingSystem curWs in wss.Except(new[] { ws }))
				m_wsListBox.Items.Add(curWs);
			m_wsListBox.SelectedIndex = 0;

			m_helpTopicProvider = helpTopicProvider;

			if (m_helpTopicProvider != null) // m_helpTopicProvider could be null for testing
			{
				m_helpProvider = new HelpProvider();
				m_helpProvider.HelpNamespace = m_helpTopicProvider.HelpFile;
				m_helpProvider.SetHelpKeyword(this, m_helpTopicProvider.GetHelpString(HelpTopic));
				m_helpProvider.SetHelpNavigator(this, HelpNavigator.Topic);
			}
		}

		public void AutoMap(IEnumerable<string> csvColumns)
		{
			this.CsvColumns = csvColumns.ToArray();

			foreach (var propertyMap in this.PropertyMaps)
			{
				var entityColumnName = propertyMap.EntityColumnName;
				var betterMatchCsvColumn = csvColumns.Select(x => new { csvColumn = x, distance = x.ComputeLevenshteinDistance(entityColumnName) })
													 .Where(x => x.distance < 2)
													 .OrderBy(x => x.distance)
													 .Select(x => x.csvColumn)
													 .FirstOrDefault();
				if (betterMatchCsvColumn != null)
				{
					propertyMap.CsvColumnName = betterMatchCsvColumn;
					propertyMap.CustomValue = null;
				}
				else
				{
					propertyMap.CsvColumnName = null;
				}

			}
			//All not mapped properties may be a product property
			this.PropertyCsvColumns = csvColumns.Except(this.PropertyMaps.Where(x => x.CsvColumnName != null).Select(x => x.CsvColumnName)).ToArray();
			//Generate ETag for identifying csv format
			this.ETag = string.Join(";", this.CsvColumns).GetMD5Hash();
		}

        /// <summary>
        /// Initializes a new instance of the <see cref="ClassTypeTree"/> class.
        /// </summary>
        /// <param name="types">The types to build the tree out of.</param>
        public ClassTypeTree(IEnumerable<Type> types)
        {
            // ReSharper disable DoNotCallOverridableMethodsInConstructor

            var childList = new List<ClassTypeTree>();

            // Remove duplicates
            types = types.Where(x => x.IsClass).Distinct();

            // Grab the lowest-level types
            var baseTypes = types.Where(x => !types.Any(y => x != y && y.IsAssignableFrom(x)));

            // Grab the possible child types
            var remainingTypes = types.Except(baseTypes);
            foreach (var bt in baseTypes)
            {
                // Recursively build the tree
                childList.Add(CreateNode(this, bt, remainingTypes));
            }

            // Add the wildcard for the base level
            childList.Add(CreateNode(this, null, null));

            // Store the children
            _children = FinalizeChildren(childList);

            // ReSharper restore DoNotCallOverridableMethodsInConstructor
        }

        /// <summary>
        /// Obtain the set between two lists
        /// </summary>
        /// <param name="before"></param>
        /// <param name="after"></param>
        /// <returns>List of Unique Application Names</returns>
        public static List<string> GetAppsToDelete(IEnumerable<string> before, IEnumerable<string> after)
        {
            var applicationNames = before.Except(after);

            var enumerable = applicationNames as IList<string> ?? applicationNames.ToList();
            return enumerable.Any() ? enumerable.ToList() : null;
        }

        public void UpdateSession(IEnumerable<EventSourceSettings> updatedEventSources)
        {
            Guard.ArgumentNotNull(updatedEventSources, "updatedEventSources");

            var eventSourceComparer = new EventSourceSettingsEqualityComparer(nameOnly: true);

            // updated sources
            foreach (var currentSource in this.eventSources.Intersect(updatedEventSources, eventSourceComparer).ToArray())
            {
                var updatedSource = updatedEventSources.Single(s => s.Name == currentSource.Name);
                if (updatedSource.Level != currentSource.Level ||
                    updatedSource.MatchAnyKeyword != currentSource.MatchAnyKeyword)
                {
                    TraceEventUtil.EnableProvider(this.session, updatedSource.EventSourceId, updatedSource.Level, updatedSource.MatchAnyKeyword, sendManifest: false);
                    currentSource.Level = updatedSource.Level;
                    currentSource.MatchAnyKeyword = updatedSource.MatchAnyKeyword;
                }
            }

            // new sources
            foreach (var newSource in updatedEventSources.Except(this.eventSources, eventSourceComparer).ToArray())
            {
                TraceEventUtil.EnableProvider(this.session, newSource.EventSourceId, newSource.Level, newSource.MatchAnyKeyword, sendManifest: true);
                this.eventSources.Add(newSource);
            }

            // removed sources
            foreach (var removedSource in this.eventSources.Except(updatedEventSources, eventSourceComparer).ToArray())
            {
                this.session.DisableProvider(removedSource.EventSourceId);
                this.eventSources.Remove(removedSource);
            }
        }

        private static string GatherBucklingLengthsCollection(IEnumerable<BucklingLength> BucklingLengths)
        {
            StringBuilder output = new StringBuilder();
            IEnumerable<BucklingLength> verticalMembers;
            IEnumerable<BucklingLength> horizontalMembers;

            verticalMembers = BucklingLengths.Where(bl => bl.Member.Type == MEMBERTYPE.COLUMN || bl.Member.Type == MEMBERTYPE.POST).OrderBy(bl => bl.Member.StartNode.z).ThenBy(bl => bl.Member.StartNode.x).ThenBy(bl => bl.Member.StartNode.y);
            horizontalMembers = BucklingLengths.Except(verticalMembers).OrderBy(bl => bl.Member.StartNode.y).ThenBy(bl => bl.Member.StartNode.z).ThenBy(bl => bl.Member.StartNode.x);

            // Output Columns
            output.AppendLine("***");
            output.AppendLine("*** COLUMNS & POSTS");
            output.AppendLine("***");
            foreach (BucklingLength bl in verticalMembers)
                output.AppendLine(bl.ToSTAADString());
            // Output beams
            output.AppendLine("***");
            output.AppendLine("*** BEAMS & OTHERS");
            output.AppendLine("***");
            foreach (IGrouping<double, BucklingLength> bucklingLengthGroup in horizontalMembers.GroupBy(bl => bl.Member.StartNode.y))
            {
                output.AppendLine("***");
                output.AppendLine(string.Format("*** EL+{0:0.000}", bucklingLengthGroup.Key));
                output.AppendLine("***");
                foreach (BucklingLength bl in bucklingLengthGroup)
                    output.AppendLine(bl.ToSTAADString());
            }

            return output.ToString();
        }

        public string[] GetFilenamesNotInCache(IEnumerable<string> filenamesToCheck)
        {
            var filenamesInCache = ListFiles().Select(fi => fi.Name);
            var filenamesNotInCache = filenamesToCheck.Except(filenamesInCache);

            return filenamesNotInCache.ToArray();
        }