Combining multiple sequences into 1 object

Vulpes, I have another related question.  I am now trying to figure out how to perform calculations on a list of objects, and then put the results in a new list.  for example:

List<OffenseStats> off = new List<OffenseStats>
{
        new OffenseStats {Team= "Bears", FGA = 50, FGM = 25},
        new OffenseStats {Team= "Lions", FGA = 70, FGM = 20}
};

How can I then create the equation FGM/FGA for each team, and then put the results in a new List:

List<GoalPercent> GoalPercent = ?????

The GoalPercent class would look something like this:

class GoalPercent()
{
        public string Team {get; set;}
        decimal GoalPercent {get; set;}

public GoalPercent(string team, decimal gp)
{
        Team = team;
        GoalPercent = gp;
}

}

Thanks in advance.

Afraid not, Rich.

The only 'tweeting' I do is on here :)

TBH, Rich, it doesn't make complete sense because what you've called a Season seems to me to be a Game and, in any case, a Season class can't have a property of the same name.

Also, I'd have thought that your AwayRecord class needs an additional property for the name of the team (Team say) and I wasn't clear what the date property was storing unless it's the date of the first away game for that team.

Anyway, for now, I've ignored the Season and date properties and just populated the others with this query which, as you suspected, requires the GroupBy extension method:

List<AwayRecord> awayRecords = this.NBAGetSeasonScores().

GroupBy(s => s.awayTeam).OrderBy(g => g.Key).Select(g => new AwayRecord{Team = g.Key, Wins = g.Count(s => s.awayScore > s.homeScore), Losses = g.Count(s => s.awayScore < s.homeScore)}).AsEnumerable().ToList();

Vulpes, your query worked like a charm.   I have yet created another challenge for myself.  I added two more properties to the AwayRecord class, which are Spread and Total.  The Spread property should hold the average point amount an away team wins or looses by(awayScore - homeScore), while the Total property should hold the average point total of the game(awayScore + homeScore).  The Total property was easy enough, but I am having trouble trying to figure out how to correctly query for the Spread property, since the away team isn't always a winner, therefore producing unwanted negative results( awayScore 80 - homeScore 100).  I am guessing this may involve a nested lambda expression, and possibly creating another class.  Here is what I have so far:

// Get NBA Away Record

        public List<NBAawayRecord> NBAteamAwayRecord()

        {

            List<NBAawayRecord> AwayRecord = this.NBAGetSeasonScores().GroupBy(at => at.away)

                .OrderBy(g => g.Key).Select(g => new NBAawayRecord

                {

                    Teams = g.Key,

                    Wins = g.Count(at => at.awayScore > at.homeScore)

                    ,

                    Losses = g.Count(at => at.awayScore < at.homeScore)

                    ,

                    Spread = g.Average(?????)

                    ,

                    Total = g.Average(at => (decimal)at.awayScore + (decimal)at.homeScore)

                }).AsEnumerable().ToList();

 

            return AwayRecord;

 

        }

To convert the negative values into positive values, all you need to do is to use the absolute value of the difference in scores:

Spread = g.Average(at => (decimal)Math.Abs(at.awayScore - at.homeScore))

Don't understand that as (at.awayScore - at.homeScore) is integral and Math.Abs has an overload for Int32 as well as Decimal.

Might be a LINQ to SQL peculiarity but no matter if it's OK working for you :)

public List<NBAstandings> NBAgetStandings()

        {

            List<nba_Team_Names> teams = this.NBAgetTeams().AsEnumerable().OrderBy(t => t.Abreviated_Long)

                .Select(t => t).ToList();

            List<NBAstandings> AwayRecord = this.NBAGetSeasonScores().GroupBy(ar => ar.away)

                .OrderBy(t => t.Key).Select(t => new NBAstandings

                {

                    Teams = t.Key,

                    Wins = t.Count(at => at.awayScore > at.homeScore),

                    Losses = t.Count(at => at.awayScore < at.homeScore),

                    Spread = t.Sum(at => Math.Abs((decimal)at.awayScore - (decimal)at.homeScore)),

                    Total = t.Sum(at => (decimal)at.awayScore + (decimal)at.homeScore)

                }).AsEnumerable().ToList();

            List<NBAstandings> HomeRecord = this.NBAGetSeasonScores().GroupBy(hr => hr.home)

                .OrderBy(t => t.Key).Select(t => new NBAstandings

                {

                    Teams = t.Key,

                    Wins = t.Count(ht => ht.homeScore > ht.awayScore),

                    Losses = t.Count(ht => ht.homeScore < ht.awayScore),

                    Spread = t.Sum(ht => Math.Abs((decimal)ht.homeScore - (decimal)ht.awayScore)),

                    Total = t.Sum(ht => (decimal)ht.homeScore + (decimal)ht.awayScore)

                }).AsEnumerable().ToList();

            List<NBAstandings> TotalSeason = teams.Select((t, i) => new NBAstandings

                (t.Abreviated_Long, AwayRecord[i], HomeRecord[i])).ToList();

            return TotalSeason;

        }

In your first query:

List<nba_Team_Names> teams = this.NBAgetTeams().AsEnumerable().OrderBy(t => t.Abreviated_Long).Select(t => t).ToList();

you could omit the Select() method which isn't actually doing anything:

List<nba_Team_Names> teams = this.NBAgetTeams().AsEnumerable().OrderBy(t => t.Abreviated_Long).ToList();

but other than that it's fine.

I woudn't try to cram too much into your LINQ queries as it makes them harder to understand and to maintain. I thought these seemed just right :)