private void Sauvegarder(object sender, RoutedEventArgs e)
{
SaveFileDialog sauver = new SaveFileDialog();
sauver.Filter = "Extensible Markup Language (*.xml) | *.xml";
sauver.Title = "Enregistrer sous";
if (sauver.ShowDialog() == true)
{
Persistance.Sauvegarde(sauver.FileName, App.Sauvegarde);
}
}
private void Charger(object sender, RoutedEventArgs e)
{
OpenFileDialog charger = new OpenFileDialog();
charger.Title = "Charger toutes les catégories";
charger.Filter = "Extended Markup Language (*.xml) | *.xml";
if (charger.ShowDialog() == true)
{
Persistance.Sauvegarde(charger.FileName, App.Sauvegarde);
}
}
static void Main(string[] args)
{
#region CHARGER DONNEES
List <Navire> collectionNavire = Persistance.ChargeNavire();
List <ZoneDeStockage> collectionStockage = Persistance.ChargeZoneDeStockage();
#endregion
#region VARIABLES ==> Utilisées pour la structure WHILE (menu)
int choix;
bool sortir = false;
#endregion
#region VARIABLES ==> Utilisées pour stocker les données métiers
Navire unNavire = null;
ZoneDeStockage zoneDeStockage = null;
string numCin, nomNavire, libelleFret;
int quantiteFret, numZoneDeStockage, capaciteMaxiamelDeStockage, capaciteStockageDisponible;
#endregion
#region VARIABLES (dénombrements et structures itératives)
#endregion
#region VARIABLES DIVERSES
#endregion
do
{
Console.Clear();
textM("------------------------------------------------------------------------");
textM("0 - Sortir du programme.");
textM("1 - Ajouter un Navire.");
textM("2 - Ajouter une Zone de stockage.");
textM("3 - Afficher la liste des navire.");
textM("4 - Afficher la liste des zone de stockage.");
textM("5 - Supprimer un navire.");
textM("6 - Supprimer une zone de stockage.");
textM("------------------------------------------------------------------------");
Console.WriteLine("");
choix = Convert.ToInt32(Console.ReadLine());
switch (choix)
{
case 1:
Console.Clear();
textM("------------------------------------------------------------------------");
textM("Saisir le numéro CIN.");
numCin = Console.ReadLine();
textM("Saisir le nom du navire.");
nomNavire = Console.ReadLine();
textM("Saisir le nom de la marchandise.");
libelleFret = Console.ReadLine();
textM("Saisir la quantite de marchandise.");
quantiteFret = Convert.ToInt32(Console.ReadLine());
unNavire = new Navire(numCin, nomNavire);
unNavire.LibelleFret = libelleFret;
unNavire.QuantiteFret = quantiteFret;
collectionNavire.Add(unNavire);
textM("Le navire a été ajouter.");
textM("------------------------------------------------------------------------");
break;
case 2:
textM("------------------------------------------------------------------------");
textM("Saisir le numéro de la zone de stockage.");
numZoneDeStockage = Convert.ToInt32(Console.ReadLine());
textM("Saisir la capactité de stockage maximale.");
capaciteMaxiamelDeStockage = Convert.ToInt32(Console.ReadLine());
textM("Saisir la capacite de stockage disponible.");
capaciteStockageDisponible = Convert.ToInt32(Console.ReadLine());
zoneDeStockage = new ZoneDeStockage(numZoneDeStockage, capaciteMaxiamelDeStockage);
zoneDeStockage.CapaciteStockageDisponible = capaciteStockageDisponible;
collectionStockage.Add(zoneDeStockage);
textM("La zone de stockage a été ajouter.");
textM("------------------------------------------------------------------------");
break;
case 3:
Console.Clear();
AffichageCollectionNavire(collectionNavire);
Console.ReadKey();
break;
case 4:
Console.Clear();
AffichageCollectionZoneDeStockage(collectionStockage);
Console.ReadKey();
break;
case 5:
Console.Clear();
AffichageCollectionNavire(collectionNavire);
textM("------------------------------------------------------------------------");
textM("Saisir le numéros ");
numCin = Console.ReadLine();
textM("------------------------------------------------------------------------");
break;
case 0:
#region SAUVEGARDE DES DONNEES
Persistance.Sauvegarde(collectionNavire);
Persistance.Sauvegarde(collectionStockage);
#endregion
sortir = true;
break;
default:
sortir = true;
break;
}
} while (!sortir);
}
static void Main(string[] args)
{
List <Employe> collectionEmploye = Persistance.ChargeEmploye();
List <Service> collectionService = Persistance.ChargeService();
if (collectionEmploye == null)
{
collectionEmploye = new List <Employe>();
}
if (collectionService == null)
{
collectionService = new List <Service>();
}
bool continuer = true;
do
{
Console.WriteLine("Gestion des employés");
Console.WriteLine("\t1 - Ajouter employé");
Console.WriteLine("\t2 - Afficher la liste des employés");
Console.WriteLine("\t3 - Modifier employé");
Console.WriteLine();
Console.WriteLine("\t4 - Ajouter un service");
Console.WriteLine("\t5 - Afficher la liste de service");
Console.WriteLine();
Console.WriteLine("\t6 - Supprimer employé");
Console.WriteLine("\t7 - Affichage employé par service");
Console.WriteLine("\t8 - Affichage employé par salaire");
Console.WriteLine();
Console.WriteLine("\t0 - Fermer le programme");
string choix = Console.ReadLine();
Console.Clear();
#region Traitements associés (relatifs) au menu
switch (choix)
{
case "1":
AjouterEmploye(collectionEmploye, collectionService);
break;
case "2":
AfficherEmploye(collectionEmploye);
break;
case "3":
ModifierEmploye(collectionEmploye, collectionService);
break;
case "4":
AjouterService(collectionService);
break;
case "5":
AfficherService(collectionService);
break;
case "6":
SupprimerEmploye(collectionEmploye);
break;
case "7":
AffichageEmployeService(collectionEmploye, collectionService);
break;
case "8":
break;
case "0":
continuer = false;
Persistance.Sauvegarde(collectionEmploye);
Persistance.Sauvegarde(collectionService);
break;
default:
break;
}
#endregion
} while (continuer == true);
}
static void Main(string[] args)
{
bool continuer = true;
bool trouve;
string noCIN, nomNavire, libelleFret;
int quantiteFret;
int numZoneStockage, capaciteStockageMaximale, capaciteStockageDisponible;
Navire unNavire;
ZoneDeStockage uneZoneDeStockage;
List <Navire> collectionNavire = Persistance.ChargeNavire();
List <ZoneDeStockage> collectionZoneDeStockage = Persistance.ChargeZoneDeStockage();
if (collectionNavire == null)
{
collectionNavire = new List <Navire>();
}
if (collectionZoneDeStockage == null)
{
collectionZoneDeStockage = new List <ZoneDeStockage>();
}
do
{
Console.WriteLine("\t0. Sauvegarder et fermer l'application");
Console.WriteLine();
Console.WriteLine("\t1. Ajouter un navire");
Console.WriteLine("\t2. Supprimer un navire");
Console.WriteLine();
Console.WriteLine("\t3. Ajouter une zone de fret");
Console.WriteLine("\t4. Supprimer une zone de fret");
Console.WriteLine();
Console.WriteLine("\t5. Afficher les informations des navires");
Console.WriteLine("\t6. Afficher les informations des zones de stockages");
string choixUtilisateur = Console.ReadLine();
Console.Clear();
switch (choixUtilisateur)
{
case "0":
Persistance.Sauvegarde(collectionNavire);
Persistance.Sauvegarde(collectionZoneDeStockage);
continuer = false;
break;
case "1":
Console.WriteLine("Quel est son numéro:");
noCIN = Console.ReadLine();
Console.WriteLine("\nQuel est son nom:");
nomNavire = Console.ReadLine();
Console.WriteLine("\nQuel est le nom de la marchandise:");
libelleFret = Console.ReadLine();
Console.WriteLine("\nQuel est la quantité de marchandise:");
quantiteFret = Convert.ToInt32(Console.ReadLine());
unNavire = new Navire(noCIN, nomNavire);
unNavire.LibelleFret = libelleFret;
unNavire.QuantiteFret = quantiteFret;
collectionNavire.Add(unNavire);
break;
case "2":
Console.WriteLine("Quel est le nom du navire à supprimer:");
nomNavire = Console.ReadLine();
Console.WriteLine();
trouve = false;
foreach (Navire navire in collectionNavire)
{
if (navire.NomNavire == nomNavire)
{
collectionNavire.Remove(navire);
Console.WriteLine($"Le navire \"{nomNavire}\" à bien été supprimé !");
trouve = true;
break;
}
}
if (!trouve)
{
Console.WriteLine("Le navire spécifié n'a pas été trouvé");
}
Console.ReadKey();
break;
case "3":
Console.WriteLine("Quel est son numéro de zone de stockage:");
numZoneStockage = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("\nQuel est sa capacité de stockage max:");
capaciteStockageMaximale = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("\nQuel est sa capacité de stockage disponible:");
capaciteStockageDisponible = Convert.ToInt32(Console.ReadLine());
uneZoneDeStockage = new ZoneDeStockage(numZoneStockage, capaciteStockageMaximale);
uneZoneDeStockage.CapaciteStockageDisponible = capaciteStockageDisponible;
collectionZoneDeStockage.Add(uneZoneDeStockage);
break;
case "4":
Console.WriteLine("Quel est le numéro de la zone de stockage à supprimer:");
numZoneStockage = Convert.ToInt32(Console.ReadLine());
Console.WriteLine();
trouve = false;
foreach (ZoneDeStockage zoneDeStockage in collectionZoneDeStockage)
{
if (zoneDeStockage.NumZoneStockage == numZoneStockage)
{
collectionZoneDeStockage.Remove(zoneDeStockage);
Console.WriteLine($"La zone de stockage \"{numZoneStockage}\" à bien été supprimé !");
trouve = true;
break;
}
}
if (!trouve)
{
Console.WriteLine("La zone de stockage spécifié n'a pas été trouvé");
}
Console.ReadKey();
break;
case "5":
foreach (Navire navire in collectionNavire)
{
Console.WriteLine($"\tNo {navire.NoCIN}\tNom: {navire.NomNavire}\tMarchandise: {navire.LibelleFret}\tQte March.: {navire.QuantiteFret}");
}
Console.ReadKey();
break;
case "6":
foreach (ZoneDeStockage zoneDeStockage in collectionZoneDeStockage)
{
Console.WriteLine($"\tNo {zoneDeStockage.NumZoneStockage}\tCapacité max: {zoneDeStockage.CapaciteStockageMaximale}\tCapacité dispo: {zoneDeStockage.CapaciteStockageDisponible}");
}
Console.ReadKey();
break;
}
Console.Clear();
} while (continuer);
}
static void Main(string[] args)
{
#region CHARGER DONNEES
List <Livre> collectionLivres = Persistance.ChargeLivre();
List <Adherent> collectionAdherents = Persistance.ChargeAdherent();
List <Emprunt> collectionEmprunts = Persistance.ChargeEmprunt();
#endregion
#region VARIABLES ==> Utilisées pour la structure WHILE (menu)
int choix;
bool sortir = false;
#endregion
#region VARIABLES ==> Utilisées pour stocker les données métiers
string numAdherent, nomAdherent, prenomAdherent, emailAdherent, adresseAdherent, villeAdherent, codePostalAdherent;
string titreLivre, numLivre, auteur, isbn;
string dateRetour;
Livre unLivre = null;
Adherent unAdherent = null;
#endregion
#region VARIABLES (dénombrements et structures itératives)
int nbElement, compteur = 0, test;
#endregion
#region VARIABLES DIVERSES
bool supprimer = false, trouver = false;
#endregion
do
{
Console.Clear();
textMillieu("------------------------------------------------------------------------");
textMillieu("0- Sortir du programme");
textMillieu("1- Ajouter un Livre");
textMillieu("2- Ajouter un adhérent");
textMillieu("3- Afficher la liste des adhérents");
textMillieu("4- Afficher la liste des livres");
textMillieu("5- Supprimer un adhérent");
textMillieu("6- Supprimer un livre");
textMillieu("7- Ajouter un emprunt");
textMillieu("8- Liste des emprunts");
textMillieu("9- Enregister le retour d'un livre");
textMillieu("------------------------------------------------------------------------");
Console.WriteLine("");
choix = Convert.ToInt32(Console.ReadLine());
switch (choix)
{
case 1:
Console.Clear();
textMillieu("------------------------------------------------------------------------");
textMillieu("Le numéro de l'ouvrage :");
numLivre = Console.ReadLine();
textMillieu("------------------------------------------------------------------------");
textMillieu("Titre de l'ouvrage :");
titreLivre = Console.ReadLine();
textMillieu("------------------------------------------------------------------------");
textMillieu("Nom de l'auteur :");
auteur = Console.ReadLine();
textMillieu("------------------------------------------------------------------------");
textMillieu("ISBN :");
isbn = Console.ReadLine();
unLivre = new Livre(numLivre, titreLivre, auteur, isbn);
collectionLivres.Add(unLivre);
/* A compléter
*
* Ecrire les instructions qui :
*
* permettent à l'utilisateur de saisir le numéro, le titre, le nom de l'auteur et l'ISBN d'un livre
* initialise une variable de type livre à partir des valeurs saisies
* ajoute le livre à la collection de livres
* */
break;
case 2:
Console.Clear();
textMillieu("------------------------------------------------------------------------");
textMillieu("Saisir le numéro du nouvel adhérent");
numAdherent = Console.ReadLine();
int numeroAdherent = Convert.ToInt16(numAdherent);
textMillieu("------------------------------------------------------------------------");
textMillieu("Saisir le nom du nouvel adhérent");
nomAdherent = Console.ReadLine();
textMillieu("------------------------------------------------------------------------");
textMillieu("Saisir le prénom du nouvel adhérent");
prenomAdherent = Console.ReadLine();
textMillieu("------------------------------------------------------------------------");
textMillieu("Saisir l'adresse email du nouvel adhérent");
emailAdherent = Console.ReadLine();
textMillieu("------------------------------------------------------------------------");
textMillieu("Saisir l'adresse postale du nouvel adhérent");
adresseAdherent = Console.ReadLine();
textMillieu("------------------------------------------------------------------------");
textMillieu("Saisir la ville de résidence du nouvel adhérent");
villeAdherent = Console.ReadLine();
textMillieu("------------------------------------------------------------------------");
textMillieu("Saisir le code postal de résidence du nouvel adhérent");
codePostalAdherent = Console.ReadLine();
Adherent nouveauAdherent = new Adherent(numeroAdherent, nomAdherent, prenomAdherent, emailAdherent, adresseAdherent, villeAdherent, codePostalAdherent);
collectionAdherents.Add(nouveauAdherent);
/* A compléter
*
* Ecrire les instructions qui :
* initialise une variable de type Adhérent à partir des valeurs saisies
* ajoute l'adhérent (la variable adhérent !) à la collection d'adhérents
* */
break;
case 3:
Console.Clear();
test = collectionAdherents.Count;
if (test == 0)
{
Console.WriteLine("Aucun adherent n'est référencé");
Console.ReadKey();
break;
}
else
{
Console.WriteLine("Num Adherent [Nom Adherent] [Prenom Adherent] [Email Adherent] [Adresse Adherent] [Ville Adherent] [Code Postal Adherent]");
foreach (Adherent adherentsCourant in collectionAdherents)
{
Console.WriteLine();
Console.Write(adherentsCourant.NumeroAdherent);
Console.Write(" [ {0} ]", adherentsCourant.NomAdherent);
Console.Write(" [ {0} ]", adherentsCourant.PrenomAdherent);
Console.Write(" [ {0} ]", adherentsCourant.EmailAdherent);
Console.Write(" [ {0} ]", adherentsCourant.AdresseAdherent);
Console.Write(" [ {0} ]", adherentsCourant.VilleAdherent);
Console.Write(" [ {0} ]", adherentsCourant.CodePostalAdherent);
Console.WriteLine();
}
}
Console.ReadKey();
/* A compléter
*
* Ecrire les instructions qui :
* parcours la collection d'adhérents et affiche à chaque itération, les informations de l'adhérents courant
* */
break;
case 4:
/*
* Modifier le bloc d'instruction ci-dessous comme suit :
* Si aucun livre n'est référencé, le programme en informe l'utilisateur
* dans le cas contraire elle affiche la collection de livres
*
*/
Console.Clear();
test = collectionLivres.Count;
if (test == 0)
{
textMillieu("------------------------------------------------------------------------");
textMillieu("Aucun livre n'est référencé.");
textMillieu("------------------------------------------------------------------------");
Console.ReadKey();
break;
}
else
{
Console.WriteLine("[Num livre] [Titre livre] [Auteur livre] [ISBN]");
foreach (Livre livreCourant in collectionLivres)
{
Console.WriteLine();
Console.Write(livreCourant.NumLivre);
Console.Write(" [ {0} ]", livreCourant.TitreLivre);
Console.Write(" [ {0} ]", livreCourant.Auteur);
Console.Write(" [ {0} ]", livreCourant.Isbn);
Console.WriteLine();
}
}
Console.ReadKey();
break;
case 5:
Console.Clear();
#region Affichage adherents
test = collectionAdherents.Count;
if (test == 0)
{
textMillieu("------------------------------------------------------------------------");
textMillieu("Aucun adherent n'est référencé");
textMillieu("------------------------------------------------------------------------");
Console.ReadKey();
break;
}
else
{
Console.WriteLine("Num Adherent [Nom Adherent] [Prenom Adherent] [Email Adherent] [Adresse Adherent] [Ville Adherent] [Code Postal Adherent]");
foreach (Adherent adherentsCourant in collectionAdherents)
{
Console.WriteLine();
Console.Write(adherentsCourant.NumeroAdherent);
Console.Write(" [ {0} ]", adherentsCourant.NomAdherent);
Console.Write(" [ {0} ]", adherentsCourant.PrenomAdherent);
Console.Write(" [ {0} ]", adherentsCourant.EmailAdherent);
Console.Write(" [ {0} ]", adherentsCourant.AdresseAdherent);
Console.Write(" [ {0} ]", adherentsCourant.VilleAdherent);
Console.Write(" [ {0} ]", adherentsCourant.CodePostalAdherent);
Console.WriteLine();
}
}
#endregion
textMillieu("------------------------------------------------------------------------");
textMillieu("Saisir le nom de l'adhérent à supprimer");
textMillieu("------------------------------------------------------------------------");
nomAdherent = Console.ReadLine();
/* A compléter
*
* Ecrire les instructions qui :
* parcours la collection d'adhérents et
* Supprime l'adhérent lorsque le nom de l'adhérent parcouru (courant) est équivalent à celui saisi par l'utilisateur
* Rappel : Une collection (LIST) parcouru à l'aide d'un FOREACH est en lecture seule.
* La méthode Remove de la classe LIST peut etre utilisée à condition de sortir prématurément
* du parcours à l'aide d'une BREAK
*
* Vous proposerez deux parcours (itération) différents, l'un avec la structure foreach, l'autre avec la structure While
*/
Console.WriteLine("Méthode Foreach ou While:");
switch (Console.ReadLine())
{
case "Foreach":
compteur = 0;
supprimer = false;
foreach (Adherent adherentCourant in collectionAdherents)
{
if (adherentCourant.NomAdherent == nomAdherent)
{
supprimer = true;
collectionAdherents.RemoveAt(compteur);
Console.WriteLine("{0} a été supprimer avec la fonction foreach.", nomAdherent);
Console.ReadKey();
break;
}
else
{
compteur++;
}
}
break;
case "While":
compteur = 0;
supprimer = false;
while (compteur < collectionAdherents.Count)
{
if (collectionAdherents[compteur].NomAdherent == nomAdherent)
{
supprimer = true;
collectionAdherents.RemoveAt(compteur);
Console.WriteLine("{0} a été supprimer avec la fonction while.", nomAdherent);
break;
}
compteur++;
}
break;
}
if (supprimer == false)
{
Console.WriteLine("Le livre rechrché n'est pas référencés");
}
Console.ReadKey();
break;
case 6:
Console.Clear();
#region Affichage livre
test = collectionLivres.Count;
if (test == 0)
{
textMillieu("------------------------------------------------------------------------");
textMillieu("Aucun livre n'est référencé.");
textMillieu("------------------------------------------------------------------------");
Console.ReadKey();
break;
}
else
{
Console.WriteLine("[Num livre] [Titre livre] [Auteur livre] [ISBN]");
foreach (Livre livreCourant in collectionLivres)
{
Console.WriteLine();
Console.Write(livreCourant.NumLivre);
Console.Write(" [ {0} ]", livreCourant.TitreLivre);
Console.Write(" [ {0} ]", livreCourant.Auteur);
Console.Write(" [ {0} ]", livreCourant.Isbn);
Console.WriteLine();
}
}
#endregion
textMillieu("------------------------------------------------------------------------");
textMillieu("Saisir le numéro ISBN du livre à supprimer");
isbn = Console.ReadLine();
nbElement = collectionLivres.Count; //nbElement contient le nombre de livres présent dans la collection
//compteur = 0;//
/*A compléter
*
* Ecrire les instructions qui:
*
* Parcours à l'aide d'une boucle While la collection de livres.
* recherche l'indice correspondant à l'emplacement ou se trouve le livre dans la collection
* supprime l'élément en s'appuyant sur la méthode "removeAt" de la classe LIST
*
* L'application affichera un message de confirmation
* ou un message indiquant l'absence du livre recherché dans la collection de livres référencés.
* */
supprimer = false;
for (int i = 0; i < nbElement; i++)
{
if (collectionLivres[i].Isbn == isbn)
{
supprimer = true;
collectionLivres.RemoveAt(i);
Console.WriteLine("ISBN {0} a été supprimer.", isbn);
break;
}
}
if (supprimer == false)
{
Console.WriteLine("Le livre rechrché n'est pas référencés");
}
Console.ReadKey();
break;
case 7:
Console.Clear();
/*A compléter
*
* Ecrire les instructions qui:
*
* 1) Affiche la collection de livres référencés
* 2) Permet la saisie d'un numéro de livre [correspond à la sélection d'un livre]
* ou S pour sortir du traitement en cours [Utilisez le break pour sortir du case en cours]
* 3) Le systeme recherche "le livre" à partir de la valeur précédement saisie
* Si le numéro de livre est erroné, le "case" 7 est relancé [utilisez l'instruction goto]
* dans le cas contraire il est stocké dans la variable "unLivre" de type Livre
*
* 4)Effectuer le traitement similaire permettant de sélectionner un adhérent
* Celui-ci sera stocké dans la variable "unAdherent" de type Adherent
*
* */
#region Affichage livre
test = collectionLivres.Count;
if (test == 0)
{
Console.WriteLine("Aucun livre n'est référencé.");
Console.ReadKey();
break;
}
else
{
Console.WriteLine("[Num livre] [Titre livre] [Auteur livre] [ISBN]");
foreach (Livre livreCourant in collectionLivres)
{
Console.WriteLine();
Console.Write(livreCourant.NumLivre);
Console.Write(" [ {0} ]", livreCourant.TitreLivre);
Console.Write(" [ {0} ]", livreCourant.Auteur);
Console.Write(" [ {0} ]", livreCourant.Isbn);
Console.WriteLine();
}
}
#endregion
#region saisie livre
trouver = false;
Console.WriteLine("Saisir le numéro de livre (S pour sortir du traitement)");
numLivre = Console.ReadLine();
if (numLivre == "s" || numLivre == "S")
{
Console.WriteLine("Sortie du traitement.");
Console.ReadKey();
break;
}
foreach (Livre livreCourant in collectionLivres)
{
if (Convert.ToString(livreCourant.NumLivre) == numLivre)
{
trouver = true;
unLivre = livreCourant;
}
}
if (trouver == false)
{
Console.WriteLine("Le numéro de livre est erroné.");
Console.ReadKey();
goto case 7;
}
#endregion
#region Affichage adherent
test = collectionAdherents.Count;
if (test == 0)
{
Console.WriteLine("Aucun adherent n'est référencé");
Console.ReadKey();
break;
}
else
{
Console.WriteLine("Num Adherent [Nom Adherent] [Prenom Adherent] [Email Adherent] [Adresse Adherent] [Ville Adherent] [Code Postal Adherent]");
foreach (Adherent adherentsCourant in collectionAdherents)
{
Console.WriteLine();
Console.Write(adherentsCourant.NumeroAdherent);
Console.Write(" [ {0} ]", adherentsCourant.NomAdherent);
Console.Write(" [ {0} ]", adherentsCourant.PrenomAdherent);
Console.Write(" [ {0} ]", adherentsCourant.EmailAdherent);
Console.Write(" [ {0} ]", adherentsCourant.AdresseAdherent);
Console.Write(" [ {0} ]", adherentsCourant.VilleAdherent);
Console.Write(" [ {0} ]", adherentsCourant.CodePostalAdherent);
Console.WriteLine();
}
}
#endregion
#region saisie adherent
trouver = false;
Console.WriteLine("Saisir le numéro d'adherent.");
numAdherent = Console.ReadLine();
if (numAdherent == "s" || numAdherent == "S")
{
Console.WriteLine("Sortie du traitement.");
Console.ReadKey();
break;
}
foreach (Adherent adherentCourant in collectionAdherents)
{
if (Convert.ToString(adherentCourant.NumeroAdherent) == numAdherent)
{
trouver = true;
unAdherent = adherentCourant;
}
}
if (trouver == false)
{
Console.WriteLine("Le numéro d'adherent est erroné.");
Console.ReadKey();
goto case 7;
}
#endregion
Console.WriteLine("Saisir la date de retour prévue");
DateTime dt = Convert.ToDateTime(Console.ReadLine());
Emprunt nouvelleEmprunt = new Emprunt(unAdherent, unLivre, dt);
collectionEmprunts.Add(nouvelleEmprunt);
/*A compléter
*
* Ecrire les instructions qui:
*
* initialise un objet de type emprunt à partir des variables objets Livre (unLivre)
* et Adherent (unAdherent) précédemment valorisées ainsi que la date d'emprunt stockée
* dans une structure (similaire à un objet) de type dateTime (dt)
*
* Ajoute l'emprunt à la collection d'emprunt
*
* */
break;
case 8:
Console.Clear();
foreach (Emprunt empruntCourant in collectionEmprunts)
{
Console.WriteLine("Date de l'emprunt : {0} \nDate de retour prévue {1} \nAdhérent : {2} \nLivre {3} ", empruntCourant.DateEmprunt.ToString(), empruntCourant.DateRetour.ToString(), empruntCourant.UnAdherent.NomAdherent, empruntCourant.UnLivre.TitreLivre);
}
Console.ReadKey();
break;
case 9:
/*A compléter
*
* Ecrire les instructions qui:
* A partir d'un numéro d'adhérent et d'un numéro de livre, recherche l'emprunt correspondant
* et enregistre son retour.
*
* */
textMillieu("------------------------------------------------------------------------");
textMillieu("Saisir le numéro d'adhérent:");
numAdherent = Console.ReadLine();
textMillieu("------------------------------------------------------------------------");
textMillieu("------------------------------------------------------------------------");
textMillieu("Saisir le numéro de livre:");
numLivre = Console.ReadLine();
textMillieu("------------------------------------------------------------------------");
foreach (Emprunt item in collectionEmprunts)
{
if (Convert.ToString(item.UnAdherent.NumeroAdherent) == numAdherent && Convert.ToString(item.UnLivre.NumLivre) == numLivre)
{
item.RetourEmprunt();
}
}
break;
case 0:
#region SAUVEGARDE DES DONNEES
Persistance.Sauvegarde(collectionLivres);
Persistance.Sauvegarde(collectionEmprunts);
Persistance.Sauvegarde(collectionAdherents);
#endregion
sortir = true;
break;
default:
sortir = true;
break;
}
} while (!sortir);
}
