reworked OnParticipantSubmitted event

src/AddEntrantControl.cs

@@ -17,7 +17,13 @@ namespace TournamentManager
 
         public Participant NewParticipant { get; private set; }
 
-        public event EventHandler SubmitParticipantClicked;
+        public delegate void ParticipantAddedDelegate(object sender, ParticipantAddedEventArgs e);
+        
+        public event ParticipantAddedDelegate SubmitParticipantClicked;
+
+        protected void OnSubmitParticipantClicked(ParticipantAddedEventArgs e) =>
+            SubmitParticipantClicked?.Invoke(this, e);
+        
         public AddEntrantControl()
         {
             InitializeComponent();
@@ -51,7 +57,7 @@ namespace TournamentManager
                 Rating = int.TryParse(tbRating.Text, out int rating) ? rating : 0
             };
             
-            SubmitParticipantClicked?.Invoke(this, e);
+            OnSubmitParticipantClicked(new ParticipantAddedEventArgs(NewParticipant));
         }
 
         private void btnReset_Click(object sender, EventArgs e)

src/GroupControl.cs

@@ -84,7 +84,7 @@ namespace TournamentManager.src
                 cbSecondOpponent.SelectedItem.ToString(), (firstScore, secondScore), index - 1));
         }
         
-        protected void OnOpponentsSelected()
+        private void OnOpponentsSelected()
         {
             ClearTextBoxes();
             if (cbFirstOpponent.SelectedItem == null || cbSecondOpponent.SelectedItem == null)

src/ManageTournamentForm.cs

@@ -2,7 +2,9 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Collections.Specialized;
+using System.IO;
 using System.Linq;
+using System.Text.Json;
 using System.Threading.Tasks;
 using System.Windows.Forms;
 
@@ -13,16 +15,36 @@ namespace TournamentManager
         private const string RemoveParticipantError = "Participant with this name is already signed in competition";
         private const string EditParticipantError = "Participant with this name is already signed in competition";
         private const string ErrorCaption = "Error";
-        private readonly ObservableCollection<Participant> _participants = new();
-        private List<Group> _groups;
-        private PlayOffTree _playOff;
+        private TournamentData _data;
+        private readonly string _path;
+
+        // private readonly ObservableCollection<Participant> _data.Participants = new();
+        // private List<Group> _data.Groups;
+        // private PlayOffTree _data.PlayOff;
         
         public ManageTournamentForm(string path)
         {
             InitializeComponent();
+            _path = path;
             
+            AsignEventHandlers();
+            AsignSaves();
+
+            foreach (var p in _data.Participants)
+            {
+                manageParticipantsControl.CbAddParticipant($"{p.FirstName} {p.Surname}");
+            }
+        }
+
+        private void AsignSaves()
+        {
+            enterantCntrl.SubmitParticipantClicked += OnSubmitParticipantClicked;
+
+        }
+
+        private void AsignEventHandlers()
+        {
             enterantCntrl.SubmitParticipantClicked += OnSubmitParticipantClicked;
-            _participants.CollectionChanged += HandleParticipantsChanged;
             manageParticipantsControl.ParticipantsModified += HandleOnParticipantRemovedClicked;
             computeControl.ComputeGroups += HandleOnComputeGroupsClicked;
             computeControl.ComputePlayOff += HandleOnComputePlayOffClicked;
@@ -32,37 +54,34 @@ namespace TournamentManager
             playOffControl.RoundSelected += HandleOnRoundSelected;
             playOffControl.MatchSelected += HandleOnMatchSelected;
             playOffControl.SubmitPlayOffMatchClicked += HandleOnSubmitPlayOffMatchClicked;
-            
-            foreach (var p in _participants)
+        }
+
+        private async Task Save()
+        {
+            var options = new JsonSerializerOptions
             {
-                manageParticipantsControl.CbAddParticipant($"{p.FirstName} {p.Surname}");
-            }
+                WriteIndented = true,
+            };
+            using var stream = File.Create(_path);
+            await JsonSerializer.SerializeAsync(stream, _data, options);
+            await stream.DisposeAsync();
+            
         }
         
         #region eventHandlers
         
