C# IReadOnlyCollection.OrderByDescending方法代码示例

        public IndexCollection(IReadOnlyCollection<Index> latest,
                                    IndexCollection previous,
                                    FileInfo info,
                                    Encoding encoding)
        {
            Info = info;
            Encoding = encoding;
            Count = latest.Select(idx => idx.LineCount).Sum();
            Indicies = latest.ToArray();
            Diff = Count - (previous?.Count ?? 0);
            
            //need to check whether
            if (previous == null)
            {
                ChangedReason = LinesChangedReason.Loaded;
                TailInfo = new TailInfo(latest.Max(idx => idx.End));
            }
            else
            {
                var mostRecent = latest.OrderByDescending(l => l.TimeStamp).First();
                ChangedReason = mostRecent.Type == IndexType.Tail
                                ? LinesChangedReason.Tailed
                                : LinesChangedReason.Paged;

             TailInfo = new TailInfo(previous.Indicies.Max(idx => idx.End));
            }
        }

        public FilteredPostVault(IReadOnlyCollection<PostViewModel> posts)
        {
            var now = DateTime.UtcNow;
            var timezone = TimeZoneInfo.FindSystemTimeZoneById("Central Standard Time");

            AllPosts = posts;

            ActivePosts =
                AllPosts
                    .OrderByDescending(x => x.PublishedAtCst)
                    .Where(x => now >= TimeZoneInfo.ConvertTimeToUtc(x.PublishedAtCst, timezone))
                    .ToList();

            FuturePosts = AllPosts.Except(ActivePosts).ToList();
        }

        protected ReflectorProvider(string component, Version version, IEnumerable<_Assembly> assemblies, string assemblyDirectory)
        {
            _component = component;
              _version = version;
              _assemblyDirectory = assemblyDirectory;

              _reflectorTypes = assemblies.SelectMany (a => a.GetExportedTypes()).Where (IsValidReflector).ToArray();

              if (!_reflectorTypes.Any())
            throw new ArgumentException ("There are no valid reflectors in the given assemblies", "assemblies");

              CheckAssemblyRequirements (
              _reflectorTypes.OrderByDescending (t => t.GetAttribute<ReflectorSupportAttribute>().MinVersion).First(),
              assemblyDirectory);
        }

        async Task<string[]> UpdateMultiple(IReadOnlyCollection<FileObjectMapping> objects,
            IReadOnlyCollection<Package> packages,
            IEnumerable<Uri> remotes) {
            if (!objects.Any()) {
                Repository.Log("No remote objects to resolve");
                return new string[0];
            }
            Repository.Log("Resolving {0} remote objects for {1} packages from {2} remotes, please be patient..",
                objects.Count(), packages.Count(), remotes.Count());

            var relObjects = objects.OrderByDescending(x => Tools.FileUtil.SizePrediction(x.FilePath))
                .Select(x => new FileFetchInfo(Repo.GetObjectSubPath(x), x.FilePath))
                .ToArray();

            StatusRepo.Reset(RepoStatus.Downloading, objects.Count());
            StatusRepo.ProcessSize(GetExistingObjects(objects, packages), Repo.ObjectsPath, GetPackedSize(packages));
            await Package.DownloadObjects(remotes, StatusRepo, relObjects, Repo.ObjectsPath).ConfigureAwait(false);
            Repo.ReAddObject(objects.Select(x => x.Checksum).ToArray());

            return relObjects.Select(x => x.FilePath).ToArray();
        }

 public StatsViewModel ComputeStats(IReadOnlyCollection<Report> userReports)
 {
     var vm = new StatsViewModel();
     var orderedReports = userReports
         .OrderByDescending(report => report.Timestamp)
         .ToList()
         .AsReadOnly();
     ComputeStatsForAllTime(orderedReports, vm);
     ComputeStatsForQuartal(orderedReports, vm);
     return vm;
 }

        async Task<string[]> UpdateMultiple(IReadOnlyCollection<Package.ObjectMap> objects,
            IReadOnlyCollection<Package> packages,
            IReadOnlyCollection<Uri> remotes) {
            if (!objects.Any()) {
                Repository.Log("No remote objects to resolve");
                return new string[0];
            }
            Repository.Log("Resolving {0} remote objects for {1} packages from {2} remotes, please be patient..",
                objects.Count, packages.Count, remotes.Count);

            var doneObjects = new ConcurrentBag<FileObjectMapping>();

            var relObjects = objects.OrderByDescending(x => Tools.FileUtil.SizePrediction(x.FO.FilePath))
                .Select(x => new FileFetchInfo(Repo.GetObjectSubPath(x.FO), x.FO.FilePath) {
                    ExistingPath = x.ExistingObject != null ? Repo.GetObjectSubPath(x.ExistingObject) : null,
                    OnComplete = () => doneObjects.Add(x.FO)
                })
                .ToArray();

            StatusRepo.Reset(RepoStatus.Downloading, objects.Count);
            StatusRepo.ProcessSize(GetExistingObjects(objects.Select(x => x.FO), packages), Repo.ObjectsPath,
                GetPackedSize(packages));
            try {
                await
                    Package.DownloadObjects(remotes, StatusRepo, relObjects, Repo.ObjectsPath).ConfigureAwait(false);
            } finally {
                Repo.ReAddObject(doneObjects.Select(x => x.Checksum).ToArray());
            }

            return relObjects.Select(x => x.FilePath).ToArray();
        }