C# IReadOnlyCollection.SelectMany方法代码示例

        public static ObservableViewModel CombineViewModels(IViewModelServiceProvider serviceProvider, ModelContainer modelContainer, IReadOnlyCollection<ObservableViewModel> viewModels)
        {
            if (viewModels == null) throw new ArgumentNullException("viewModels");
            var combinedViewModel = new ObservableViewModel(serviceProvider, modelContainer, viewModels.SelectMany(x => x.Dirtiables));

            var rootNodes = new List<ObservableModelNode>();
            foreach (var viewModel in viewModels)
            {
                if (!(viewModel.RootNode is SingleObservableNode))
                    throw new ArgumentException(@"The view models to combine must contains SingleObservableNode.", "viewModels");

                viewModel.parent = combinedViewModel;
                var rootNode = (ObservableModelNode)viewModel.RootNode;
                rootNodes.Add(rootNode);
            }

            if (rootNodes.Count < 2)
                throw new ArgumentException(@"Called CombineViewModels with a collection of view models that is either empty or containt just a single item.", "viewModels");

            // Find best match for the root node type
            var rootNodeType = rootNodes.First().Root.Type;
            if (rootNodes.Skip(1).Any(x => x.Type != rootNodeType))
                rootNodeType = typeof(object);

            CombinedObservableNode rootCombinedNode = CombinedObservableNode.Create(combinedViewModel, "Root", null, rootNodeType, rootNodes, null);
            combinedViewModel.Identifier = new ObservableViewModelIdentifier(rootNodes.Select(x => x.ModelGuid));
            rootCombinedNode.Initialize();
            combinedViewModel.RootNode = rootCombinedNode;
            return combinedViewModel;
        }

 private static IEnumerable<ArrangeMetadataElement.ContextStateFeature> GetContextFeatures(IReadOnlyCollection<TestCaseMetadataElement> testCaseMetadataElements)
 {
     return testCaseMetadataElements.SelectMany(x => x.Arrange.Features.OfType<ArrangeMetadataElement.ContextStateFeature>())
                                    .Union(testCaseMetadataElements.SelectMany(x => x.Act.Features.OfType<ArrangeMetadataElement.ContextStateFeature>()));
 }

        public static IReadOnlyCollection<int> ExtractValues(IReadOnlyCollection<Cell> cells)
        {
            var output = cells.SelectMany(cell => cell.PotentialValues).Distinct().ToList();

            return new ReadOnlyCollection<int>(output);
        }

        public static ICurve CreateBsplineCurve(IReadOnlyCollection<Vector4> controlPoints, IEnumerable knotVectorU, int order, bool isPeriodic, IModeler modeler)
        {
            var controlPointsList = controlPoints
                .SelectMany(p => new double[] {p.X, p.Y, p.Z, p.W}.ToArray())
                .ToArray();

            var dimensionControlPoints = BitConverter.GetBytes(4);
            var orderBytes = BitConverter.GetBytes((int) order);
            var numControlPointsBytes = BitConverter.GetBytes((int) controlPoints.Count);

            var periodicity = BitConverter.GetBytes(isPeriodic ? 1 : 0);

            var props = new[]
            {
                BitConverter.ToDouble(dimensionControlPoints.Concat(orderBytes).ToArray(), 0),
                BitConverter.ToDouble(numControlPointsBytes.Concat(periodicity).ToArray(), 0)
            };

            return (Curve) modeler.CreateBsplineCurve(props, knotVectorU, controlPointsList);
        }

        public static async Task<IReadOnlyList<Contribution>> Get(
            IReadOnlyCollection<CommitterGroup> committerGroups, IIssueService issueService)
        {
            Guard.AgainstNullArgument(nameof(committerGroups), committerGroups);
            Guard.AgainstNullArgument(nameof(issueService), issueService);

            return
                (await Task.WhenAll(committerGroups.SelectMany(group => @group.RepositoryList.Select(id =>
                {
                    log.InfoFormat("Getting issues for {@Repository}...", id);
                    return issueService.Get(id.Owner, id.Name).ContinueWith(task =>
                    {
                        if (task.Exception != null)
                        {
                            log.ErrorException("Failed to get issues for {@Repository}.", task.Exception.InnerException, id);
                            return Enumerable.Empty<Issue>();
                        }

                        log.InfoFormat("Got issues for {@Repository}.", id);
                        return task.Result;
                    });
                }))))
                .SelectMany(_ => _)
                .Select(issue => new { issue.Repository, Login = issue.Creator, issue.Created.LocalDateTime })
                .Distinct()
                .GroupBy(contribution => new
                {
                    Group = committerGroups.First(group => @group.RepositoryList.Contains(contribution.Repository)).Name,
                    contribution.Login
                })
                .Select(g => new Contribution(g.Key.Group, g.Key.Login, g.Sum(contribution => Score(contribution.LocalDateTime))))
                .ToList();
        }

        /// <summary>
        /// 重複した条件付き書式を抽出しリスト化する
        /// </summary>
        /// <param name="conditionFormatLsit">条件付き書式の定義一覧</param>
        /// <returns>削除対象の定義一覧</returns>
        private static IEnumerable<string> GetDoubleConditionFormatLsit(
            IReadOnlyCollection<ConditionFormat> conditionFormatLsit)
        {
            var combinations = conditionFormatLsit.SelectMany(
                (x, i) => conditionFormatLsit.Skip(i + 1).Select(y => new List<ConditionFormat> {x, y}));

            return
                combinations.Where(x => x[0].Sqref == x[1].Sqref && x[0].RuleList == x[1].RuleList)
                    .Select(x => x[1].FullText)
                    .Distinct()
                    .ToList();
        }

        public ActorRegistry(IReadOnlyCollection<Tuple<ActorDescriptor, IRingBuffer, ActorId>> actors)
        {
            if (actors.Count > ActorId.MaxValue)
            {
                throw new ArgumentException("To many actors");
            }

            var messageTypesOrdered = actors.Select(t => t.Item1)
                .SelectMany(d => d.HandledMessageTypes)
                .Distinct()
                .OrderBy(t => t.TypeHandle.Value.ToInt64())
                .ToArray();

            if (messageTypesOrdered.Length == 0)
            {
                throw new ArgumentException("The handled messages set is empty. This is a useless registry");
            }

            _messageTypeDiff = messageTypesOrdered.First().TypeHandle.Value.ToInt64() - 1;

            var ringsGroupedByMessageId = actors.SelectMany(
                t =>
                    t.Item1.HandledMessageTypes.Select(
                        messageType => new {MessageTypeId = GetMessageTypeId(messageType), Buffer = t.Item2}))
                .GroupBy(a => a.MessageTypeId)
                .ToArray();

            var buffers = new List<IRingBuffer>();
            AddPadding(buffers);

            var count = ringsGroupedByMessageId.Length;
            var keys = new int[count];
            var values = new Tuple<int, int>[count];
            var index = 0;

            foreach (var g in ringsGroupedByMessageId)
            {
                keys[index] = g.Key;
                var start = buffers.Count;
                buffers.AddRange(g.Select(tuple => tuple.Buffer));
                var end = buffers.Count;
                var length = end - start;

                values[index] = Tuple.Create(start, length);
                index += 1;
            }

            AddPadding(buffers);

            // create one table
            var bufferArray = buffers.ToArray();
            var valuesArray =
                values.Select(tuple => new ArraySegment<IRingBuffer>(bufferArray, tuple.Item1, tuple.Item2)).ToArray();

            _messageTypeToBuffers = new IntLookup<ArraySegment<IRingBuffer>>(keys, valuesArray);

            // by actor
            var max = actors.Max(t => t.Item3.Value);
            _buffersByActor = new IRingBuffer[max + 1];

            foreach (var actor in actors)
            {
                _buffersByActor[actor.Item3.Value] = actor.Item2;
            }
        }

 public ShipPartViewModel(IReadOnlyCollection<ShipPart> parts)
 {
     _parts = parts;
     CommonFlags = new HashSet<string>(_parts.SelectMany(s => s.Flags));
 }

 private Task FetchAllRequestedPackages(IReadOnlyCollection<SpecificVersion> specificVersions) {
     var i = 0;
     var totalCount = specificVersions.Count;
     var lObject = new object();
     var allRemotes =
         specificVersions.SelectMany(x => FindRemotesWithPackage(x.GetFullName())).Distinct().ToArray();
     return
         SyncEvilGlobal.DownloadHelper.DownloadFilesAsync(allRemotes, StatusRepo,
             specificVersions.ToDictionary(x => new FileFetchInfo("packages/" + x.GetFullName() + ".json"),
                 x =>
                     (ITransferStatus)
                     new Status(x.GetFullName(), StatusRepo) {
                         RealObject = "packages/" + x + ".json",
                         OnComplete =
                             () => {
                                 lock (lObject)
                                     Progress.PackageFetching.Update(null, (++i).ToProgress(totalCount));
                                 return TaskExt.Default;
                             }
                     }),
             Repo.RootPath);
 }

 Task SynchronizeCollections(IReadOnlyCollection<Game> games) {
     if (Common.Flags.Verbose)
         MainLog.Logger.Info($"Syncing collections for games: {string.Join(", ", games.Select(x => x.Id))}");
     return
         _networkContentSyncer.SyncCollections(games.SelectMany(x => x.SubscribedCollections).ToArray(), false);
 }