C# IGrouping.GroupBy方法代码示例

 private static DeptWiseAttendanceDTO CreateAttendanceDTO(IGrouping<int, ActivityLogDTO> grp, IEnumerable<Employee> allEmployees)
 {
     var deptMembers = allEmployees.Where(e => e.Deprtment.Id == grp.First().Department.Id);
     var dto = new DeptWiseAttendanceDTO
     {
         DepartmentName = grp.First().Department.Name,
         Attendance = grp.GroupBy(gd => gd.Employee.Id)
                         .Select(empGroup => new AttendanceDTO
                         {
                             EmployeeName = empGroup.First().Employee.Name,
                             EmployeeId = empGroup.First().Employee.Id,
                             Attended = true,
                             Date = empGroup.First().TimeStamp.ToString("yyyy-MM-dd")
                         })
                         .ToList()
     };
     var absents = deptMembers.Where(m => !dto.Attendance.Any(a => a.EmployeeId == m.Id));
     var date = dto.Attendance.First().Date;
     dto.Attendance.AddRange(absents.Select(a => new AttendanceDTO
                         {
                             EmployeeName = a.Name,
                             EmployeeId = a.Id,
                             Attended = false,
                             Date = date
                         }));
     return dto;
 }

 private static IEnumerable<IAutoCompleteListItem> parseClientGroup(IGrouping<ulong, Toggl.TogglAutocompleteView> c)
 {
     var projectItems = c.GroupBy(p => p.ProjectID).Select(parseProjectGroup);
     if (c.Key == 0)
         return projectItems;
     var clientName = c.First().ClientLabel;
     return new ClientCategory(clientName, projectItems.ToList()).Yield<IAutoCompleteListItem>();
 }

 public void Calc(IGrouping<string, SpecItem> itemGroup, SpecTable specTable)
 {
    // itemGroup - элементы одной группы.
    // Нужно сгруппировать по ключевому свойству
    var uniqRecs = itemGroup.GroupBy(m => m.Key).OrderBy(m => m.Key, new AcadLib.Comparers.AlphanumComparator());
    
    foreach (var urec in uniqRecs)
    {
       SpecRecord rec = new SpecRecord(urec.Key, urec.ToList(), specTable);
       Records.Add(rec);
    }
 }

        private static void WriteGroup(IGrouping<int, Packet> groups)
        {
            var groupDir = groups.GroupBy(p => p.Direction);
            foreach (var group in groupDir)
            {
                var fileName = Folder + "/" + Opcodes.GetOpcodeName(groups.Key, group.Key) + ".pkt";

                using (var fileStream = new FileStream(fileName, FileMode.Append, FileAccess.Write))
                    using (var writer = new BinaryWriter(fileStream, _encoding))
                        foreach (var packet in group)
                        {
                            writer.Write((ushort)packet.Opcode);
                            writer.Write((int)packet.Length);
                            writer.Write((byte)packet.Direction);
                            writer.Write((ulong)Utilities.GetUnixTimeFromDateTime(packet.Time));
                            writer.Write(packet.GetStream(0));
                        }
            }
        }

        private ApiDeclaration DescriptionGroupToApiDeclaration(IGrouping<string, ApiDescription> descriptionGroup)
        {
            var modelSpecsBuilder = new ModelSpecsBuilder();

            // Group further by relative path - each group corresponds to an ApiSpec
            var apiSpecs = descriptionGroup
                .GroupBy(ad => ad.RelativePath)
                .Select(dg => DescriptionGroupToApiSpec(dg, modelSpecsBuilder))
                .ToList();

            return new ApiDeclaration
                {
                    apiVersion = "1.0",
                    swaggerVersion = SwaggerVersion,
                    basePath = _basePathAccessor(),
                    resourcePath = descriptionGroup.Key,
                    apis = apiSpecs,
                    models = modelSpecsBuilder.Build()
                };
        }

        private ApiDeclaration CreateDeclaration(IGrouping<string, ApiDescription> apiDescriptionGroup)
        {
            var modelSpecRegistrar = new ModelSpecRegistrar();

            // Group further by relative path - each group corresponds to an ApiSpec
            var apiSpecs = apiDescriptionGroup
                .GroupBy(apiDesc => apiDesc.RelativePath)
                .Select(apiDescGrp => CreateApiSpec(apiDescGrp, modelSpecRegistrar))
                .ToList();

            return new ApiDeclaration
            {
                ApiVersion = "1.0",
                SwaggerVersion = SwaggerVersion,
                BasePath = _basePathResolver().TrimEnd('/'),
                ResourcePath = apiDescriptionGroup.Key,
                Apis = apiSpecs,
                Models = modelSpecRegistrar.ToDictionary()
            };
        }

        private static void WriteGroup(IGrouping<int, Packet> groups)
        {
            var groupDir = groups.GroupBy(p => p.Direction);
            foreach (var group in groupDir)
            {
                var fileName = "Fusion.pkt";

                using (var fileStream = new FileStream(fileName, FileMode.Append, FileAccess.Write))
                    using (var writer = new BinaryWriter(fileStream, _encoding))
                        foreach (var packet in group)
                        {
                            writer.Write((ushort)packet.Opcode);
                            writer.Write((int)packet.Length);
                            writer.Write((byte)packet.Direction);
                            writer.Write((ulong)Utilities.GetUnixTimeFromDateTime(packet.Time));
                            writer.Write(packet.GetStream(0));
                            // TODO: Add ConnIdx in a backwards compatible way
                        }
            }
        }

        private ApiDeclaration CreateDeclaration(IGrouping<string, ApiDescription> apiDescriptionGroup)
        {
            var complexModels = new Dictionary<string, DataType>();

            // Group further by relative path - each group corresponds to an Api
            var apis = apiDescriptionGroup
                .GroupBy(apiDesc => apiDesc.RelativePathSansQueryString())
                .Select(apiDescGrp => CreateApi(apiDescGrp, complexModels))
                .OrderBy(api => api.Path)
                .ToList();

            return new ApiDeclaration
            {
                SwaggerVersion = SwaggerVersion,
                ApiVersion = _apiVersion,
                BasePath = _basePath,
                ResourcePath = apiDescriptionGroup.Key,
                Apis = apis,
                Models = complexModels
            };
        }

        /// <summary>
        /// Assigns the severity and environment severity list.
        /// </summary>
        /// <param name="environment">The environment.</param>
        /// <param name="bugItem">The bug item.</param>
        private static void AssignSeverityAndEnvironmentSeverityList(IGrouping<byte?, ProjectPortalBugsBySeverityAndEnvironment> environment, EnvironmentBugList bugItem)
        {
            var severityGroupedBugList = environment.GroupBy(bugType => bugType.Severity);

            foreach (var severity in severityGroupedBugList)
            {
                SeverityBug severityItem = new SeverityBug();

                severityItem.WorkItemCount = severity.Sum(bugType => bugType.WorkItemCount) ?? 0;

                switch (severity.Key)
                {
                    case SeverityCritical:
                        bugItem.CriticalBug = severityItem;
                        break;

                    case SeverityHigh:
                        bugItem.HighBug = severityItem;
                        break;

                    case SeverityMedium:
                        bugItem.MediumBug = severityItem;
                        break;

                    case SeverityLow:
                        bugItem.LowBug = severityItem;
                        break;
                }
            }
        }

 private void ProcessBout(IGrouping<int, Jam> boutJamSet, IGrouping<int, PenaltyGroup> penaltyGroups, Dictionary<int, JamTimeEstimate> estimateMap)
 {
     // first, we do the approximations
     var periods = boutJamSet.GroupBy(j => j.IsFirstHalf);
     foreach (IEnumerable<Jam> jams in periods)
     {
         var jamIDs = jams.Select(j => j.ID);
         int totalSeconds = 1800;
         // we'll assume four clock stoppages per half, then add time in as necessary
         totalSeconds -= 30 * (jams.Count() - 5);
         int minTime = 0;
         int maxTime = 0;
         foreach (int jamID in jamIDs)
         {
             minTime += estimateMap[jamID].Minimum;
             maxTime += estimateMap[jamID].Maximum;
         }
         totalSeconds -= minTime;
         if (totalSeconds < 0)
         {
             // just assume the min time for everything
             foreach (Jam jam in jams)
             {
                 var jamLimit = estimateMap[jam.ID];
                 jamLimit.Estimate = jamLimit.Minimum;
             }
         }
         else
         {
             int difference = maxTime - minTime;
             double ratio = ((double)(totalSeconds)) / difference;
             if (ratio > 1.0)
             {
                 Console.WriteLine("Bout: " + jams.First().BoutID + " has a period that the maximums don't fill");
                 ratio = 1.0;
             }
             foreach (Jam jam in jams)
             {
                 var jamLimit = estimateMap[jam.ID];
                 jamLimit.Estimate = jamLimit.Minimum + (int)((jamLimit.Maximum - jamLimit.Minimum) * ratio);
             }
         }
     }
 }

        /// <summary>
        /// Assigns the severity and bug type severity list.
        /// </summary>
        /// <param name="bugType">Type of the bug.</param>
        /// <param name="bugItem">The bug item.</param>
        private static void AssignSeverityAndBugTypeSeverityList(IGrouping<string, ProjectPortalBugsBySeverityAndBugType> bugType, EnvironmentBugList bugItem)
        {
            var severityGroupedBugList = bugType.GroupBy(bugTypeItem => bugTypeItem.Severity);

            foreach (var severityItem in severityGroupedBugList)
            {
                var severityBug = new SeverityBug();

                severityBug.WorkItemCount = severityItem.Sum(bugTypeItem => bugTypeItem.WorkItemCount) ?? 0;

                switch (severityItem.Key)
                {
                    case SeverityCritical:
                        bugItem.CriticalBug = severityBug;
                        break;

                    case SeverityHigh:
                        bugItem.HighBug = severityBug;
                        break;

                    case SeverityMedium:
                        bugItem.MediumBug = severityBug;
                        break;

                    case SeverityLow:
                        bugItem.LowBug = severityBug;
                        break;
                }
            }
        }

        /// <summary>
        /// Validates a group of operations with the same context Uri.
        /// </summary>
        /// <param name="operations">Operations to validate.</param>
        private void ValidateOperationMetadataGroup(IGrouping<string, ODataOperation> operations)
        {
            Debug.Assert(operations != null, "operations must not be null.");
            Debug.Assert(operations.Any(), "operations.Any()");
            Debug.Assert(operations.All(o => this.GetOperationMetadataString(o) == operations.Key), "The operations should be grouped by their metadata.");

            if (operations.Count() > 1 && operations.Any(o => o.Target == null))
            {
                throw new ODataException(OData.Core.Strings.ODataJsonLightEntryAndFeedSerializer_ActionsAndFunctionsGroupMustSpecifyTarget(operations.Key));
            }

            foreach (IGrouping<string, ODataOperation> operationsByTarget in operations.GroupBy(this.GetOperationTargetUriString))
            {
                if (operationsByTarget.Count() > 1)
                {
                    throw new ODataException(OData.Core.Strings.ODataJsonLightEntryAndFeedSerializer_ActionsAndFunctionsGroupMustNotHaveDuplicateTarget(operations.Key, operationsByTarget.Key));
                }
            }
        }

 /// <summary>
 /// Gibt Auftraege zurueck, die dem Rechnungstyp entsprechen
 /// </summary>
 /// <param name="type">Rechnungstyp</param>
 /// <param name="groupedOrder">Auftragsgruppe</param>
 /// <returns></returns>
 private IEnumerable<IGrouping<string, VirtualOrder>> getCurrentInvoiceType(InvoiceTypes type, IGrouping<string, VirtualOrder> groupedOrder)
 {
     IEnumerable<IGrouping<string, VirtualOrder>> _invoiceTypeGroup=null;
     if ((type != null) && type.InvoiceTypeName == "Sammelrechnung")
     {
         _invoiceTypeGroup = groupedOrder.GroupBy(q => q.LocationName.ToString());
     }
     if ((type != null) && type.InvoiceTypeName == "Einzelrechnung")
     {
         _invoiceTypeGroup = groupedOrder.GroupBy(q => q.OrderNumber.ToString());
     }
     if ((type != null) && type.InvoiceTypeName == "Wochenrechnung")
     {
         _invoiceTypeGroup = groupedOrder.GroupBy(q => Math.Floor((decimal)q.ExecutionDate.Value.DayOfYear / 7).ToString());
     }
     if ((type != null) && type.InvoiceTypeName == "Monatsrechnung")
     {
         _invoiceTypeGroup = groupedOrder.GroupBy(q => q.ExecutionDate.Value.Month.ToString());
     }
     return _invoiceTypeGroup;
 }

        private static bool RunTestClass(IMessageSink messageSink, IGrouping<ITypeInfo, XunitTestCase> group, RunSummary classSummary)
        {
            bool cancelled = false;
            var aggregator = new ExceptionAggregator();

            Type testClassType = ((IReflectionTypeInfo)group.Key).Type;
            Dictionary<Type, object> fixtureMappings = new Dictionary<Type, object>();
            List<object> constructorArguments = new List<object>();

            // TODO: Read class fixtures from test collection
            foreach (var iface in testClassType.GetInterfaces().Where(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IClassFixture<>)))
            {
                Type fixtureType = iface.GetGenericArguments().Single();
                object fixture = null;
                aggregator.Run(() => fixture = Activator.CreateInstance(fixtureType));
                fixtureMappings.Add(fixtureType, fixture);
            }

            var ctors = testClassType.GetConstructors();
            if (ctors.Length != 1)
            {
                aggregator.Add(new TestClassException("A test class may only define a single public constructor."));
            }
            else
            {
                var ctor = ctors.Single();
                List<string> unusedArguments = new List<string>();

                foreach (var paramInfo in ctor.GetParameters())
                {
                    object fixture;

                    if (fixtureMappings.TryGetValue(paramInfo.ParameterType, out fixture))
                        constructorArguments.Add(fixture);
                    else
                        unusedArguments.Add(paramInfo.ParameterType.Name + " " + paramInfo.Name);
                }

                if (unusedArguments.Count > 0)
                    aggregator.Add(new TestClassException("The following constructor arguments did not have matching fixture data: " + String.Join(", ", unusedArguments)));
            }

            var methodGroups = group.GroupBy(tc => tc.Method);

            foreach (var method in methodGroups)
            {
                if (!messageSink.OnMessage(new TestMethodStarting { ClassName = group.Key.Name, MethodName = method.Key.Name }))
                    cancelled = true;
                else
                    cancelled = RunTestMethod(messageSink, constructorArguments.ToArray(), method, classSummary, aggregator);

                if (!messageSink.OnMessage(new TestMethodFinished { ClassName = group.Key.Name, MethodName = method.Key.Name }))
                    cancelled = true;

                if (cancelled)
                    break;
            }

            foreach (var fixture in fixtureMappings.Values.OfType<IDisposable>())
            {
                try
                {
                    fixture.Dispose();
                }
                catch (Exception ex)
                {
                    if (!messageSink.OnMessage(new ErrorMessage(ex.Unwrap())))
                        cancelled = true;
                }
            }

            return cancelled;
        }

        /// <summary>
        /// Assigns the environment and type list.
        /// </summary>
        /// <param name="environment">The environment.</param>
        /// <param name="bugItem">The bug item.</param>
        private static void AssignEnvironmentAndTypeList(IGrouping<byte?, ProjectPortalBugsByEnvironmentAndBugType> environment, EnvironmentBugList bugItem)
        {
            var severityGroupedBugList = environment.GroupBy(bugType => bugType.BugType);

            foreach (var severity in severityGroupedBugList)
            {
                SeverityBug severityItem = new SeverityBug();

                severityItem.WorkItemCount = severity.Sum(bugType => bugType.WorkItemCount) ?? 0;

                switch (severity.Key)
                {
                    case CodeDefect:
                        bugItem.CodeDefect = severityItem;
                        break;

                    case SpecIssue:
                        bugItem.SpecIssue = severityItem;
                        break;

                    case Suggestion:
                        bugItem.Suggestion = severityItem;
                        break;
                }
            }
        }