Debut persistance

Sources/CoreLibrary/Joueurs/Joueur.cs

@@ -1,21 +1,27 @@
 using CoreLibrary.Core;
 using CoreLibrary.Events;
+using System.Runtime.Serialization;
 
 namespace CoreLibrary.Joueurs
 {
     /// <summary>
     /// Classe représentant un joueur.
     /// </summary>
+    [DataContract]
     public class Joueur
     {
         /// <summary>
         /// Le nom du joueur.
         /// </summary>
+        [DataMember]
         public string Nom { get; private init; }
-
+        [DataMember]
         public int NbCoutTotal { get; set; }
+        [DataMember]
         public int NbPartieGagnee { get; set; }
+        [DataMember]
         public int NbPartieEgalite { get; set; }
+        [DataMember]
         public int NbPartiePerdue { get; set; }
 
         /// <summary>

Sources/CoreLibrary/Manager/IPersistanceManager.cs

@@ -6,8 +6,12 @@ namespace CoreLibrary.Manager
     {
         public bool EstEnregistre { get; }
 
-        public IEnumerable<Joueur> Charger();
+        public IEnumerable<Joueur> ChargerJoueurs();
 
-        public void Enregistrer(IEnumerable<Joueur> donnees);
+        public IEnumerable<Partie> ChargerParties();
+
+        public void EnregistrerJoueurs(IEnumerable<Joueur> donnees);
+
+        public void EnregistrerParties(IEnumerable<Joueur> donnees);
     }
 }

Sources/CoreLibrary/Partie.cs

@@ -2,14 +2,17 @@
 using CoreLibrary.Events;
 using CoreLibrary.Joueurs;
 using CoreLibrary.Regles;
+using System.Runtime.Serialization;
 
 namespace CoreLibrary
 {
     /// <summary>
     /// Représente une partie de jeu.
     /// </summary>
+    [DataContract]
     public class Partie
     {
+        [DataMember]
         public IRegles Regles { get; private set; }
 
         private readonly List<Joueur> joueurs = new List<Joueur>();

Sources/CoreLibrary/Persistance/IPersistance.cs

@@ -0,0 +1,16 @@
+using CoreLibrary.Joueurs;
+
+namespace CoreLibrary.Persistance
+{
+    public interface IPersistance
+    {
+
+        public List<Joueur> ChargerJoueurs();
+
+        public List<Partie> ChargerParties();
+
+        public void EnregistrerJoueurs(List<Joueur> joueurs);
+
+        public void EnregistrerParties(List<Partie> parties);
+    }
+}

Sources/CoreLibrary/Persistance/Persistance.cs

@@ -0,0 +1,75 @@
+using CoreLibrary.Joueurs;
+using System.Runtime.Serialization.Json;
+using System.Text;
+using System.Text.Json;
+
+namespace CoreLibrary.Persistance
+{
+    public class Persistance : IPersistance
+    {
+        public List<Joueur> joueurs = new List<Joueur>();
+        public List<Partie> parties = new List<Partie>();
+
+        public string ancienRepertoire = Directory.GetCurrentDirectory();
+
+        public List<Joueur> ChargerJoueurs()
+        {
+            DataContractJsonSerializer jsonSerializer = new DataContractJsonSerializer(typeof(List<Joueur>));
+
+            using (FileStream s = File.OpenRead("joueurs.json"))
+            {
+                joueurs = jsonSerializer.ReadObject(s) as List<Joueur>;
+            }
+
+            return joueurs;
+        }
+
+        public List<Partie> ChargerParties()
+        {
+            DataContractJsonSerializer jsonSerializer = new DataContractJsonSerializer(typeof(List<Partie>));
+
+            using (FileStream s = File.OpenRead("parties.json"))
+            {
+                parties = jsonSerializer.ReadObject(s) as List<Partie>;
+            }
+
+            return parties;
+        }
+
+        public void EnregistrerJoueurs(List<Joueur> joueurs)
+        {
+            DataContractJsonSerializer jsonSerializer = new DataContractJsonSerializer(typeof(List<Joueur>));
+
+            using (FileStream s = File.Create("joueurs.json"))
+            {
+                using (var writer = JsonReaderWriterFactory.CreateJsonWriter(
+                                        s,
+                                        Encoding.UTF8,
+                                        false,
+                                        true))
+                {
+                    jsonSerializer.WriteObject(writer, joueurs);
+                }
+            }
+            Directory.SetCurrentDirectory(ancienRepertoire);
+        }
+
+        public void EnregistrerParties(List<Partie> parties)
+        {
+            DataContractJsonSerializer jsonSerializer = new DataContractJsonSerializer(typeof(List<Partie>));
+
+            using (FileStream s = File.Create("parties.json"))
+            {
+                using (var writer = JsonReaderWriterFactory.CreateJsonWriter(
+                                        s,
+                                        Encoding.UTF8,
+                                        false,
+                                        true))
+                {
+                    jsonSerializer.WriteObject(writer, parties);
+                }
+            }
+            Directory.SetCurrentDirectory(ancienRepertoire);
+        }
+    }
+}

Sources/CoreLibrary/Regles/IRegles.cs

@@ -1,4 +1,5 @@
 using CoreLibrary.Core;
+using System.Runtime.Serialization;
 
 namespace CoreLibrary.Regles
 {

Sources/CoreLibrary/Regles/ReglesClassiques.cs

@@ -1,28 +1,35 @@
-namespace CoreLibrary.Regles
+using System.Runtime.Serialization;
+
+namespace CoreLibrary.Regles
 {
     /// <summary>
     /// Classe définissant les règles classiques du jeu.
     /// </summary>
+    [DataContract]
     public class ReglesClassiques : IRegles
     {
         /// <summary>
         /// Le nom des règles.
         /// </summary>
+        [DataMember]
         public string Nom { get => "Règles classiques"; }
 
         /// <summary>
         /// Le nombre maximum de tour.
         /// </summary>
+        [DataMember]
         public int TourMaximum { get => 12; }
 
         /// <summary>
         /// La taille maximale d'un code.
         /// </summary>
+        [DataMember]
         public int TailleCodeMaximum { get => 4; }
 
         /// <summary>
         /// Me nombre maximum de joueurs possibles pour le jeu.
         /// </summary>
+        [DataMember]
         public int NbJoueursMaximum { get => 2; }
     }
 }