C# IEnumerable.OrderByDescending方法代码示例

        public async Task<IEnumerable<ParkingLot>> CreateList(IEnumerable<ParkingLot> items)
        {
            var mainVm = ServiceLocator.Current.GetInstance<MainViewModel>();
            var filter = mainVm.ParkingLotFilterMode;
            var orderAsc = mainVm.ParkingLotFilterAscending;
            var alphabeticalSortingFunc = new Func<ParkingLot, string>(x => x.Name);
            switch (filter)
            {
                case ParkingLotFilterMode.Alphabetically:
                    return orderAsc ? items.OrderBy(alphabeticalSortingFunc) : items.OrderByDescending(alphabeticalSortingFunc);
                case ParkingLotFilterMode.Availability:
                    var availabilitySortingFunc = new Func<ParkingLot, double>(x =>
                    {
                        if (x.TotalLots == 0)
                        {
                            return 2; //they're always last of the list
                        }
                        return 1 - ((double) x.FreeLots / (double)x.TotalLots); //something between 0 and 1
                    });
                    return orderAsc ? items.OrderBy(availabilitySortingFunc).ThenBy(alphabeticalSortingFunc) : items.OrderByDescending(availabilitySortingFunc).ThenBy(alphabeticalSortingFunc);
                case ParkingLotFilterMode.Distance:
                    var userPos = await ServiceLocator.Current.GetInstance<GeolocationService>().GetUserLocation();
                    if (userPos == null)
                    {
                        mainVm.ParkingLotFilterMode = ParkingLotFilterMode.Alphabetically;
                        return await CreateList(items);
                    }

                    var distanceSortingFunc = new Func<ParkingLot, double>(x => x?.Coordinates?.Point == null ? double.MaxValue : userPos.Coordinate.Point.GetDistanceTo(x.Coordinates.Point));
                    return orderAsc ? items.OrderBy(distanceSortingFunc).ThenBy(alphabeticalSortingFunc) : items.OrderByDescending(distanceSortingFunc).ThenBy(alphabeticalSortingFunc);
                default:
                    return orderAsc ? items.OrderBy(alphabeticalSortingFunc) : items.OrderByDescending(alphabeticalSortingFunc);
            }
        }

		private IEnumerable<IGrouping<string, RepositoryDetailedModel>> CreateGroupedItems(IEnumerable<RepositoryDetailedModel> model)
        {
            var order = Repositories.Filter.OrderBy;

            if (order == RepositoriesFilterModel.Order.LastUpdated)
            {
                var a = model.OrderByDescending(x => x.UtcLastUpdated).GroupBy(x => FilterGroup.IntegerCeilings.First(r => r > x.UtcLastUpdated.TotalDaysAgo()));
                a = Repositories.Filter.Ascending ? a.OrderBy(x => x.Key) : a.OrderByDescending(x => x.Key);
                return FilterGroup.CreateNumberedGroup(a, "Days Ago", "Updated");
            }
            if (order == RepositoriesFilterModel.Order.CreatedOn)
            {
                var a = model.OrderByDescending(x => x.UtcCreatedOn).GroupBy(x => FilterGroup.IntegerCeilings.First(r => r > x.UtcCreatedOn.TotalDaysAgo()));
                a = Repositories.Filter.Ascending ? a.OrderBy(x => x.Key) : a.OrderByDescending(x => x.Key);
                return FilterGroup.CreateNumberedGroup(a, "Days Ago", "Created");
            }
            if (order == RepositoriesFilterModel.Order.Owner)
            {
                var a = model.OrderBy(x => x.Name).GroupBy(x => x.Owner);
                a = Repositories.Filter.Ascending ? a.OrderBy(x => x.Key) : a.OrderByDescending(x => x.Key);
                return a.ToList();
            }

            return null;
        }

 //Check the Sort Order to sort with corresponding column
 public void CheckSortOrder(string sortOrder, ref IEnumerable<Comment> comment)
 {
     switch (sortOrder)
     {
         case "Date_desc":
             comment = comment.OrderByDescending(u => u.PostedDate);
             break;
         case "PatientName":
             comment = comment.OrderBy(u => u.Patient.FullName);
             break;
         case "PatientName_desc":
             comment = comment.OrderByDescending(u => u.Patient.FullName);
             break;
         case "DoctorName":
             comment = comment.OrderBy(u => u.Doctor.FullName);
             break;
         case "DoctorName_desc":
             comment = comment.OrderByDescending(u => u.Doctor.FullName);
             break;
         case "Content":
             comment = comment.OrderBy(u => u.Content);
             break;
         case "Content_desc":
             comment = comment.OrderByDescending(u => u.Content);
             break;
         default:
             comment = comment.OrderBy(u => u.PostedDate);
             break;
     }
 }

 IEnumerable<Product> SortProducts(IEnumerable<Product> products, string sortOrder)
 {
     switch (sortOrder)
     {
         case NAME:
             products = products.OrderByDescending(s => s.name);
             break;
         case MANUNAME:
             products = products.OrderBy(s => s.Manufacturer);
             break;
         case MFGDISCOUNT:
             products = products.OrderByDescending(s => s.Manufacturer.mfgDiscount);
             break;
         case PRICE:
             products = products.OrderByDescending(s => s.price);
             break;
         case VENDOR:
             products = products.OrderByDescending(s => s.vendor);
             break;
         default:
             products = products.OrderByDescending(s => s.productID);
             break;
     }
     return products;
 }

        public IPagedList<Facility> getList(string sortOrder, string currentFilter, int? page, IEnumerable<Facility> data)
        {
            ViewBag.CurrentSort = sortOrder;
            ViewBag.Name = String.IsNullOrEmpty(sortOrder) ? "Name_desc" : "";
            ViewBag.IsFree = sortOrder == "IsFree" ? "IsFree_desc" : "IsFree";
            ViewBag.Enabled = sortOrder == "Enabled" ? "Enabled_desc" : "Enabled";
            ViewBag.SO_RateTypeId = sortOrder == "RateTypeId" ? "RateTypeId_desc" : "RateTypeId";
            ViewBag.Rate = sortOrder == "Rate" ? "Rate_desc" : "Rate";
            ViewBag.IsGST = sortOrder == "IsGST" ? "IsGST_desc" : "IsGST";
            switch (sortOrder)
            {
                case "Name_desc":
                    data = data.OrderByDescending(s => s.Name );
                    break;
                case "IsFree":
                    data = data.OrderBy(s => s.IsFree);
                    break;
                case "IsFree_desc":
                    data = data.OrderByDescending(s => s.IsFree);
                    break;
                case "Enabled":
                    data = data.OrderBy(s => s.Enabled);
                    break;
                case "Enabled_desc":
                    data = data.OrderByDescending(s => s.Enabled);
                    break;
                case "RateTypeId":
                    data = data.OrderBy(s => s.RateTypeId);
                    break;
                case "RateTypeId_desc":
                    data = data.OrderByDescending(s => s.RateTypeId);
                    break;
                case "Rate":
                    data = data.OrderBy(s => s.Rate);
                    break;
                case "Rate_desc":
                    data = data.OrderByDescending(s => s.Rate);
                    break;
                case "IsGST":
                    data = data.OrderBy(s => s.IsGST);
                    break;
                case "IsGST_desc":
                    data = data.OrderByDescending(s => s.IsGST);
                    break;
                case "":
                default:
                    data = data.OrderBy(s => s.Name);
                    break;
            }

            int pageSize = Configurations.PageSize(); 
            int pageNumber = (page ?? 1);
            return data.ToPagedList(pageNumber, pageSize);
        }

        public _ContentFeedViewModel(IEnumerable<Content> content, Guid? authorId, string groupUrl, int contentPerPage = 5)
        {
            AuthorId = authorId;
            GroupUrl = groupUrl;

            if (authorId.HasValue)
                content = content.OrderByDescending(x => x.IsUserAttached(authorId.Value));
            if (!string.IsNullOrEmpty(groupUrl))
                content = content.OrderByDescending(x => x.IsGroupAttached(groupUrl));

            FeedContent = new PaginationList<_ContentFeed_ContentViewModel, Content>(content, contentPerPage, x => new _ContentFeed_ContentViewModel(x));
        }

        private IEnumerable<DataGridViewRow> _SortRowsByColumn(IEnumerable<DataGridViewRow> rows)
        {
            var get_row_mod_name = new Func<DataGridViewRow, string>(row => ((GUIMod) row.Tag).Name);
            Func<DataGridViewRow, string> sort_fn;

            // XXX: There should be a better way to identify checkbox columns than hardcoding their indices here
            if (this.m_Configuration.SortByColumnIndex < 2)
            {
                sort_fn = new Func<DataGridViewRow, string>(row =>
                {
                    var cell = row.Cells[this.m_Configuration.SortByColumnIndex];
                    if (cell.ValueType == typeof (bool))
                    {
                        return (bool) cell.Value ? "a" : "b";
                    }
                    // It's a "-" cell so let it be ordered last
                    return "c";
                });
            }
            else
            {
                sort_fn =
                    new Func<DataGridViewRow, string>(
                        row => row.Cells[this.m_Configuration.SortByColumnIndex].Value.ToString());
            }
            // Update the column sort glyph
            this.ModList.Columns[this.m_Configuration.SortByColumnIndex].HeaderCell.SortGlyphDirection =
                this.m_Configuration.SortDescending ? SortOrder.Descending : SortOrder.Ascending;
            // The columns will be sorted by mod name in addition to whatever the current sorting column is
            if (this.m_Configuration.SortDescending)
            {
                return rows.OrderByDescending(sort_fn).ThenBy(get_row_mod_name);
            }
            return rows.OrderBy(sort_fn).ThenBy(get_row_mod_name);
        }

        private static void DownloadVideo(IEnumerable<VideoInfo> videoInfos)
        {
            /*
             * Select the first .mp4 video with 360p resolution
             */
            VideoInfo video = videoInfos
                .OrderByDescending(v => v.Resolution).First(info => info.VideoType == VideoType.Mp4);

            /*
             * If the video has a decrypted signature, decipher it
             */
            if(video.RequiresDecryption) {
                DownloadUrlResolver.DecryptDownloadUrl(video);
            }

            /*
             * Create the video downloader.
             * The first argument is the video to download.
             * The second argument is the path to save the video file.
             */
            var videoDownloader = new VideoDownloader(video,
                Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
                RemoveIllegalPathCharacters(video.Title) + video.VideoExtension));

            // Register the ProgressChanged event and print the current progress
            videoDownloader.DownloadProgressChanged += (sender, args) => Console.WriteLine(args.ProgressPercentage);

            /*
             * Execute the video downloader.
             * For GUI applications note, that this method runs synchronously.
             */
            videoDownloader.Execute();
        }

 public Wechselgeld BerechneWechselgeld(IEnumerable<Münze> verfügbareMünzen, Cents betrag)
 {
     var münzen = verfügbareMünzen.OrderByDescending(i => i).ToArray();
     var lösung = LöseRekursiv(münzen, 0, betrag);
     if (lösung == null) throw new Exception("keine Lösung gefunden");
     return lösung.Item2;
 }

        IPackageInfo PackageInfo(IEnumerable<IPackageInfo> packageInfos)
        {
            if (Version != null)
                return packageInfos.OrderByDescending(x => x.Version).FirstOrDefault(x => x.Version.Major.Equals(Version.Major) && x.Version.Major.Equals(Version.Major));

            return packageInfos.Last();
        }

 public MicroDataProcessor(IEnumerable<MicroDataEntry> microDataEntries)
 {
     if (microDataEntries != null)
     {
         _microDataEntries = microDataEntries.OrderByDescending(o => o.ContentType.GetValueOrDefault(Guid.Empty));
     }
 }

 public Wechselgeld BerechneWechselgeld(IEnumerable<Münze> verfügbareMünzen, Cents betrag)
 {
     var münzen = verfügbareMünzen.OrderByDescending(i => i);
     var initial = Tuple.Create((Wechselgeld) new AnzahlMünzePaar[] {}, betrag);
     var gewählteMünzen = münzen.Aggregate(initial, AusgabeUndRestbetragFürMünze);
     return gewählteMünzen.Item1;
 }

 private static List<NewsItem> SortNews(IEnumerable<NewsItem> items)
 {
     //Order by NewsByYear node, then by publish or create date
     return items.OrderByDescending(i => i.Parent<NewsByYear>().Name)
             .ThenByDescending(i => i.PublishDate != default(DateTime) ? i.PublishDate : i.CreateDate)
             .ToList();
 }

        public IEnumerable<IPackage> GetUpdates(IEnumerable<IPackage> packages, bool includePrerelease, bool includeAllVersions, IEnumerable<System.Runtime.Versioning.FrameworkName> targetFrameworks, IEnumerable<IVersionSpec> versionConstraints)
        {
            // only keep the latest version of each package Id to mimic the behavior of nuget.org GetUpdates() service method
            packages = packages.OrderByDescending(p => p.Version).Distinct(PackageEqualityComparer.Id);

            return this.GetUpdatesCore(packages, includePrerelease, includeAllVersions, targetFrameworks, versionConstraints);
        }

 public override IEnumerable<IUnit> PickNextTargets(IEnumerable<IUnit> candidateTargets)
 {
     ////-picks 3 targets with most health points.
     //// If there are several targets with equal health points, picks those with alphabetically first name.
     this.ValidateTargets(candidateTargets);
     return candidateTargets.OrderByDescending(t => t.HealthPoints).ThenBy(t => t.Name).Take(3).ToList();
 }