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;
