C# IReadOnlyList.All方法代码示例

        public static List<TimerInfo> GetTimersForSeries(SeriesTimerInfo seriesTimer, IEnumerable<ProgramInfo> epgData, IReadOnlyList<RecordingInfo> currentRecordings, ILogger logger)
        {
            List<TimerInfo> timers = new List<TimerInfo>();

            // Filtered Per Show
            var filteredEpg = epgData.Where(epg => epg.Id.Substring(0, 10) == seriesTimer.Id); 

            if (!seriesTimer.RecordAnyTime)
            {
                filteredEpg = filteredEpg.Where(epg => (seriesTimer.StartDate.TimeOfDay == epg.StartDate.TimeOfDay));
            }

            if (seriesTimer.RecordNewOnly)
            {
                filteredEpg = filteredEpg.Where(epg => !epg.IsRepeat); //Filtered by New only
            }

            if (!seriesTimer.RecordAnyChannel)
            {
                filteredEpg = filteredEpg.Where(epg => string.Equals(epg.ChannelId, seriesTimer.ChannelId, StringComparison.OrdinalIgnoreCase));
            }

            filteredEpg = filteredEpg.Where(epg => seriesTimer.Days.Contains(epg.StartDate.DayOfWeek)); 
         
            filteredEpg = filteredEpg.Where(epg => currentRecordings.All(r => r.Id.Substring(0, 14) != epg.Id.Substring(0, 14))); //filtered recordings already running
            
            filteredEpg = filteredEpg.GroupBy(epg => epg.Id.Substring(0, 14)).Select(g => g.First()).ToList();

            foreach (var epg in filteredEpg)
            {
                timers.Add(CreateTimer(epg, seriesTimer));
            }

            return timers;
        }

        public static bool CanSynchronize(IReadOnlyList<Ticker> tickers, ISimulationSettings settings, out string error)
        {
            if (tickers == null) throw new ArgumentNullException("tickers");
            if (settings == null) throw new ArgumentNullException("settings");

            if (tickers.Count == 0)
            {
                error = "There must be least one ticker.";
                return false;
            }

            if (tickers.Select(t => t.Name.ToLowerInvariant()).GroupBy(name => name).Count() < tickers.Count)
            {
                error = "Ticker names must be unique.";
                return false;
            }

            if (settings.Get<SimulationRangeSetting>().Type == SimulationRangeType.Common &&
                tickers.Select(t => t.From).Max() > tickers.Select(t => t.To).Min())
            {
                error = "Tickers do not have common range.";
                return false;
            }

            if (settings.Get<CommissionSetting>().Value < 0)
            {
                error = "Commission cannot be negative.";
                return false;
            }

            if (settings.Get<CommissionSetting>().Type == CommissionType.Percent &&
                settings.Get<CommissionSetting>().Value >= 100)
            {
                error = "Commission of percentage type must be smaller than 100 %.";
                return false;
            }

            if (settings.Get<SimulationRangeSetting>().Type == SimulationRangeType.FromToDates &&
                settings.Get<SimulationRangeSetting>().From > settings.Get<SimulationRangeSetting>().To)
            {
                error = "Simulation range is invalid.";
                return false;
            }

            if (settings.Get<InitialEquitySetting>().Value < 1)
            {
                error = "Initial equity cannot be smaller than 1.";
                return false;
            }

            if (settings.Get<SimulationRangeSetting>().Type == SimulationRangeType.FromToDates &&
                tickers.All(t => t.From > settings.Get<SimulationRangeSetting>().To || t.To < settings.Get<SimulationRangeSetting>().From))
            {
                error = "No quotes matching specified simulation time range.";
                return false;
            }

            error = null;
            return true;
        }

        public PersistenceRequest(Stream stream, int expectedStreamSequence, IReadOnlyList<UnpersistedEvent> events)
            : this(events)
        {
            Argument.RequiresNotNull(stream, nameof(stream));
            Argument.Requires(expectedStreamSequence >= 0 || expectedStreamSequence == ExpectedSequence.Any, nameof(expectedStreamSequence));
            Argument.Requires(events.All(e => e.Stream.Equals(stream)), nameof(events), $"All events must belong to the stream '{stream}'");

            this.Stream = stream;
            this.ExpectedStreamSequence = expectedStreamSequence;
            this.Events = events;
        }

        private void SetupWallSideActuators(IEnumerable<GrabableItemData> items, IReadOnlyList<ActuatorItemData> actuators)
        {
            if (actuators.Any())
            {
                CurrentGrabableItems = items;

                var factory = parser.TryMatchFactory(actuators, items.Any());
                if (factory != null)
                {
                    CurrentTile.SubItems.Add(factory.CreateItem(builder, CurrentTile, actuators));
                }
                else
                {
                    if(actuators.All(x => x.ActuatorType != 5 && x.ActuatorType != 6))
                    {
                        foreach (var i in actuators)
                        {
                            Point? absolutePosition = null;
                            if (i.ActionLocation is RemoteTarget)
                                absolutePosition = ((RemoteTarget) i.ActionLocation).Position.Position.ToAbsolutePosition(builder.CurrentMap);

                            CurrentTile.SubItems.Add(new Actuator(builder.GetWallPosition(i.TilePosition, CurrentTile), $"{absolutePosition} {i.DumpString()}"));
                        }
                    }
                    else
                    {
                        
                    }
                }
            }
        }

            private void AugmentCompletionsBasedOnLinesBefore(IReadOnlyList<RobotsTxtLineSyntax> before, IList<Completion> completions)
            {
                // first line
                if (!before.Any())
                {
                    completions.Add(ToCompletion("User-agent"));
                }

                // right after User-agent
                else if (before.All(l => l.NameToken.Value.Equals("User-agent", StringComparison.InvariantCultureIgnoreCase)))
                {
                    completions.Add(ToCompletion("User-agent"));
                    completions.Add(ToCompletion("Allow"));
                    completions.Add(ToCompletion("Disallow"));
                    completions.Add(ToCompletion("Sitemap"));
                    completions.Add(ToCompletion("Host"));
                    completions.Add(ToCompletion("Crawl-delay"));
                }

                // any other case
                else
                {
                    completions.Add(ToCompletion("Allow"));
                    completions.Add(ToCompletion("Disallow"));
                    completions.Add(ToCompletion("Sitemap"));

                    if (!before.Any(l => l.NameToken.Value.Equals("Host", StringComparison.InvariantCultureIgnoreCase)))
                        completions.Add(ToCompletion("Host"));

                    if (!before.Any(l => l.NameToken.Value.Equals("Crawl-delay", StringComparison.InvariantCultureIgnoreCase)))
                        completions.Add(ToCompletion("Crawl-delay"));
                }
            }

        public IReadOnlyList<IRange> Search(string currentText, IReadOnlyList<IRange> ranges)
        {
            Contract.Requires(currentText != null);
            Contract.Requires(ranges != null);
            Contract.Requires(ranges.All(range => range != null));

            if (Strategy == LookupStrategy.NONE || ranges.Count == 0 || currentText.Equals(OriginalText))
            {
                return ranges;
            }

            var regexSearchStr = new StringBuilder();

            var offset = 0;
            for(var i = 0;i < ranges.Count ; i++)
            {
                var range = ranges[i];
                var surface = OriginalText.Substring(range.Start, range.Length);

                if (offset != range.Start)
                {
                    if (range.Start - offset > 1)
                    {
                        regexSearchStr.Append(".*?");
                    }
                    regexSearchStr.Append("(?:");
                    regexSearchStr.Append(Regex.Escape(OriginalText.Substring(range.Start-1,1)));
                    if(offset == 0) {
                        regexSearchStr.Append("|\\A");
                    }
                    regexSearchStr.Append(")");
                }
                offset = range.End;

                regexSearchStr.Append("(" + Regex.Escape(surface) + ")");
            }

            Regex regex = new Regex(regexSearchStr.ToString(), RegexOptions.Multiline);

            var searchTextRange = OriginalText.Substring(0, Math.Min(OriginalText.Length, ranges[ranges.Count -1].End+1));
            var matchesBefore = regex.Matches(searchTextRange).Count;

            //Contract.Assert(matchesBefore >= 1);

            var currentMatches = regex.Matches(currentText);

            List<IRange> result = new List<IRange>();
            {
                var i = 0;
                foreach(System.Text.RegularExpressions.Match match in currentMatches){
                    i++;
                    if(i == Math.Min(matchesBefore, currentMatches.Count))
                    {
                        Contract.Assert(match.Groups.Count -1 == ranges.Count);
                        var r = -1;
                        foreach (Group group in match.Groups)
                        {
                            r++;
                            if (r == 0)
                            {
                                continue;
                            }
                            var range = ranges[r -1];
                            Contract.Assert(OriginalText.Substring(range.Start,range.Length).Equals(group.Value));

                            result.Add(new Range(group.Index, group.Index + group.Length));
                        }
                    }
                }
            }

            return result;
        }