C# ICollection.OrderBy方法代码示例

 public OrderDetailViewModel(RequestDetail requestDetail, ICollection<StockInformation> stockInformations, ICollection<ApprovedDetail> approvedDetails, Forcasting forcasting, ConsumptionSetting consumptionSetting)
 {
     _requestDetail = requestDetail;
     _stockInformations = stockInformations;
     _approvedDetails = approvedDetails;
     _forcasting = forcasting;
     _consumptionSetting = consumptionSetting;
     _hasManyActivity = getActivityViewModels().Count > 2;
     _hasManyManufacturer = getManufacturerViewModels().Count > 2;
     _hasExpiryDatePreference = getExpiryDateViewModels().Count > 2;
     _hasPhysicalStorePreference = getPhysicalStoreViewModels().Count > 2;
     _allowAdd = _hasManyActivity || _hasManyManufacturer || _hasExpiryDatePreference || _hasPhysicalStorePreference;
     _allowRemove = RequestedQuantity == 0;
     if (_requestDetail.ActivityGroup == null)
     {
         var stockInformation = _stockInformations.OrderBy(s => s.ExpiryDate).FirstOrDefault();
         if (stockInformation != null)
         {
             _requestDetail.ActivityGroup = stockInformation.Activity;
         }
     }
     if (_requestDetail.IsFirstLoad)
     {
         if (_requestDetail.RequestedQuantity >= AvailableQuantity)
         {
             _requestDetail.ApprovedQuantity = AvailableQuantity;
         }
     }
 }

 public void ScheduleFlights(ICollection<FlightModel> flights)
 {
     foreach (var flight in flights.OrderBy(f => f.Arrives))
     {
         ScheduleFlight(flight);
     }
 }

        public Card GetCardWithSuitThatEnemyDoesNotHave(bool enemyHasATrumpCard, CardSuit trumpSuit, ICollection<Card> playerCards)
        {
            if (!enemyHasATrumpCard)
            {
                // In case the enemy does not have any trump cards and Stalker has a trump, he should throw a trump.
                var myTrumpCards = playerCards.Where(c => c.Suit == trumpSuit).ToList();
                if (myTrumpCards.Count() > 0)
                {
                    return myTrumpCards.OrderBy(c => c.GetValue()).LastOrDefault();
                }
            }

            var orderedCards = playerCards.OrderBy(c => c.GetValue());
            foreach (var card in orderedCards)
            {
                if (this.cardHolder.EnemyCards.All(c => c.Suit != card.Suit))
                {
                    if (enemyHasATrumpCard)
                    {
                        return playerCards.Where(c => c.Suit == card.Suit).OrderBy(c => c.GetValue()).FirstOrDefault();
                    }

                    return playerCards.Where(c => c.Suit == card.Suit).OrderByDescending(c => c.GetValue()).FirstOrDefault();
                }
            }

            return null;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="DefaultRuntimeElementInfoFactoryDispatcher" /> class.
        /// </summary>
        /// <param name="elementInfoExportFactories">The element information export factories.</param>
        protected DefaultRuntimeElementInfoFactoryDispatcher(ICollection<IExportFactory<IRuntimeElementInfoFactory, RuntimeElementInfoFactoryMetadata>> elementInfoExportFactories)
        {
            Contract.Requires(elementInfoExportFactories != null);

            this.elementInfoFactories = elementInfoExportFactories
                    .OrderBy(e => e.Metadata.ProcessingPriority)
                    .ToDictionary(e => e.CreateExport().Value, e => e.Metadata);
        }

 public VotingSystem(ICollection<Tag> tags)
 {
     int c = 0;
     this.tags = tags.OrderBy (x => x);
     foreach (Tag tag in this.tags) {
         dict.Add (tag, c);
         c++;
     }
     NumberOfTags = c;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="DefaultSerializationService"/> class.
        /// </summary>
        /// <param name="serializerFactories">The serializer factories.</param>
        public DefaultSerializationService(ICollection<IExportFactory<ISerializer, SerializerMetadata>> serializerFactories)
        {
            Contract.Requires(serializerFactories != null);

            foreach (var factory in serializerFactories.OrderBy(f => f.Metadata.OverridePriority))
            {
                if (!this.serializerFactories.ContainsKey(factory.Metadata.FormatType))
                {
                    this.serializerFactories.Add(factory.Metadata.FormatType, factory);
                }
            }
        }

 public static ICollection<Model.Node> OrderItemsByDistance(ICollection<Model.Node> nodes, Geopoint location) {
     if (nodes == null || location == null) {
         return nodes;
     }
     var point = Position.From(location);
     var elist = nodes.OrderBy(node => {
         double meters = Haversine.DistanceInMeters(point, new Position() { Latitude = node.lat, Longitude = node.lon });
         // update distance to show on map
         node.Distance = meters;
         return meters;
     });
     var list = elist.ToList();
     return list;
 }

        private static void PrintResults(TimeSpan totalTime, int parllelCount, ICollection<HttpResult> results)
        {
            var count = results.Count;
            var orderedResults = results.OrderBy(r => r.TimeTakenMs).ToList();

            Console.WriteLine("--------------------------------------------------");
            Console.WriteLine("Total time taken:    {0}", totalTime);
            Console.WriteLine("Total requests:      {0}", count);
            Console.WriteLine("Total errors:        {0}", results.Count(r => r.IsError));
            Console.WriteLine("Throughput QPS:      {0}", count/totalTime.TotalSeconds);
            Console.WriteLine("Parallel count:      {0}", parllelCount);
            Console.WriteLine("50th percentile:     {0}", orderedResults[(count * 10) / 20].TimeTakenMs);
            Console.WriteLine("85th percentile:     {0}", orderedResults[(count * 17) / 20].TimeTakenMs);
            Console.WriteLine("95th percentile:     {0}", orderedResults[(count * 19) / 20].TimeTakenMs);
            Console.WriteLine("--------------------------------------------------");
        }

 /// <summary>
 /// Resets strategy with new population of individuals.
 /// </summary>
 /// <param name="newPopulation">New population for strategy.</param>
 public void Set(ICollection<Individual> newPopulation)
 {
     if (newPopulation == null)
         throw new ArgumentException(nameof(newPopulation));
     if (newPopulation.Count == 0)
         throw new InvalidOperationException("Attempt to set empty population");
     var problem = newPopulation.First().Problem;
     var graph = newPopulation.First().Graph;
     if (newPopulation.Any(i => i.Graph != graph || i.Problem != problem))
         throw new AlgorithmException("Setting up new population", "Individuals in population represent either different graphs or different problems");
     _population = newPopulation;
     //In case is not SortedSet<T>
     if (!(_population is SortedSet<Individual>))
         _population = _population.OrderBy(p => p.SolutionFitness).ToList();
     InitializeRoulette();
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="DefaultRuntimeModelElementFactory" /> class.
        /// </summary>
        /// <param name="modelElementConstructors">The element information export factories.</param>
        /// <param name="modelElementConfigurators">The model element configurators.</param>
        public DefaultRuntimeModelElementFactory(
            ICollection<IExportFactory<IRuntimeModelElementConstructor, RuntimeModelElementConstructorMetadata>> modelElementConstructors,
            ICollection<IExportFactory<IRuntimeModelElementConfigurator, RuntimeModelElementConfiguratorMetadata>> modelElementConfigurators)
        {
            Contract.Requires(modelElementConstructors != null);

            this.modelElementConstructors = modelElementConstructors
                    .OrderBy(e => e.Metadata.ProcessingPriority)
                    .ToDictionary(e => e.CreateExport().Value, e => e.Metadata);

            this.modelElementConfigurators =
                (from cfg in modelElementConfigurators
                 group cfg by cfg.Metadata.RuntimeElementType
                 into cfgGroup select cfgGroup).ToDictionary(
                     g => g.Key.AsRuntimeTypeInfo(),
                     g => g.OrderBy(e => e.Metadata.ProcessingPriority).Select(e => e.CreateExport().Value).ToList());
        }

        internal static StressTrend CalculateTrend(ICollection<HealthReport> healthReports)
        {

            var healthReportsOrdered = healthReports.OrderBy(hr => hr.Time);

            var firstHealthReport = healthReportsOrdered.First();

            var lastHealthReport = healthReportsOrdered.Last();

            if (firstHealthReport.Stress > lastHealthReport.Stress + StressOffset)
            {
                return StressTrend.Down;
            }
            if (firstHealthReport.Stress < lastHealthReport.Stress - StressOffset)
            {
                return StressTrend.Up;
            }

            return StressTrend.Equal;

        }

        public ParsedFile(string filePath, string hash, ICollection<ParsedElement> elements)
        {
            #region Argument Check

            if (string.IsNullOrWhiteSpace(filePath))
            {
                throw new ArgumentException(
                    @"The value can be neither empty nor whitespace-only string nor null.",
                    nameof(filePath));
            }

            if (string.IsNullOrWhiteSpace(hash))
            {
                throw new ArgumentException(
                    @"The value can be neither empty nor whitespace-only string nor null.",
                    nameof(hash));
            }

            if (elements == null)
            {
                throw new ArgumentNullException(nameof(elements));
            }

            if (elements.Any(item => item == null))
            {
                throw new ArgumentException(@"The collection contains a null element.", nameof(elements));
            }

            #endregion

            FilePath = filePath;
            Hash = hash;

            Elements = elements
                .OrderBy(obj => obj.LineIndex)
                .ThenBy(obj => obj.GetType().FullName)
                .ToArray()
                .AsReadOnly();
        }

        /// <summary>
        ///     Map an virtual address to the raw file address.
        /// </summary>
        /// <param name="VA">Virtual Address</param>
        /// <param name="sh">Section Headers</param>
        /// <returns>Raw file address.</returns>
        public static ulong VAtoFileMapping(this ulong VA, ICollection<IMAGE_SECTION_HEADER> sh)
        {
            VA -= 0x00400000;
            var sortedSt = sh.OrderBy(x => x.VirtualAddress).ToList();
            uint vOffset = 0, rOffset = 0;
            var secFound = false;
            for (var i = 0; i < sortedSt.Count - 1; i++)
            {
                if (sortedSt[i].VirtualAddress <= VA && sortedSt[i + 1].VirtualAddress > VA)
                {
                    vOffset = sortedSt[i].VirtualAddress;
                    rOffset = sortedSt[i].PointerToRawData;
                    secFound = true;
                    break;
                }
            }

            // try last section
            if (secFound == false)
            {
                if (VA >= sortedSt.Last().VirtualAddress &&
                    VA <= sortedSt.Last().VirtualSize + sortedSt.Last().VirtualAddress)
                {
                    vOffset = sortedSt.Last().VirtualAddress;
                    rOffset = sortedSt.Last().PointerToRawData;
                }
                else
                {
                    throw new Exception("Cannot find corresponding section.");
                }
            }

            return VA - vOffset + rOffset;
        }

        /// <summary>
        /// Formats the list of request parameters into string a according
        /// to the requirements of oauth. The resulting string could be used
        /// in the Authorization header of the request.
        /// </summary>
        ///
        /// <remarks>
        ///   <para>
        ///     See http://dev.twitter.com/pages/auth#intro  for some
        ///     background.  The output of this is not suitable for signing.
        ///   </para>
        ///   <para>
        ///     There are 2 formats for specifying the list of oauth
        ///     parameters in the oauth spec: one suitable for signing, and
        ///     the other suitable for use within Authorization HTTP Headers.
        ///     This method emits a string suitable for the latter.
        ///   </para>
        /// </remarks>
        ///
        /// <param name="parameters">The Dictionary of
        /// parameters. It need not be sorted.</param>
        ///
        /// <returns>a string representing the parameters</returns>
        private static string EncodeRequestParameters(ICollection<KeyValuePair<String, String>> p)
        {
            var sb = new System.Text.StringBuilder();
            foreach (KeyValuePair<String, String> item in p.OrderBy(x => x.Key))
            {
                if (!String.IsNullOrEmpty(item.Value) &&
                    !item.Key.EndsWith("secret"))
                    sb.AppendFormat("oauth_{0}=\"{1}\", ",
                                    item.Key,
                                    UrlEncode(item.Value));
            }

            return sb.ToString().TrimEnd(' ').TrimEnd(',');
        }

        private static string ReadTickets(ICollection<Ticket> tickets)
        {
            var result = string.Join(" ", tickets.OrderBy(t => t));

            return result;
        }