Personne.

cs

using System;
using System.Collections.Generic;
using System.Dynamic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Sequence_6_Classess
{
internal class Personne : IEquatable<Personne?>
{
private string nom;
private string prenom;
private double taille;
private double poids;

// Unités de mesure (variables de classe)

public static readonly string UNITE_MESURE_POIDS = "kg";
public static readonly string UNITE_MESURE_TAILLE = "m";

// qst 12-b: Constante pour le poids maximum

public static readonly double POIDS_MAX = 1000;

// qst 12-c: Constante pour la taille maximum

public static readonly double TAILLE_MAX = 5;

// Constructeur par défaut

public Personne()
{
}

// Propriétés publiques pour accéder aux champs privés

public string Nom
{
get { return nom; }
set { nom = value; }
}

public string Prenom

{
get { return prenom; }
//set { prenom = value; }
set
{
if (!string.IsNullOrEmpty(value))
{
// Formatage de la première lettre en majuscule et le reste en minuscule
string prenomFormate = char.ToUpper(value[0]) + value.Substring(1).ToLower();
prenom = prenomFormate;
}
else
{
throw new ArgumentNullException("Le prénom ne peut pas être null ou vide.");
}
}

}
 public double Taille
{
get { return taille; }
//set { taille = value; }
// 12-c
set
{
if (value >= 0 && value <= TAILLE_MAX)
{
taille = value;
}
else
{
throw new ArgumentOutOfRangeException($"La taille doit être un nombre positif et ne pas dépasser
{TAILLE_MAX} mètres.");
}
}

public double Poids

{
get { return poids; }
//set { poids = value; }
//set 12-b
set
{
if (value >= 0 && value <= POIDS_MAX)
{
poids = value;
}
else
{
throw new ArgumentOutOfRangeException($"Le poids doit être un nombre positif et ne pas dépasser
{POIDS_MAX} kg.");
}
}

//qst9 & 10 & 18

public override string? ToString()
{
return $"Nom : {this.Nom}, Prénom : {this.Prenom}, Taille : {this.Taille}
{Personne.UNITE_MESURE_TAILLE}, Poids : {this.Poids}{Personne.UNITE_MESURE_POIDS}"; ;
}

public override bool Equals(object? obj)

{
return Equals(obj as Personne);
}

public bool Equals(Personne? other)

{
return other is not null &&
nom == other.nom &&
prenom == other.prenom &&
taille == other.taille &&
poids == other.poids &&
Nom == other.Nom &&
Prenom == other.Prenom &&
Taille == other.Taille &&
Poids == other.Poids;
}

public override int GetHashCode()

{
return HashCode.Combine(nom, prenom, taille, poids, Nom, Prenom, Taille, Poids);
}

public static bool operator ==(Personne? left, Personne? right)

{
return EqualityComparer<Personne>.Default.Equals(left, right);
}

public static bool operator !=(Personne? left, Personne? right)

{
return !(left == right);
}

//qst12-a changement set prenom

//qst 16
// Constructeur avec quatre paramètres pour initialiser toutes les propriétés
public Personne(string nom, string prenom, double taille, double poids)
{
// Assignation des valeurs aux propriétés de l'objet Personne créé
this.Nom = nom;
this.Prenom = prenom;
this.Taille = taille;
this.Poids = poids;
}

//qst 17
// Surcharge du constructeur pour rendre le nom optionnel
public Personne(string prenom, double taille, double poids) : this("", prenom, taille, poids)
{
// Ce constructeur appelle le constructeur existant avec une chaîne vide pour le nom
// et utilise les valeurs fournies pour prénom, taille et poids
}

//qst 20
// Comparaison de la taille avec les opérateurs <, >, <=, >=
public static bool operator <(Personne personne1, Personne personne2)
{
return personne1?.Taille < personne2?.Taille;
}

public static bool operator >(Personne personne1, Personne personne2)

{
return personne1?.Taille > personne2?.Taille;
}

public static bool operator <=(Personne personne1, Personne personne2)

{
return personne1?.Taille <= personne2?.Taille;
}

public static bool operator >=(Personne personne1, Personne personne2)

{
return personne1?.Taille >= personne2?.Taille;
}

//qst 21-a)
// Méthodes pour calculer l'IMC et donner l'indication correspondante
 public double CalculeImc()
{
if (Taille == 0)
{
throw new InvalidOperationException("La taille ne peut pas être égale à zéro pour calculer l'IMC.");
}

double tailleEnM = Taille;

double imc = Poids / (tailleEnM * tailleEnM);
return imc;
}

//qst 21-b)

public string DonneIndicationImc()

{
double imc = CalculeImc();

if (imc < 18.5)

{
return "Maigreur";
}
else if (imc >= 18.5 && imc < 25)
{
return "Corpulence normale";
}
else if (imc >= 25 && imc < 30)
{
return "Surpoids";
}
else
{
return "Obésité";
}
}

//qsts 23, 24, 25 et 26

private DateTime _dateNaissance;

public DateTime DateNaissance

{
get => _dateNaissance;
set
{
if (value >= DateTime.Today)
{
throw new ArgumentException("La date de naissance ne peut pas être égale ou postérieure à la date
d'aujourd'hui.");
}
_dateNaissance = value;
}
}

public int CalculeAge()

{
DateTime today = DateTime.Today;
int age = today.Year - DateNaissance.Year;
if (DateNaissance > today.AddYears(-age))
{
age--;
}
 return age;
}

public int Age => CalculeAge(); // Propriété en lecture seule pour l'âge

public bool EstPlusJeune(Personne autrePersonne)

{
return DateNaissance > autrePersonne.DateNaissance;
}

public Personne(string nom, string prenom, double taille, double poids, int age)
{

}
}
}

Main

namespace Sequence_6_Classess
{
internal class Program
{
static void Main(string[] args)
{
// Instanciation d'un objet Personne
//Personne p = new Personne();

// Assignation des valeurs aux propriétés de l'objet

// p.Nom = "Doe";
// p.Prenom = "John";
// p.Taille = 1.75;
// p.Poids = 70.5;

// Affichage des informations de la personne

// Console.WriteLine(p);

/*
//qst 16
try
{
// Utilisation du constructeur avec quatre paramètres pour créer un objet Personne
Personne p = new Personne("Doe", "John", 1.8, 75);

// Affichage des valeurs de l'objet créé

Console.WriteLine($"Nom : {p.Nom}");
Console.WriteLine($"Prénom : {p.Prenom}");
Console.WriteLine($"Taille : {p.Taille} m");
Console.WriteLine($"Poids : {p.Poids} kg");
}
catch (Exception e)
{
Console.WriteLine($"Erreur : {e.Message}");
}

//qst 12-a
try
{
 Personne p = new Personne();
p.Prenom = "MARC";
Console.WriteLine($"Donnée en entrée : MARC, Résultat : {p.Prenom}");

p.Prenom = "marc";
Console.WriteLine($"Donnée en entrée : marc, Résultat : {p.Prenom}");

p.Prenom = " ";

// Cette ligne ne sera pas atteinte car une exception sera levée avant
Console.WriteLine($"Donnée en entrée : ' ', Résultat : {p.Prenom}");
}
catch (ArgumentNullException e)
{
Console.WriteLine($"Exception : {e.Message}");
}

try
{
Personne p = new Personne();
string prenomNull = null;
p.Prenom = prenomNull;
// Cette ligne ne sera pas atteinte car une exception sera levée avant
Console.WriteLine($"Donnée en entrée : null, Résultat : {p.Prenom}");
}
catch (ArgumentNullException e)
{
Console.WriteLine($"Exception : {e.Message}");
}

//qst 12-b
try
{
Personne p = new Personne();
p.Poids = 800;
Console.WriteLine($"Poids : {p.Poids} kg");

p.Poids = -50;
// Cette ligne ne sera pas atteinte car une exception sera levée avant
Console.WriteLine($"Poids : {p.Poids} kg");
}
catch (ArgumentOutOfRangeException e)
{
Console.WriteLine($"Exception : {e.Message}");
}

try
{
Personne p = new Personne();
p.Poids = 1200;
// Cette ligne ne sera pas atteinte car une exception sera levée avant
Console.WriteLine($"Poids : {p.Poids} kg");
}
catch (ArgumentOutOfRangeException e)
{
Console.WriteLine($"Exception : {e.Message}");
}

//12-c
try
{
Personne p = new Personne();
p.Taille = 3.5;
Console.WriteLine($"Taille : {p.Taille} m");
 p.Taille = -1;
// Cette ligne ne sera pas atteinte car une exception sera levée avant
Console.WriteLine($"Taille : {p.Taille} m");
}
catch (ArgumentOutOfRangeException e)
{
Console.WriteLine($"Exception : {e.Message}");
}

try
{
Personne p = new Personne();
p.Taille = 6;
// Cette ligne ne sera pas atteinte car une exception sera levée avant
Console.WriteLine($"Taille : {p.Taille} m");
}
catch (ArgumentOutOfRangeException e)
{
Console.WriteLine($"Exception : {e.Message}");
}

//qst 19
Personne vous = new Personne("VotreNom", "VotrePrenom", 1.75, 70); // Remplacez avec vos détails
Personne votreVoisin = new Personne("VoisinNom", "VoisinPrenom", 1.80, 75); // Remplacez avec les
détails de votre voisin

bool identiques = vous.Equals(votreVoisin);

if (identiques)
{
Console.WriteLine("Vous et votre voisin êtes identiques !");
}
else
{
Console.WriteLine("Vous et votre voisin êtes différents !");
}

//qst 20
Personne personne1 = new Personne("Nom1", "Prenom1", 1.75, 70);
Personne personne2 = new Personne("Nom2", "Prenom2", 1.80, 75);
if (personne1 > personne2)
{
Console.WriteLine("La personne 1 est plus grande que la personne 2 !");
}
else if (personne1 < personne2)
{
Console.WriteLine("La personne 2 est plus grande que la personne 1 !");
}
else
{
Console.WriteLine("Les deux personnes ont la même taille !");
}

//qst 21:

// Test d'identité entre vous et votre voisin

bool identiquess = personne1 == personne2;
Console.WriteLine(identiquess ? "Vous et votre voisin êtes identiques !" : "Vous et votre voisin êtes
différents !");

// Comparaison des tailles et affichage de la personne la plus grande

Personne plusGrande = (personne1 > personne2) ? personne1 : personne2;
 Console.WriteLine($"La personne la plus grande mesure : {plusGrande.Taille}m");

// Calcul de l'IMC et indication pour vous et votre voisin

double votreImc = personne1.CalculeImc();
double voisinImc = personne2.CalculeImc();
Console.WriteLine($"Votre IMC : {votreImc}, Indication : {personne1.DonneIndicationImc()}");
Console.WriteLine($"IMC de votre voisin : {voisinImc}, Indication : {personne2.DonneIndicationImc()}");

*/

// qst 22
Console.WriteLine("Entrez vos informations :");
Console.Write("Nom : ");
string nom = Console.ReadLine();

Console.Write("Prénom : ");
string prenom = Console.ReadLine();

Console.Write("Taille (en mètres) : ");

double taille = Convert.ToDouble(Console.ReadLine());

Console.Write("Poids (en kg) : ");

double poids = Convert.ToDouble(Console.ReadLine());

int agevous = Convert.ToInt16(Console.ReadLine());

Personne vous = new Personne(nom, prenom, taille, poids,agevous);

//qst 23, 24, 25 et 26

vous.DateNaissance = new DateTime(1997, 6, 30);
Console.WriteLine($"Age de vous : {vous} ans");
//

Console.WriteLine($"Informations pour {prenom} {nom} :");

Console.WriteLine($"Taille : {taille} m | Poids : {poids} kg| age : {agevous} kg");

double votreImc = vous.CalculeImc();

Console.WriteLine($"Votre IMC : {votreImc}, Indication : {vous.DonneIndicationImc()}");

Console.Write("Nom : ");
string nom1 = Console.ReadLine();

Console.Write("Prénom : ");
string prenom1 = Console.ReadLine();

Console.Write("Taille (en mètres) : ");

double taille1 = Convert.ToDouble(Console.ReadLine());

Console.Write("Poids (en kg) : ");

double poids1 = Convert.ToDouble(Console.ReadLine());

int agelui = Convert.ToInt16(Console.ReadLine());

Personne lui = new Personne(nom1, prenom1, taille1, poids1,agelui);

//
lui.DateNaissance = new DateTime(2000, 3, 15);
Console.WriteLine($"Age de lui : {lui} ans");
//
 Console.WriteLine($"Informations pour {prenom1} {nom1} :");
Console.WriteLine($"Taille : {taille1} m | Poids : {poids1} kg");

double luiImc = vous.CalculeImc();

Console.WriteLine($"Votre IMC : {luiImc}, Indication : {lui.DonneIndicationImc()}");

//
bool estPlusJeune = vous.EstPlusJeune(lui);
Console.WriteLine(estPlusJeune ? "vous est plus jeune que lui." : "lui est plus jeune que vous");
//
}

}
}