LINQ统计

var _hardwarePerf = (from _stats in _statsList 
                    where _time>=DateTime.Parse("2012-04-04 00:00:00")
                        &&_time<=DateTime.Parse("2012-04-04 11:00:00") 
                    select new {
                           Latency = _stats.latency, 
                           CpuUsagePercent = _stats.cpuUsagePercent, 
                           MemoryUsagePercent = _stats.memoryUsagePercent, 
                           DiskUsage = _stats.diskUsage, DiskRead = _stats.diskRead, 
                           DiskWrite = _stats.diskWrite
                    }).Average(Latency => Latency.Latency);

var query = from _stats in _statsList 
    group _stats by new {
               Latency = _stats.latency, 
               CpuUsagePercent = _stats.cpuUsagePercent, 
               MemoryUsagePercent = _stats.memoryUsagePercent, 
               DiskUsage = _stats.diskUsage, 
               DiskRead = _stats.diskRead, 
               DiskWrite = _stats.diskWrite

    } into myGroup
    select new {
        AverageVal = myGroup.Average(x => x.Value),
        CpuUsagePercent = myGroup.Key.CpuUsagePercent,
        ... 
};

var averages =
    new
    {
        Latency = filteredStats.Average(x => x.Latency),
        CpuUsagePercent = filteredStats.Average(x => x.CpuUsagePercent),
        …
    };

var _hardwareAccumulator =
    _statsList
        .Where(s =>
            s.time >= DateTime.Parse("2012-04-04 00:00:00") &&
            s.time <= DateTime.Parse("2012-04-04 11:00:00"))
        .Aggregate(
            new
            {
                count = 0,
                cpuUsagePercent = 0.0,
                memoryUsagePercent = 0.0,
                diskUsage = 0.0,
                diskRead = 0.0
            },
            (acc, s) =>
                new
                {
                    count = acc.count + 1,
                    cpuUsagePercent =
                        acc.cpuUsagePercent + s.cpuUsagePercent,
                    memoryUsagePercent =
                        acc.memoryUsagePercent + s.memoryUsagePercent,
                    diskUsage =
                        acc.diskUsage + s.diskUsage,
                    diskRead =
                        acc.diskRead + s.diskRead
                }
            );
var _hardwarePerf = new
{
    cpuUsagePercent =
        _hardwareAccumulator.cpuUsagePercent / _hardwareAccumulator.count,
    memoryUsagePercent =
        _hardwareAccumulator.memoryUsagePercent / _hardwareAccumulator.count,
    diskUsage =
        _hardwareAccumulator.diskUsage / _hardwareAccumulator.count,
    diskRead =
        _hardwareAccumulator.diskRead / _hardwareAccumulator.count
};

var averages = statsList.Where(s => s.time >= new DateTime(2012, 4, 4) && s.time <= new DateTime(2012, 4, 04, 11, 0, 0))
            .GroupBy(s => 1)
            .Select(grp => new
            {
                Latency = grp.Average(s => s.latency),
                CpuUsagePercent = grp.Average(s => s.cpuUsagePercent),
                MemoryUsagePercent = grp.Average(s => s.memoryUsagePercent),
                DiskUsage = grp.Average(s => s.diskUsage),
                DiskRead = grp.Average(s => s.diskRead),
                DiskWrite = grp.Average(s => s.diskWrite)
            }).FirstOrDefault();

 

 

var newList = list.GroupBy(x => new {x.School, x.Friend, x.FavoriteColor})
                    .Select(y => new ConsolidatedChild()
                                        {
                                            FavoriteColor = y.Key.FavoriteColor,
                                            Friend = y.Key.Friend,
                                            School = y.Key.School,
                                            Children = y.ToList()
                                        }
                    );

var result = (from ls in list1
                  group ts by new {ls.Counter, ls.SrvID}
                order by ls.ID
                  select new{
                             ls.ID,
                             ls.Counter.FirstOrDefault(),
                             ls.SrvID.First,
                             ls.FirstName}).ToList()

list1.GroupBy(item => new { Counter = item.Counter, SrvID = item.SrvID })
     .Select(group => new { 
        ID = group.First().ID, 
        Counter = group.Key.Counter,
        SrvID = group.Key.SrvID,
        FirstName = group.First().FirstName})
     .OrderBy(item => item.ID);

var query =
  from record in list1
  group record by new {record.Counter, record.SrvID } into g
  let winner =
  (
    from groupedItem in g
    order by groupedItem.ID
    select groupedItem
  ).First()
  select winner;

var stats =
(
    from a in entities.Articles
    group a by a.UserId into g
    select new
    {
        UserId = g.Key,
        TotalPosts = g.Count(),
        LastUpdated = g.Max(i => i.DatePosted)
    }
);

var query =
(
    from u in entities.Users
    join s in stats on u.UserId equals s.UserId
    orderby u.Name 
    select new UserListing()
    {
        UserId = u.UserId,
        Name = u.Name,
        Email = u.Email,
        TotalPosts = s.TotalPosts,
        LastUpdated = s.LastUpdated
    }
);

