C# IOrderedEnumerable.Select方法代码示例

        public DisplayPackageViewModel(Package package, IOrderedEnumerable<Package> packageHistory, bool isVersionHistory)
            : base(package)
        {
            Copyright = package.Copyright;

            if (!isVersionHistory)
            {
                Dependencies = new DependencySetsViewModel(package.Dependencies);
                PackageVersions = packageHistory.Select(p => new DisplayPackageViewModel(p, packageHistory, isVersionHistory: true));
            }

            DownloadCount = package.DownloadCount;
            LastEdited = package.LastEdited;

            if (!isVersionHistory && packageHistory.Any())
            {
                // calculate the number of days since the package registration was created
                // round to the nearest integer, with a min value of 1
                // divide the total download count by this number
                TotalDaysSinceCreated = Convert.ToInt32(Math.Max(1, Math.Round((DateTime.UtcNow - packageHistory.Last().Created).TotalDays)));
                DownloadsPerDay = TotalDownloadCount / TotalDaysSinceCreated; // for the package
            }
            else
            {
                TotalDaysSinceCreated = 0;
                DownloadsPerDay = 0;
            }
        }

 internal BurrowsWheelerTransform(IOrderedEnumerable<int[]> transform)
 {
     var y = transform.Select(v => new { F = v[0], L = v[2], S = v[1] }).ToArray();
     sorted = y.Select(v => v.F).ToArray();
     bwt = y.Select(v => v.L).ToArray();
     suffix = y.Select(v => v.S).ToArray();
     index = suffix.Select((s, i) => new { S = s, I = i }).OrderBy(v => v.S).Select(v => v.I).ToArray();
 }

        private static void Print(IOrderedEnumerable<A> result)
        {
            var output = result.Select(a =>
                                           {
                                               Console.WriteLine(a.S);
                                               return a.S;
                                           });

        }

        public string MeansOfTransportAsString(IOrderedEnumerable<TransportMethod> meansOfTransport)
        {
            if (meansOfTransport == null || !meansOfTransport.Any())
            {
                return string.Empty;
            }

            return string.Join("-", meansOfTransport.Select(m => EnumHelper.GetShortName(m)));
        }

            public FromComprenoModel AddLinkedChain(Compreno.SentenceElement master, IOrderedEnumerable<Compreno.SentenceElement> dependantWords)
            {
                var linkedChain = new LinkedChain();
                linkedChain.Master.Words.Add(_toSentenceWord(master));
                linkedChain.Dependent.Words.AddRange(dependantWords.Select(_toSentenceWord));

                _comparisonSentence.LinkedChains.Add(linkedChain);

                return this;
            }

            public FromComprenoModel AddSimpleSentence(IOrderedEnumerable<Compreno.SentenceElement> words)
            {
                var simpleSentece = new SimpleSentence();

                simpleSentece.Words.AddRange(words.Select(_toSentenceWord));

                _comparisonSentence.SimpleSentences.Add(simpleSentece);

                return this;
            }

 private static void CheckFirstMainWrite(IOrderedEnumerable<KeyValuePair<string, string>> data)
 {
     if (firstMainWrite && _mainLogger.IsInfoEnabled)
     {
         lock (firstMainWriteLock)
         {
             if (firstMainWrite)
             {
                 _mainLogger.Info(string.Join(";", data.Select(kvp => kvp.Key).ToArray()));
                 firstMainWrite = false;
             }
         }
     }
 }

 /// <summary>
 /// Pairs the players against each other in swiss format, e.g. top player plays
 /// against the second, third against the fourth and so on. Avoids creating the 
 /// same pairing twice. See the PairingAlgorithm.txt document for details.
 /// </summary>
 public IEnumerable<Pairing> Swiss(IOrderedEnumerable<KeyValuePair<Player, int>> standings, IList<Pairing> history)
 {
     ValidatePlayerCount(standings.Select(i => i.Key));
     var players = standings.OrderByDescending(i => i.Value).Select(i => i.Key).ToList();
     var pairings = new Stack<Pairing>();
     var timer = Stopwatch.StartNew();
     while (!AllPlayersPaired(pairings, players))
     {
         TryAddPairing(pairings, players, history);
         if (timer.ElapsedMilliseconds > SwissTimeout)
         {
             throw new TimeoutException("The requested operation took too long to complete.");
         }
     }
     return pairings.ToArray().Reverse();
 }

 private MatchStats[] GetMatchStats(IOrderedEnumerable<MatchScore> orderedMatches)
 {
     IEnumerable<MatchStats> matchStats = orderedMatches.Select(x => x.MatchStats);
     MatchStats[] matchStatsArray = matchStats.ToArray();
     return matchStatsArray;
 }

 public static ActivitiesViewModel Create(ActivityQuery query, IOrderedEnumerable<Application> applications)
 {
     var model = Mapper.Map<ActivitiesViewModel>(query);
     var list = new List<SelectListItem>
                    {
                        new SelectListItem
                            {
                                Selected = query.ApplicationId == null,
                                Text = String.Empty,
                                Value = null
                            }
                    };
     list.AddRange(applications.Select(x => Create(query, x)));
     model.Applications = list;
     return model;
 }

        private void LoadInfo()
        {
            if (_selectedType != _loadedInfoForType) {
                _collection =
                    typeof(GameState).GetMethod("FetchAll")
                    .MakeGenericMethod(_selectedType)
                    .Invoke(null, new object[] { false }) as IList;

                _props = _selectedType.GetProperties().OrderBy(prop => prop.Name);
                _headers = _props.Select(prop => {
                    var header = new TableHeader { Label = prop.Name, Width = 100 };
                    switch (header.Label) {
                        case "_Id":
                            header.Label = "ID";
                            header.Width = 23;
                            break;
                        case "_EditorId":
                            header.Label = "Editor ID";
                            break;
                    }
                    return header;
                }).ToArray();
                _loadedInfoForType = _selectedType;
            }
        }

		private static OrderLine OrderProduct(int productId, IOrderedEnumerable<int> variants, int itemCount, OrderInfo order)
		{
			var currentLocalization = StoreHelper.CurrentLocalization;
			var productService = IO.Container.Resolve<IProductService>();
			var productInfo = productService.CreateProductInfoByProductId(productId, order, currentLocalization, itemCount);
			if (variants != null && variants.Any())
			{
				var productVariantService = IO.Container.Resolve<IProductVariantService>();
				var variantClasses = variants.Select(variant => productVariantService.GetById(variant, currentLocalization)).Where(variant => variant != null).GroupBy(a => a.Group).Select(g => g.FirstOrDefault()).Where(variant => variant != null);

				productInfo.ProductVariants = variantClasses.Select(variant => new ProductVariantInfo(variant, productInfo, itemCount)).ToList();
			}
			return new OrderLine(productInfo, order);
		}

 public HighChart ParseToHighChart(IOrderedEnumerable<ScoreList> source)
 {
     var hiChart = new HighChart();
     if(source.Any())
     {
         hiChart.Name = source.First().Title;
         hiChart.Data = source.Select(s => ParseDateAndNumber(s.Date, s.Popular)).ToList();
     }
     return hiChart;
 }

 private static void CheckFirstObjectWrite(IOrderedEnumerable<KeyValuePair<string, string>> data)
 {
     if (firstObjectWrite)
     {
         lock (firstObjectWriteLock)
         {
             if (firstObjectWrite)
             {
                 _objectsLogger.Info("name;" + string.Join(";", data.Select(kvp => kvp.Key).ToArray()));
                 firstObjectWrite = false;
             }
         }
     }
 }

 /// <summary>
 /// Create the display model from the parameter model.
 /// </summary>
 /// <param name="parameterModel">The parameters in the model</param>
 /// <returns>An observable collection of the parameters using the display model</returns>
 internal static ObservableCollection<ParameterDisplayModel> CreateParameters(IOrderedEnumerable<ParameterModel> parameterModel)
 {
     return new ObservableCollection<ParameterDisplayModel>(parameterModel.Select(p => new ParameterDisplayModel(p)));
 }