-        private void OnSubmitParticipantClicked(object sender, EventArgs e)
+        private void OnSubmitParticipantClicked(object sender, ParticipantAddedEventArgs e)
         {
-            if (_participants.Any(x =>
+            if (_data.Participants.Any(x =>
                 x.FirstName.Equals(enterantCntrl.NewParticipant.FirstName) &&
                 x.Surname.Equals(enterantCntrl.NewParticipant.Surname))) 
             {
                 MessageBox.Show(RemoveParticipantError, ErrorCaption, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                 return;
             }
-            _participants.Add(enterantCntrl.NewParticipant);
+            _data.Participants.Add(enterantCntrl.NewParticipant);
             enterantCntrl.ResetControl();
-        }
-
-        private void HandleParticipantsChanged(object sender, NotifyCollectionChangedEventArgs e)
-        {
-            if (e.Action == NotifyCollectionChangedAction.Add)
-            {
-                foreach (Participant p in e.NewItems ?? new List<Participant>())
-                {
-                    manageParticipantsControl.CbAddParticipant($"{p.FirstName} {p.Surname}");
-                }
-            }
+            manageParticipantsControl.CbAddParticipant($"{e.Participant.FirstName} {e.Participant.Surname}");
         }
 
         private void HandleOnParticipantRemovedClicked(object sender, ParticipantsModifiedEventArgs e)
@@ -72,7 +91,7 @@ namespace TournamentManager
 
             var name = e.ParticipantName.Split();
 
-            _participants.Remove(_participants.FirstOrDefault(x => 
+            _data.Participants.Remove(_data.Participants.FirstOrDefault(x => 
                 x.FirstName.Equals(name[0]) && x.Surname.Equals(name[1])));
         }
         
@@ -89,15 +108,15 @@ namespace TournamentManager
         private void HandleOnComputeGroupsClicked(object sender, ComputeEventArgs e)
         {
             groupControl.ClearInputData();
-            var numberOfGroups = (_participants.Count - 1) / e.Amount + 1;
+            var numberOfGroups = (_data.Participants.Count - 1) / e.Amount + 1;
             var groupIndex = 0;
-            var orderedParticipants = _participants.OrderBy(x => x.Rating);
+            var orderedParticipants = _data.Participants.OrderBy(x => x.Rating);
 
             groupControl.AddGroups(numberOfGroups);
-            _groups = new List<Group>();
+            _data.Groups = new List<Group>();
             for (int i = 0; i < numberOfGroups; i++)
             {
-                _groups.Add(new Group());
+                _data.Groups.Add(new Group());
             }
             
             foreach (var participant in orderedParticipants)
@@ -107,10 +126,10 @@ namespace TournamentManager
                 {
                     groupIndex = 0;
                 }
-                _groups[groupIndex].Members.Add(participant);
+                _data.Groups[groupIndex].Members.Add(participant);
             }
 
-            foreach (var group in _groups)
+            foreach (var group in _data.Groups)
             {
                 var memberCount = group.Members.Count;
                 group.Matches = new int[memberCount, memberCount];
@@ -122,10 +141,10 @@ namespace TournamentManager
             playOffControl.ResetInput();
             try
             {
-                var toKeep = (int)Math.Round(((double)_participants.Count / (double)100) * (double)(100 - e.Amount), 0);
+                var toKeep = (int)Math.Round(((double)_data.Participants.Count / (double)100) * (double)(100 - e.Amount), 0);
                 var sortedParticipants = (await ComputeAllGroupOrders()).Take(toKeep).ToList();
-                _playOff = new PlayOffTree(sortedParticipants);
-                playOffControl.SetRounds(_playOff.Depth);
+                _data.PlayOff = new PlayOffTree(sortedParticipants);
+                playOffControl.SetRounds(_data.PlayOff.Depth);
             }
             catch (Exception ex)
             {
@@ -144,7 +163,7 @@ namespace TournamentManager
                 return;
             }
 
-            var groupMembers = _groups[result - 1].Members
+            var groupMembers = _data.Groups[result - 1].Members
                 .Select(x => $"{x.FirstName} {x.Surname}").ToArray();
             groupControl.AddToFirstOpponentList(groupMembers);
             groupControl.AddToSecondOpponentList(groupMembers);
@@ -158,7 +177,7 @@ namespace TournamentManager
                 return;
             }
 
-            var group = _groups[e.Index];
+            var group = _data.Groups[e.Index];
             var firstOpponent = group.ExtractGroupMember(e.FirstOpponent);
             var secondOpponent = group.ExtractGroupMember(e.SecondOpponent);
             
@@ -172,7 +191,7 @@ namespace TournamentManager
                 //TODO:ERROR MESSAGE
                 return;
             }
-            var group = _groups[e.Index];
+            var group = _data.Groups[e.Index];
             Func<string[], Participant> matchOpponent = x => group.Members
                 .FirstOrDefault(p => p.FirstName.Equals(x[0]) && p.Surname.Equals(x[1]));
             
@@ -189,7 +208,7 @@ namespace TournamentManager
             {
                 throw new Exception();
             }
-            var matches = _playOff.GetRoundMatches(round);
+            var matches = _data.PlayOff.GetRoundMatches(round);
             playOffControl.SetMatches(matches);
         }
         
@@ -200,14 +219,14 @@ namespace TournamentManager
                 throw new Exception();
             }
 
-            var match = _playOff.GetMatch(round, e.SelectedMatch);
+            var match = _data.PlayOff.GetMatch(round, e.SelectedMatch);
 
             playOffControl.SetMatch(match);
         }
         
         private void HandleOnSubmitPlayOffMatchClicked(object sender, MatchSubmittedEventArgs e)
         {
-            var matchNode = _playOff.GetMatchNode(e.FirstOpponent, e.SecondOpponent, e.Index);
+            var matchNode = _data.PlayOff.GetMatchNode(e.FirstOpponent, e.SecondOpponent, e.Index);
             matchNode.TreeMatch.Scores = e.Score;
 
             if (matchNode.IsRoot())
@@ -235,7 +254,7 @@ namespace TournamentManager
         {
             return Task.Factory.StartNew(() =>
             {
-                return _groups.AsParallel().SelectMany(x => ComputeGroupOrder(x))
+                return _data.Groups.AsParallel().SelectMany(x => ComputeGroupOrder(x))
                     .OrderByDescending(x => x.Item2)
                     .ThenByDescending(x => x.Item3)
                     .Select(x => x.Item1)

src/ParticipantAddedEventArgs.cs

+using System;
+
+namespace TournamentManager
+{
+    public class ParticipantAddedEventArgs : EventArgs
+    {
+        public Participant Participant { get; }
+
+        public ParticipantAddedEventArgs(Participant participant)
+        {
+            Participant = participant;
+        }
+    }
+}
\ No newline at end of file

src/TournamentData.cs

+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+
+namespace TournamentManager
+{
+    public class TournamentData
+    {
+        public readonly ObservableCollection<Participant> Participants = new();
+        public List<Group> Groups { get; set; }
+        public PlayOffTree PlayOff { get; set; }
+    }
+}
\ No newline at end of file