var query =
(
    from u in entities.Users
    join s in stats on u.UserId equals s.UserId into g
    from a in g.DefaultIfEmpty()
    orderby u.Name 
    select new UserListing()
    {
        UserId = u.UserId,
        Name = u.Name,
        Email = u.Email,
        TotalPosts = a.TotalPosts,
        LastUpdated = a.LastUpdated
    }
);

var stats =
(
    from a in entities.Articles
    group a by a.UserId into g
    select new
    {
        UserId = g.Key,
        TotalPosts = (int?)g.Count(),
        LastUpdated = g.Max(i => i.DatePosted)
    }
);

var query =
(
    from u in entities.Users
    join s in stats on u.UserId equals s.UserId into joinedStats
    from s in joinedStats.DefaultIfEmpty() // do left outer join
    orderby u.Name 
    select new UserListing()
    {
        UserId = u.UserId,
        Name = u.Name,
        Email = u.Email,
        TotalPosts = s.TotalPosts,  // null if doesn't contain stats
        LastUpdated = s.LastUpdated // default DateTime if doesn't contain stats
    }
);

 

Func<DateTime, object> groupByClause;
if (groupByDay) groupByClause = date => date.Date;
else if (groupByMonth) groupByClause = date => new { date.Year, date.Month};
else throw new NotSupportedException("Some option should be chosen");

var result = data.Where(d => d.Type == "Deposit")
                 .GroupBy(groupByClause)
                 .Select(g => new { DateKey = g.Key,
                                    TotalDepositAmount = g.Sum(d => d.Amount),
                                    DepositCount = g.Count(),
                 });

var auta = from e in
                       (from a in DtPoruchy.FindAll()
                        where a.SERVIS >= 3
                        join p in MtAuta.FindAll() on a.MtAuta equals p.Id into ap
                        from ap2 in ap.DefaultIfEmpty()
                        select new
                        {
                            Cena = ap.cena,
                            IdAuta = a.MtAuta,
                            Servis = a.servis
                        })
                   group e by e.IdAuta into g
                   select new
                   {
                       Cena = g.Sum(e => e.cena),
                       IdAuta = g.Key,
                       Servis = g.Max(e => e.servis)
                   };

var auta = from jo in
                       (
                           from a in MtAuta.FindAll()
                           join p in DtPoruchy.FindAll() on a equals p.MtAuta into ap
                           from ap2 in ap.DefaultIfEmpty()
                           where ap2.SERVIS >= 3
                           select new
                           {
                               Cena = ap2.CENA,
                               Idauto = ap2.ID_AUTA,
                               Servis = ap2.SERVIS
                           }
                       )
                   group jo by jo.Idauto into g
                   select new
                   {
                       Cena = g.Sum(jo => jo.Cena),
                       IdAuto = g.Key,
                       Servis = g.Max(jo => jo.Servis)
                   };

 

WriteRankedList(from game in games
                group game by game.WinningPitcher into g
                orderby g.Count() descending
                select g);

WriteRankedList(games.GroupBy(g => g.WinningPitcher).
    OrderByDescending(g => g.Count()));

WriteRankedList(from game in games
                where game.Save != null
                group game by game.Save into g
                orderby g.Count() descending
                select g);

var battingAverageLeaders =
    from game in games
    from play in game.GetPlays()
    where play.Result != null
    group play by play.Batter into g
    where g.Count(p => p.Result.IsAtBat) > 400
    let pd = new PlayerData {
        Player = g.Key,
        Data = (Math.Round(1000.0d *
                           ((double)g.Count(p => p.Result.IsHit) /
                            (double)g.Count(p => p.Result.IsAtBat))) / 1000.0d).
                                ToString(".000") }
    orderby pd.Data descending
    select pd;


var battingAverageLeaders =
    games.SelectMany(g => g.GetPlays()).Where(p => p.Result != null).
    GroupBy(p => p.Batter).Where(g => g.Count(p => p.Result.IsAtBat) > 400).
    Select(g => new PlayerData {
               Player = g.Key,
               Data = (Math.Round(1000.0d *
                                  ((double)g.Count(p => p.Result.IsHit) /
                                   (double)g.Count(p => p.Result.IsAtBat))) / 1000.0d).
                                       ToString(".000")
           }).OrderByDescending(pd => pd.Data);


Func<Play, bool> obaPredicateTop =
    (p => p.Result.IsHit ||
          p.Result == PlayResult.Walk ||
          p.Result == PlayResult.IntentionalWalk ||
          p.Result == PlayResult.HitByPitch);

Func<Play, bool> obaPredicateBottom =
    (p => p.Result.IsAtBat ||
          p.Result == PlayResult.Walk ||
          p.Result == PlayResult.IntentionalWalk ||
          p.Result == PlayResult.HitByPitch ||
          p.Result == PlayResult.SacrificeFly);

var onBaseAverage =
    from game in games
    from play in game.GetPlays()
    where play.Result != null
    group play by play.Batter into g
    where g.Count() > 400
    let pd = new PlayerData {
        Player = g.Key,
        Data = (Math.Round(1000.0d *
                ((double)g.Count(obaPredicateTop) /
                 (double)g.Count(obaPredicateBottom))) / 1000.0d).
                     ToString(".000") }
    orderby pd.Data descending
    select pd;