C# IGrouping.Select方法代码示例

        private static IEnumerable<KeyValuePair<IndexedName, RealNode>> ReduceGroup(
			IEnumerable<KeyValuePair<IndexedName, RealNode>> aggr, IGrouping<XName, RealNode> items)
        {
            var addition = items.Select((elem, i) =>
                new KeyValuePair<IndexedName, RealNode>(new IndexedName(items.Key, i), elem));
            return aggr.Concat(addition);
        }

        /// <summary>
        /// Exports the masteries.
        /// </summary>
        /// <param name="typeMasteries">The type masteries.</param>
        /// <returns></returns>
        private static IEnumerable<SerializableMastery> ExportMasteries(IGrouping<int, DgmTypeMasteries> typeMasteries)
        {
            List<SerializableMastery> listOfMasteries = new List<SerializableMastery>();

            foreach (DgmMasteries typeMastery in typeMasteries.Select(x => Database.DgmMasteriesTable[x.MasteryID]))
            {
                Util.UpdatePercentDone(Database.MasteriesTotalCount);

                int grade = typeMastery.Grade + 1;

                SerializableMastery mastery;
                if (listOfMasteries.All(x=> x.Grade != grade))
                {
                    mastery = new SerializableMastery { Grade = grade };
                    listOfMasteries.Add(mastery);
                }
                else
                    mastery = listOfMasteries.First(x => x.Grade == grade);

                SerializableMasteryCertificate masteryCertificate = new SerializableMasteryCertificate
                {
                    ID = typeMastery.CertificateID,
                    ClassName =
                        Database.CrtClassesTable[Database.CrtCertificatesTable[typeMastery.CertificateID].ClassID].ClassName
                };

                mastery.Certificates.Add(masteryCertificate);
            }

            return listOfMasteries;
        }

 public static string FormatCanonicalizedValues(IGrouping<string, string> headerOrParameter)
 {
     return headerOrParameter.Key.ToLowerInvariant() + ":" +
         String.Join(",", headerOrParameter
             .Select(value => value.TrimStart().Replace("\r\n", String.Empty))
             .OrderBy(value => value, StringComparer.OrdinalIgnoreCase));
 }

 public GroupedOrderTagViewModel(Order selectedItem, IGrouping<string, OrderTagGroup> orderTagGroups)
 {
     Name = orderTagGroups.Key;
     OrderTags = orderTagGroups.Select(x => new GroupedOrderTagButtonViewModel(selectedItem, x)).ToList();
     ColumnCount = orderTagGroups.First().ColumnCount;
     ButtonHeight = orderTagGroups.First().ButtonHeight;
 }

        protected virtual ResourceVirtualDirectory CreateVirtualDirectory(IGrouping<string, string[]> subResources)
        {
            var remainingResourceNames = subResources.Select(g => g[1]);
            var subDir = new ResourceVirtualDirectory(
                VirtualPathProvider, this, backingAssembly, subResources.Key, remainingResourceNames);

            return subDir;
        }

        private HtmlButtonGroup( HtmlForm form, IGrouping<string, IHtmlElement> inputGroup )
        {
            _form = form;

              name = inputGroup.Key;

              items = inputGroup.Select( e => new HtmlInputItem( this, e ) ).ToArray();
        }

 public MenuItemGroupedPropertyViewModel(TicketItemViewModel selectedItem, IGrouping<string, MenuItemPropertyGroup> menuItemPropertyGroups)
 {
     Name = menuItemPropertyGroups.Key;
     Properties = menuItemPropertyGroups.Select(x => new MenuItemGroupedPropertyItemViewModel(selectedItem, x)).ToList();
     ColumnCount = menuItemPropertyGroups.First().ColumnCount;
     ButtonHeight = menuItemPropertyGroups.First().ButtonHeight;
     TerminalButtonHeight = menuItemPropertyGroups.First().TerminalButtonHeight;
     TerminalColumnCount = menuItemPropertyGroups.First().TerminalColumnCount;
 }

		private DebuggerViewItem OnSelector(IGrouping<IHandler, Burden> lookup)
		{
			var handler = lookup.Key;
			var objects = lookup.Select(g => g.Instance).ToArray();
			var view = ComponentDebuggerView.BuildFor(handler);
			return new DebuggerViewItem(handler.GetComponentName(),
			                            "Count = " + objects.Length,
			                            new ReleasePolicyTrackedObjectsDebuggerViewItem(view, objects));
		}

 public HeroStatistic(IGrouping<string, Match> group)
 {
     Hero = group.Key;
     Matches = group.Count();
     Wins = group.Where(m => m.Win).Count();
     Losses = group.Where(m => m.Win == false).Count();
     WinRatio = Convert.ToInt32((double)Wins / (double)Matches * 100);
     TimePlayed = group.Select(g => g.Duration).Aggregate(TimeSpan.Zero, (subtotal, t) => subtotal.Add(t));
 }

 private static Api GetApi(IGrouping<string, SwaggerRouteData> @group)
 {
     return new Api
     {
         Path = @group.Key,
         Operations = @group
             .Select(d => d.ToOperation())
             .OrderBy(o => o.Method)
     };
 }        

        private MenuItemModel CreateMenuItemModel(IGrouping<string, HeaderNavigationDTO> menuGroup, bool isParentSelected, int? selectedHeaderId)
        {
            var headers = menuGroup.Select(m => CreateHeaderItemModel(m, selectedHeaderId, isParentSelected));

            return new MenuItemModel()
            {
                IsExpanded = isParentSelected && headers.Any(h => h.IsSelected),
                Name = menuGroup.Key,
                Headers = headers
            };
        }

        private ApiSpec GenerateApiSpec(IGrouping<string, ApiDescription> apiDescriptionGroup, ModelSpecMap modelSpecMap)
        {
            var operationSpecs = apiDescriptionGroup
                .Select(apiDesc => GenerateOperationSpec(apiDesc, modelSpecMap))
                .ToList();

            return new ApiSpec
            {
                Path = "/" + apiDescriptionGroup.Key.Split('?').First(),
                Operations = operationSpecs
            };
        }

        private ApiSpec CreateApiSpec(IGrouping<string, ApiDescription> apiDescriptionGroup, ModelSpecRegistrar modelSpecRegistrar)
        {
            var operationSpecs = apiDescriptionGroup
                .Select(apiDesc => _operationSpecGenerator.From(apiDesc, modelSpecRegistrar))
                .ToList();

            return new ApiSpec
            {
                Path = "/" + apiDescriptionGroup.Key.Split('?').First(),
                Operations = operationSpecs
            };
        }

        private Api CreateApi(IGrouping<string, ApiDescription> apiDescriptionGroup, OperationGenerator operationGenerator)
        {
            var operations = apiDescriptionGroup
                .Select(operationGenerator.ApiDescriptionToOperation)
                .OrderBy(op => op.Method)
                .ToList();

            return new Api
            {
                Path = "/" + apiDescriptionGroup.Key,
                Operations = operations
            };
        }

        private Api CreateApi(IGrouping<string, ApiDescription> apiDescriptionGroup, Dictionary<string, DataType> complexModels)
        {
            var operations = apiDescriptionGroup
                .Select(apiDesc => _operationGenerator.ApiDescriptionToOperation(apiDesc, complexModels))
                .OrderBy(op => op.Method)
                .ToList();

            return new Api
            {
                Path = "/" + apiDescriptionGroup.Key,
                Operations = operations
            };
        }