Objet : entité qui modélise (représente) un élément du domaine étudié.
Objet = état + actions.
Objet != classe :
POO : paradigme d’écriture de logiciels sous forme d’objets en interaction
Le standard : diagramme de classes UML.
Déclaration explicite de l’attribut (le plus souvent privé).
private string titulaire;
public string Titulaire {
get { return titulaire; }
set { titulaire = value; }
}
// ...
monCompte.Titulaire = "Marco";
Avantage : possibilité de contrôles dans les accesseurs (validation de la novuelle valeur, etc).
Création implicite de l’attribut par le langage.
public string Titulaire { get; set; }
// ...
monCompte.Titulaire = "Marco";
int nombre1;
nombre1 = 5;
int nombre2 = 3;
nombre2 = nombre1;
nombre1 = 10;
Console.WriteLine("nombre1 = " + nombre1); // 10
Console.WriteLine("nombre2 = " + nombre2); // 5
Cercle cercle1;
cercle1 = new Cercle(5);
Cercle cercle2 = new Cercle(3);
cercle2 = cercle1;
cercle1.Rayon = 10;
Console.WriteLine("cercle1.Rayon = " + cercle1.Rayon); // 10
Console.WriteLine("cercle2.Rayon = " + cercle2.Rayon); // ?
int
, float
, double
…static void Main(string[] args) {
int nombre = 5;
Console.WriteLine("Avant l'appel, nombre = " + nombre); // 5
Augmenter(nombre);
Console.WriteLine("Après l'appel, nombre = " + nombre); // ?
}
static void Augmenter(int unNombre) {
Console.WriteLine("Avant l'augmentation, unNombre = " + unNombre);
unNombre = unNombre + 1;
Console.WriteLine("Après l'augmentation, unNombre = " + unNombre);
}
static void Main(string[] args) {
Cercle cercle = new Cercle(5);
Console.WriteLine("Avant l'appel, cercle.Rayon = " + cercle.Rayon); // 5
AugmenterRayon(cercle);
Console.WriteLine("Après l'appel, cercle.Rayon = " + cercle.Rayon); // ?
}
static void AugmenterRayon(Cercle unCercle) {
Console.WriteLine("Avant l'augmentation, unCercle.Rayon = " + unCercle.Rayon);
unCercle.Rayon = unCercle.Rayon + 1;
Console.WriteLine("Après l'augmentation, unCercle.Rayon = " + unCercle.Rayon);
}
ref
et out
.try {
// code susceptible de lever des exceptions
}
catch (Exception e) {
// code de gestion de l’exception apparue
}
finally {
// code exécuté systématiquement
}
// levée d’une nouvelle exception
throw new Exception("Message d’erreur");
catch
.Potentiellement utile pour distinguer différentes catégories d’erreur, avec des données spécifiques.
i = 0;
trouve = false;
while (!trouve) {
i++;
if (i == 10)
throw new Exception("Fin de la boucle"); // Antipattern
else // ...
}
try {
// ...
}
catch (Exception e) {
throw e; // Antipattern : bloc inutile
}
try {
// ...
}
catch (Exception) {
// Antipattern : exception "avalée"
}
Exception
suffit souvent.<<
code applicatif.Le mot-clé var
permet de déclarer des variables implicitement typées.
int i = 10; // Typage explicite
var i = 10; // Typage implicite
Usage possible 1 : simplification du code de création d’objets (pas de répétition du type)
var l = new List<int>();
l.Add(3);
// ...
Usage possible 2 : non-nécessité de créer un type spécifique pour le résultat d’une opération.
// var est nécessaire car la clause SELECT définit un type anonyme
var custQuery = from cust in customers
where cust.City == "Bordeaux"
select new { cust.Name, cust.Phone };
// Var est nécessaire car chaque élément de la collection est un type anonyme
foreach (var item in custQuery)
{
Console.WriteLine("Nom={0}, Téléphone={1}", item.Name, item.Phone);
}
Placé juste avant le début d’une chaîne, le caractère $
permet d’y insérer des expressions entre accolades {...}
qui seront évaluées pour produire la valeur de la chaîne.
string name = "Clément";
var date = DateTime.Now;
Console.WriteLine("Hello, {0}! Today is {1}", name, date.DayOfWeek);
Console.WriteLine($"Hello, {name}! Today is {date.DayOfWeek}");
// Ces deux lignes produisent un résultat identique, similaire à :
// "Hello, Clément! Today is Monday"
Un type valeur auquel on accole le caractère ?
peut stocker la valeur null
en plus de sa plage de valeurs habituelle.
int a = null; // Erreur: ce type de peut stocker que des valeurs entières
int? b = null; // OK
int c = b ?? -1; // Conversion vers le type int
Les types nullables facilitent la gestion des valeurs indéfinies (exemple : absence de valeur pour une colonne dans une BD).
Les annotations, également appelées attributs, permettent d’ajouter des métadonnées (des informations supplémentaires) à certains éléments du code : types, méthodes, propriétés…
[Serializable]
public class ClasseExemple
{
// Les instances de cette classe sont sérialisables
}
// Cette propriété est associée à un type BD spécifique
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }