// main method protected double Compute(List <Match> matches, bool isWeighted) { using (var ctx = new FootballEntities()) { try { int matchesNo = 0; double effective = 0.0; foreach (var m in matches) { var score = ctx.Scores.FirstOrDefault(s => s.MatchId == m.Id); if (score != null) { var pHome = m.HomeGoalsPredicted; var pAway = m.AwayGoalsPredicted; var rHome = score.HomeGoals; var rAway = score.AwayGoals; if (pHome != null && pAway != null) { matchesNo++; if (GetWinner((int)pHome, (int)pAway) == GetWinner(rHome, rAway)) { if (isWeighted) { effective += WINNER_RATIO; if ((int)pHome == rHome && (int)pAway == rAway) { effective += EXACT_SCORE_RATIO; } } else { effective += 1.0; } } } } } if (matchesNo == 0) { logger.Warn("Matches count = 0. No effectiveness could be computed"); return(0.0); } else { return(effective / (double)matchesNo); } } catch (Exception e) { logger.Error("Error while computing prediction effectiveness.", e); return(-1.0); } } }
public int InsertMatches(int matchday) { var matches = GetMatches(matchday); int counter = 0; using (var ctx = new FootballEntities()) { using (var transaction = ctx.Database.BeginTransaction()) { try { foreach (var m in matches) { var matchDb = m.ToDbObject(); matchDb.HomeId = ctx.Teams.First(t => t.Name == m.HomeTeam).Id; matchDb.AwayId = ctx.Teams.First(t => t.Name == m.AwayTeam).Id; ctx.Matches.Add(m.ToDbObject()); counter++; } ctx.SaveChanges(); transaction.Commit(); } catch (Exception) { transaction.Rollback(); } } } return(counter); }
private static League CreateLeagueIfNotExists(FootballEntities context, XElement xLeague) { League league = null; var xElementLeagueName = xLeague.Element("league-name"); if (xElementLeagueName != null) { string leagueName = xElementLeagueName.Value; league = context.Leagues.FirstOrDefault(l => l.LeagueName == leagueName); if (league != null) { Console.WriteLine("Existing league: {0}", leagueName); } else { // Create a new league in the DB league = new League() { LeagueName = leagueName }; context.Leagues.Add(league); context.SaveChanges(); Console.WriteLine("Created league: {0}", leagueName); } } return(league); }
public Score SetRatio(Score score) { try { using (var ctx = new FootballEntities()) { var scoreDb = ctx.Scores.SingleOrDefault(s => s.Id == score.Id); var match = ctx.Matches.First(m => m.Id == scoreDb.MatchId); var home = ctx.Teams.First(t => t.Id == match.HomeId).Name; var away = ctx.Teams.First(t => t.Id == match.AwayId).Name; scoreDb.HOR = CalculateOffensiveRatio(GetArchiveScores(home, scoreDb.Date)); scoreDb.HDR = CalculateDefensiveRatio(GetArchiveScores(home, scoreDb.Date)); scoreDb.AOR = CalculateOffensiveRatio(GetArchiveScores(away, scoreDb.Date)); scoreDb.ADR = CalculateDefensiveRatio(GetArchiveScores(away, scoreDb.Date)); scoreDb.HORH = CalculateOffensiveRatio(GetArchiveScores(home, true, scoreDb.Date)); scoreDb.HDRH = CalculateDefensiveRatio(GetArchiveScores(home, true, scoreDb.Date)); scoreDb.AORA = CalculateOffensiveRatio(GetArchiveScores(away, false, scoreDb.Date)); scoreDb.ADRA = CalculateDefensiveRatio(GetArchiveScores(away, false, scoreDb.Date)); ctx.SaveChanges(); logger.InfoFormat("Ratio for teams: {0} and {1} on date: {2} set successfully", home, away, scoreDb.Date); return(scoreDb); } } catch (Exception e) { logger.Error("Error while setting team ratio.", e); return(null); } }
static void Main(string[] args) { var context = new FootballEntities(); var leaguesTeams = context.Leagues .OrderBy(l => l.LeagueName) .Select(l => new { leagueName = l.LeagueName, teams = l.Teams.OrderBy(t => t.TeamName).Select(t => t.TeamName) }); //foreach (var league in leaguesTeams) //{ // Console.WriteLine(league.leagueName); // foreach (var team in league.teams) // { // Console.WriteLine(team); // } //} var JSerializer = new JavaScriptSerializer(); var jsonleaguesTeams = JSerializer.Serialize(leaguesTeams); File.WriteAllText("../../leagues-and-teams.json", jsonleaguesTeams); }
public static void Main() { using (var db = new FootballEntities()) { var xml = XDocument.Load("../../../Helper.Files/leagues-and-teams.xml"); var counter = 1; foreach (var league in xml.Descendants("league")) { Console.WriteLine("Processing league #{0} ...", counter++); var currentLeague = GetOrCreateLeague(league, db); foreach (var team in league.Descendants("team")) { if (team.Attribute("name") == null) { Console.WriteLine("Missing team name attribute."); continue; } var currentTeam = GetOrCreateTeam(team, db); AddTeamToLeague(currentTeam, currentLeague); } db.SaveChanges(); Console.WriteLine(); } } }
public int InsertScores(DateTime startDate) { var scores = ParseCsvScores(startDate); int counter = 0; using (var ctx = new FootballEntities()) { using (var transaction = ctx.Database.BeginTransaction()) { try { //TODO error model foreach (var s in scores) { ctx.Scores.Add(s.ToDbObject()); UpdateLeagueTable(s); counter++; ctx.SaveChanges(); } ctx.SaveChanges(); transaction.Commit(); } catch (Exception) { transaction.Rollback(); } } } return(counter); }
static void Main(string[] args) { var context = new FootballEntities(); var doc = XDocument.Load("../../../leagues-and-teams.xml"); var leagues = doc.Root.Elements(); var leagueCounter = 1; try { foreach (var league in leagues) { Console.WriteLine("Processing league #{0} ...", leagueCounter); //League newLeague = new League(); var newLeague = ProcessLeague(context, league); var teamsNode = league.Element("teams"); if (teamsNode != null) { foreach (var team in teamsNode.Elements()) { ProcessTeam(context, team, newLeague); } } leagueCounter++; Console.WriteLine(); } } catch (ArgumentException ex) { Console.Error.WriteLine(ex.Message); } }
private static League ProcessLeague(FootballEntities context, XElement league) { League newLeague = null; var leagueNode = league.Element("league-name"); if (leagueNode != null) { newLeague = context.Leagues.FirstOrDefault(l => l.LeagueName == leagueNode.Value); if (newLeague == null) { newLeague = new League() { LeagueName = leagueNode.Value }; context.Leagues.AddOrUpdate(newLeague); context.SaveChanges(); Console.WriteLine("Created league: {0}", newLeague.LeagueName); } else { Console.WriteLine("Existing league: {0}", newLeague.LeagueName); } } return(newLeague); }
static void Main() { var context = new FootballEntities(); var data = context.Leagues.OrderBy(l => l.LeagueName).Select(l => new { leagueName = l.LeagueName, teams = l.Teams.OrderBy(t => t.TeamName).Select(t => t.TeamName) }); JsonSerializer output = new JsonSerializer(); output.Formatting = Formatting.Indented; output.NullValueHandling = NullValueHandling.Include; using (StreamWriter sw = new StreamWriter(@"../../leagues-and-teams.json")) using (JsonWriter writer = new JsonTextWriter(sw)) { foreach (var entity in data) { output.Serialize(writer, entity); } } Console.WriteLine("Successfully created JSON file!"); }
public Match Predict(Match match) { try { using (var ctx = new FootballEntities()) { var matchDb = ctx.Matches.First(m => m.Id == match.Id); string home = ctx.Teams.First(t => t.Id == matchDb.HomeId).Name; string away = ctx.Teams.First(t => t.Id == matchDb.AwayId).Name; RatioModel ratio = Calculator.CalculateTeamsRatio(home, away, match.Date); var res = Machine.PredictScore(ratio); matchDb.HomeGoalsPredicted = res.Item1; matchDb.AwayGoalsPredicted = res.Item2; ctx.SaveChanges(); return(matchDb); } } catch (Exception e) { logger.Error(string.Format("Error while predicting match: homeId = {0}, awayId = {1}, date = {2}", match.HomeId, match.AwayId, match.Date), e); return(null); } }
public int InsertAllMatches() { var matches = GetAllMatches(); int counter = 0; using (var ctx = new FootballEntities()) { using (var transaction = ctx.Database.BeginTransaction()) { try { foreach (var m in matches) { ctx.Matches.Add(m.ToDbObject()); counter++; } ctx.SaveChanges(); transaction.Commit(); } catch (Exception) { transaction.Rollback(); } } } return(counter); }
public List <Score> GetTrainingScores(DateTime date) { try { using (var ctx = new FootballEntities()) { var result = new List <Score>(); var dbScores = ctx.Scores .Where(s => s.Date < date) .OrderByDescending(s => s.Date) .Take(TRAINING_SET_CARDINALITY); RatioCalculator rc = new RatioCalculator(); foreach (var s in dbScores) { if (s.HOR == null) { result.Add(rc.SetRatio(s)); } else { result.Add(s); } } logger.InfoFormat("Training scores set (before date: {0}) have been created successfully. Training scores count = {1}", date, result.Count); return(result); } } catch (Exception e) { logger.Error(string.Format("GetTrainingScores (date = {0}) failed due to exception", date), e); return(null); } }
public double GetTeamRatio(int teamId, DateTime date, bool isOffensive) { try { using (var ctx = new FootballEntities()) { var match = ctx.Matches.Where(m => m.Date < date && (m.HomeId == teamId || m.AwayId == teamId)) .OrderByDescending(d => d.Date) .FirstOrDefault(); if (match == null) { if (isOffensive) { return(DEFENSIVE_RATIO_DEFAULT); } else { return(OFFENSIVE_RATIO_DEFAULT); } } var score = ctx.Scores.FirstOrDefault(s => s.MatchId == match.Id); if (score.HDR == null) { return(0.0); } if (isOffensive) { if (match.HomeId == teamId) { return((double)score.ADR); } else { return((double)score.HDR); } } else { if (match.HomeId == teamId) { return((double)score.AOR); } else { return((double)score.HOR); } } } } catch (Exception e) { logger.Error(string.Format("Getting ratio for teamId: {0}, date: {1}, isOffesnive: {2} failed due to exception.", teamId, date, isOffensive)); return(OFFENSIVE_RATIO_DEFAULT); } }
private static string GetRandomTeam(string leagueName, string opponentTeam = null) { using (var db = new FootballEntities()) { League currentLeague = null; if (leagueName != "no league") { currentLeague = db.Leagues.FirstOrDefault(l => l.LeagueName == leagueName); } string randomTeam; if (currentLeague != null) { var randomNumber = RandomGenerator.Next(currentLeague.Teams.Count()); randomTeam = currentLeague.Teams.OrderBy(t => t.TeamName).Skip(randomNumber).First().TeamName; } else { var randomNumber = RandomGenerator.Next(db.Teams.Count()); randomTeam = db.Teams.OrderBy(t => t.TeamName).Skip(randomNumber).First().TeamName; } if (randomTeam == opponentTeam) { return(GetRandomTeam(leagueName, opponentTeam)); } return(randomTeam); } }
public void InsertTeams() { var teams = GetTeamsFromFile(); using (var ctx = new FootballEntities()) { if (ctx.Teams.Count() == 0) { using (var transaction = ctx.Database.BeginTransaction()) { try { if (teams.Count > 0) { foreach (var t in teams) { ctx.Teams.Add(t); } ctx.SaveChanges(); transaction.Commit(); } else { transaction.Rollback(); } } catch (Exception) { transaction.Rollback(); } } } } }
private static void AddTeamsToLeagueAndDb(FootballEntities context, XElement leagueNode, Leagues tempLeague) { // parse teams info and add to league var teamNodes = leagueNode.XPathSelectElements("teams/team"); foreach (var teamNode in teamNodes) { var tempTeam = new Teams(); var teamName = teamNode.Attributes("name").FirstOrDefault().Value; string teamCountry = null; if (teamNode.Attributes("country").FirstOrDefault() != null) { teamCountry = teamNode.Attributes("country").FirstOrDefault().Value; } var team = context.Teams.FirstOrDefault(t => t.TeamName == teamName); var country = context.Countries.FirstOrDefault(c => c.CountryName == teamCountry); var teamCountryCode = context.Countries.Where(c => c.CountryName == teamCountry).Select(c => c.CountryCode).FirstOrDefault(); var teamCountryCodeInDb = context.Teams.Where(t => t.TeamName == teamName).Select(t => t.CountryCode).FirstOrDefault(); bool sameCountry = true; if (teamCountryCode != null && teamCountryCodeInDb != null) { sameCountry = teamCountryCode.Equals(teamCountryCodeInDb); } // team exists + add team to league if (team != null && country != null && sameCountry) { Console.WriteLine("Existing team: " + teamName); tempLeague.Teams.Add(team); context.SaveChanges(); Console.WriteLine("Added team to league: " + tempLeague.LeagueName); } // missing team name else if (teamName == string.Empty) { Console.WriteLine("Team name is mandatory!"); } // creating new team + add team else { var newTeam = new Teams(); newTeam.TeamName = teamName; newTeam.CountryCode = teamCountryCode; context.Teams.Add(newTeam); Console.WriteLine("Created team: " + teamName); tempLeague.Teams.Add(newTeam); Console.WriteLine("Added team to league: " + tempLeague.LeagueName); } } }
public static void Main(string[] args) { var context = new FootballEntities(); // Problem 1.Entity Framework Mappings (Database First) //var teamsQuery = context.Teams.Select(t => t.TeamName); //foreach (var team in teamsQuery) //{ // Console.WriteLine(team); //} // Problem 2.Export the Leagues and Teams as JSON //var leaguesQuery = // context.Leagues.OrderBy(l => l.LeagueName) // .Select( // l => // new LeagueDto // { // LeagueName = l.LeagueName, // Teams = l.Teams.OrderBy(t => t.TeamName).Select(t => t.TeamName) // }) // .ToList(); //const string FilePathNameJson = "../../leagues-and-teams.json"; //var jsonExporter = new JsonExporter(); //jsonExporter.Export(FilePathNameJson, leaguesQuery); // Problem 3.Export International Matches as XML //var internationalMatchesQuery = context.InternationalMatches // .OrderBy(im => im.MatchDate) // .ThenBy(im => im.Countries) // .ThenBy(im => im.Countries1) // .Select(im => new InternationalMatchesDto() // { // HomeCountry = im.Countries1.CountryName, // AwayCountry = im.Countries.CountryName, // MatchDate = im.MatchDate.ToString(), // Score = im.HomeGoals.ToString() + "-" + im.AwayGoals.ToString(), // League = im.Leagues.LeagueName, // HomeCountryCode = im.HomeCountryCode, // AwayCountryCode = im.AwayCountryCode // }).ToList(); //const string FilePathNameXml = "../../international-matches.xml "; //var xmlExporter = new XmlExporter(); //xmlExporter.Export(FilePathNameXml, internationalMatchesQuery); // Problem 4.Import Leagues and Teams from XML // Import rivers from Xml file var xmlImporter = new XmlImporter(); var xmlDoc = XDocument.Load(@"..\..\leagues-and-teams.xml "); xmlImporter.Import(xmlDoc, context); }
public ActionResult Schedule(int selectedRound = -1) { using (var ctx = new FootballEntities()) { var actualSeason = SeasonHelper.GetCurrentSeason(DateTime.Today); var actualRound = MatchweekHelper.GetMatchweekToDisplayInSchedule(); var data = new List <MainPageModel>(); if (!(selectedRound >= 1 && selectedRound <= 38)) { selectedRound = actualRound; } int success = 0; int notPlayed = 0; foreach (var x in ctx.Matches.Where(d => (d.Matchweek == selectedRound) && d.Season.Equals(actualSeason))) { if (selectedRound <= actualRound) { var score = ctx.Scores.FirstOrDefault(w => w.MatchId == x.Id); int?homeGoals, awayGoals; if (score != null) { homeGoals = score.HomeGoals; awayGoals = score.AwayGoals; bool rightPredicted = CompareScores((int)homeGoals, (int)awayGoals, x.HomeGoalsPredicted, x.AwayGoalsPredicted); if (rightPredicted) { success++; } } else { notPlayed++; homeGoals = null; awayGoals = null; } data.Add(new MainPageModel(x.Team1.FullName, x.Team.FullName, x.HomeGoalsPredicted, x.AwayGoalsPredicted, awayGoals, homeGoals, x.Date.Date)); } else { data.Add(new MainPageModel(x.Team1.FullName, x.Team.FullName, x.HomeGoalsPredicted, x.AwayGoalsPredicted, null, null, x.Date.Date)); } } ViewBag.actualRound = actualRound; ViewBag.selectedRound = selectedRound; if (selectedRound <= actualRound && notPlayed < 10) { var successPercent = (success / (10.0 - notPlayed)) * 100.0; ViewBag.success = Math.Round(successPercent, 2); } return(View(data.Distinct())); } }
private static void CreateTeam(FootballEntities context, string teamName, Country country, League league) { Team team; if (country == null) { team = context.Teams.FirstOrDefault(t => (t.Country == null) && t.TeamName == teamName); } else { team = context.Teams.FirstOrDefault( t => t.Country.CountryName == country.CountryName && t.TeamName == teamName); } if (team == null) { team = new Team { TeamName = teamName, Country = country }; context.Teams.Add(team); context.SaveChanges(); Console.WriteLine( "Created team: {0} ({1})", team.TeamName, country != null ? team.Country.CountryName : "no country"); if (league != null) { team.Leagues.Add(league); context.SaveChanges(); Console.WriteLine("Added team to league: {0}", league.LeagueName); } } else { Console.WriteLine( "Existing team: {0} ({1})", team.TeamName, country != null ? team.Country.CountryName : "no country"); if (league != null) { if (!team.Leagues.Any(l => l.LeagueName == league.LeagueName)) { team.Leagues.Add(league); context.SaveChanges(); Console.WriteLine("Added team to league: {0}", league.LeagueName); } else { Console.WriteLine("Existing team in league: {0}", league.LeagueName); } } } }
public static void Main() { using (var db = new FootballEntities()) { foreach (var team in db.Teams) { Console.WriteLine(team.TeamName); } } }
// before certain date, including exact score public double ComputeWeighted(DateTime before) { using (var ctx = new FootballEntities()) { var matches = ctx.Matches.Where(m => m.Date < before).ToList(); double res = Compute(matches, true); logger.InfoFormat("Prediction weighted effectiveness of scores before {0} equals: {1}", before, res); return(res); } }
// all scores, including exact score public double ComputeWeighted() { using (var ctx = new FootballEntities()) { var matches = ctx.Matches.ToList(); double res = Compute(matches, true); logger.InfoFormat("Prediction weighted effectiveness of all scores equals: {0}", res); return(res); } }
public void InsertTeams() { _ds.InsertTeams(); using (var ctx = new FootballEntities()) { Assert.AreEqual(ctx.Teams.Count(), 20 + 24 + 24 + 24); Assert.AreEqual(ctx.Teams.First().FullName, "Arsenal FC"); Assert.AreEqual(ctx.Teams.First().Name, "Arsenal"); } }
// season, including exact score public double ComputeWeighted(string season) { using (var ctx = new FootballEntities()) { var matches = ctx.Matches.Where(m => m.Season == season).ToList(); double res = Compute(matches, true); logger.InfoFormat("Prediction weighted effectiveness of scores in season {0} equals: {1}", season, res); return(res); } }
// only one matchweek from season (e.g. "2015/2016") public double Compute(int matchweek, string season) { using (var ctx = new FootballEntities()) { var matches = ctx.Matches.Where(m => m.Season == season && m.Matchweek == matchweek).ToList(); double res = Compute(matches, false); logger.InfoFormat("Prediction effectiveness of scores in matchweek {0} of season {1} equals: {2}", matchweek, season, res); return(res); } }
public int InsertScores(string csvFilePath, DateTime startDate) { List <ScoreModel> scores = null; if (csvFilePath == null) { scores = ParseCsvScores(startDate); } else { scores = ParseCsvScores(csvFilePath, startDate); } int counter = 0; using (var ctx = new FootballEntities()) { using (var transaction = ctx.Database.BeginTransaction()) { try { foreach (var s in scores) { var dbScore = s.ToDbObject(); if (ctx.Scores.Any(sc => sc.MatchId == dbScore.MatchId)) { logger.WarnFormat("Score already exists. Date: {0}, match: {1}-{2}", s.Date, s.HomeTeam, s.AwayTeam); continue; } else { ctx.Scores.Add(dbScore); logger.InfoFormat("Score added. Date: {0}, match: {1}-{2}", s.Date, s.HomeTeam, s.AwayTeam); } UpdateLeagueTable(s); counter++; ctx.SaveChanges(); } ctx.SaveChanges(); transaction.Commit(); logger.InfoFormat("{0}/{1} scores inserted to database", counter, scores.Count); } catch (Exception e) { logger.Error("Error while inserting scores. Transaction rollback.", e); transaction.Rollback(); } } } return(counter); }
static void Main() { var context = new FootballEntities(); var teams = context.Teams; foreach (var team in teams) { System.Console.WriteLine(team.TeamName); } }
public void InsertAllMatches() { var res = _ds.InsertAllMatches(); Assert.IsTrue(res > 0); using (var ctx = new FootballEntities()) { Assert.AreEqual(ctx.Matches.Max(m => m.Matchweek), 38); // TODO } }
static void Main() { //To test your EF data model, list all team names. // The rest of problem 1 is in separate project. var context = new FootballEntities(); foreach (var team in context.Teams) { Console.WriteLine(team.TeamName); } }
private Tuple <int, int, int> GetSuccessRateOfPrediction(TeamsInfoModel model) { int successScorePredictions = 0; int successResultPredictions = 0; int allMatches = 0; var teamName = model.Team1; var actualSeason = SeasonHelper.GetCurrentSeason(DateTime.Today); using (var ctx = new FootballEntities()) { var actualRound = MatchweekHelper.GetCurrentMatchweek(); var teamId = ctx.Teams.FirstOrDefault(e => e.FullName.Equals(teamName)).Id; foreach (var match in ctx.Matches.Where(e => (e.HomeId == teamId || e.AwayId == teamId) && DateTime.Compare(e.Date, DateTime.Today) < 0)) { var scoreOfMatch = match.Scores.FirstOrDefault(); if (scoreOfMatch == null) { continue; } if (!SeasonsComapare(model.SeasonSince, model.SeasonTo, match.Season)) { continue; } if (match.AwayGoalsPredicted == null || match.HomeGoalsPredicted == null) { continue; } if ((scoreOfMatch.HomeGoals > scoreOfMatch.AwayGoals && match.HomeGoalsPredicted > match.AwayGoalsPredicted) || (scoreOfMatch.HomeGoals < scoreOfMatch.AwayGoals && match.HomeGoalsPredicted < match.AwayGoalsPredicted) || (scoreOfMatch.HomeGoals == scoreOfMatch.AwayGoals && match.HomeGoalsPredicted == match.AwayGoalsPredicted)) { successResultPredictions++; } if (scoreOfMatch.HomeGoals == match.HomeGoalsPredicted && scoreOfMatch.AwayGoals == match.AwayGoalsPredicted) { successScorePredictions++; } allMatches++; } } return(Tuple.Create(allMatches, successResultPredictions, successScorePredictions)); }
public void UpdateLeagueTable(ScoreModel s) { using (var ctx = new FootballEntities()) { var home = ctx.FullStatistics .FirstOrDefault(t => t.Team.Name == s.HomeTeam && t.Season == s.Season); // jesli nie ma jeszcze teamu w tabeli, to go dodaj z zerowym dorobkiem if (home == null) { home = AddToLeagueTable(s.HomeTeam, s.Season); } // jesli nie ma jeszcze teamu w tabeli, to go dodaj z zerowym dorobkiem var away = ctx.FullStatistics .FirstOrDefault(t => t.Team.Name == s.AwayTeam && t.Season == s.Season); if (away == null) { away = AddToLeagueTable(s.AwayTeam, s.Season); } home.MatchesPlayed++; home.GoalsScored += s.HomeGoals; home.GoalsLost += s.AwayGoals; away.MatchesPlayed++; away.GoalsScored += s.AwayGoals; away.GoalsLost += s.HomeGoals; if (s.HomeGoals > s.AwayGoals) { home.MatchesWon++; home.Points += 3; away.MatchesLost++; } else if (s.HomeGoals < s.AwayGoals) { away.MatchesWon++; away.Points += 3; home.MatchesLost++; } else { home.MatchesDrawn++; away.MatchesDrawn++; home.Points++; away.Points++; } ctx.SaveChanges(); } }
static void Main(string[] args) { var context = new FootballEntities(); var leaguesWithTeams = context.Leagues .OrderBy(l => l.LeagueName) .Select(l => new { leagueName = l.LeagueName, teams = l.Teams .OrderBy(t => t.TeamName) .Select(t => t.TeamName) }) .ToList(); var jsonSerializer = new JavaScriptSerializer(); var json = jsonSerializer.Serialize(leaguesWithTeams); File.WriteAllText("leagues-and-teams.json", json); Console.WriteLine("File leagues-and-teams.json exported."); }