JY Tigli Homepages

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
====== Cours d'environnement de programmation en informatique en BAT4 ======
{{ cours:man-879093_640.jpg?120|}}

===== PREAMBULE =====


----

=== Un des trois Modules pour appréhender l'immotique ===

[[cours:bat4:programme_3_modules_1718|]]

=== Préambule & Approche pédagogique === 
{{ :cours:student-849825_1920.jpg?120|}}

[[cours:bat4:envlog1718:intro|]]

=== Outils de travaux pratiques ===

[[cours:bat4:envlog1718:toolslog|]]

=== Cours et Tutoriaux sur la Programmation Objet en C# ===

=== Quelques références sur la Programmation orientée objet et C# ===

  * {{:cours:cours_1_introduction_a_la_programmation_en_c_.pdf|Support du cours sur la Programmation sans Objet en C#}}
  * Autres supports plus détaillés :
     * [[https://msdn.microsoft.com/fr-fr/library/67ef8sbd.aspx|GUIDE DE PROGRAMMATION C# de référence chez Microsoft]]
     * [[:cours:cours_complet_C#|Cours Complet POO C# de Référence]]



== Pour aller  plus loin ==

{{ :cours:image_livre_c_luc_gervais.jpg?100|}}

Auteur(s) : Luc Gervais

Editeur(s) : Eni, Collection : Ressources Informatiques

Date de parution : 11/09/2013 , EAN13 : 9782746082977 



===== LES COURS PROGRAMMATION et ENVIRONNEMENT LOGICIEL =====

----

=== Séance 1 Introduction du langage C# hors objet : Introduction des outils de développement logiciel et mise en place de l'environnement du module ===

== Durée : 2h ==

== Résumé de la Séance : ==

  * Présentation des différents Projets Visual Studio
  * Démonstration d'un premier projet en mode terminal dit "Application Console" en C# sous Visual Studio
  * Démonstration d'un premier projet en mode graphique dit "Application Windows Forms" en C# sous Visual Studio 
  * QCM sur vos connaissances en programmation pour nous aider à mieux adapter l'enseignement.

== Tutorial : Développement sous Visual Studio == 

{{:cours:mementovisualstudio.pdf| Support du Tutorial}}

== A FAIRE ==
<note warning>
Aidez-vous du tutorial pour créer votre premier programme en mode console, ce programme affiche Hello. 
</note>

== Compétences acquises : ==
<note>
  * Utiliser Visual Studio pour créer et exécuter un projet Win32 console (i.e. sur un terminal non graphique) 
</note>

----

=== Séance 2 : Introduction du langage C# hors objet : Mise en œuvre de l'environnement de développement  ===

== Durée : 2h ==

== Résumé de la Séance : ==

  * Mise en œuvre de l'environnement Visual Studio pour
      * La phase de création de projets consoles et solutions : structuration d'une solution et d'un projet, fichiers sources et fichiers binaires exécutables, sauvegarde et emplacement sur le disque…
      * La phase de rédaction du code source : complétion de code et corrections en cours de saisie
      * La phase de compilation/génération d'exécutable : messages d'erreurs et de warning à la compilation
      * La phase d'exécution en mode debug : exécution pas à pas principale ou détaillée, visualisation des variables et leurs états, breakpoints …
      * [[https://docs.microsoft.com/fr-fr/dotnet/csharp/programming-guide/types/casting-and-type-conversions|Conversion de type]]

  * Rappel pratique de la programmation dite procédurale :
     * Variables et [[https://docs.microsoft.com/fr-fr/dotnet/csharp/tour-of-csharp/types-and-variables|Types élémentaires]]
     * le test if et switch
     * {{:cours:conversiontype.zip|Conversion de type, lecture à la console}}

== A FAIRE ==
<note warning>
  * Importer le programme de test de debugging et exécutez-le. 
  * Placer un point d'arrêt au bon endroit pour comprendre quel est le bug.
  * Corriger le bug en complétant le programme pour qu'il affiche 0, 1 ou 2 solutions selon que le déterminant est négatif, nul ou positif.
{{:cours:programmeavecbug.zip| Programme de test de debugging }}
  * Récupérer les coefficients du polynômes saisi au clavier avec conversion caractères vers double
</note>

== CORRIGE ==
{{:cours:corrigeprogrammeavecbug.zip| Calcul des racines d'une équation du 2d degré }}

<note>
Compétences acquises : 
  * Utiliser le debugger de Visual Studio pour placer des points d'arrêts et visualiser des variables en cours d'exécution 
  * Utilisation de l'instruction conditionnelle "If" 
  * Conversion de types de données 
</note>
----

=== Séance 3 : éléments du langage C# hors Objets et mise en oeuvre ===
== Durée : 2h ==

== Résumé de la Séance : ==

  * Revue des éléments du langage C# hors Objets et mise en oeuvre
      * Procédures et Fonctions

== Comparaison entre C# et VBA ==
{{:cours:lienVBA-CS.pdf|Exemple de codes écrits en C# et en VBA}}

== Code C# support de cours ==


{{:cours:fonctionprocedures.zip|Exemple introductif aux fonctions et procédures}}

{{:cours:fonctionslectureecriture.zip|Fonctions et procédures pour lire et écrire à la console}}

//Rappel// : Vous trouverez des compléments d'information sur [[:cours:cours_complet_C#|Cours Complet POO C# de Référence]]


== A FAIRE ==
<note warning>
Écrire un programme de test de parité d'un nombre

  * Il faudra demander de saisir un nombre au clavier
  * Récupérer la valeur entière saisie
  * Écrire une fonction booléenne qui teste la parité d'un entier
  * Tester avec l'appel de cette fonction la parité de l'entier saisi et
  * Afficher selon le message "est pair" ou "est impair"

Nota : utiliser les fonctions de lecture écriture ci-dessus.
</note>

== CORRIGE ==
{{:cours:parite.zip| Deux versions de la parité d'un nombre }}


<note>
Compétences acquises : 
  * Écriture de fonctions, de procédures et réutilisation dans un programme
  * Conversion programme VBA vers C# 
</note>
----

=== Séance 4 : éléments du langage C# hors Objets et mise en oeuvre :  ===

== Durée : 2h ==

== Résumé de la Séance : ==
  * Opérateurs du langage C#
  * [[https://msdn.microsoft.com/fr-fr/library/ms173143.aspx|Instructions du langages C#]]
  * [[https://docs.microsoft.com/fr-fr/dotnet/csharp/language-reference/keywords/while|Les boucles while et for]]

== Code C# support de cours == 
{{:cours:boucles.zip|Exemples de boucles : la somme des n premiers entiers}}


== A FAIRE ==
<note warning>
  * Application directe : calcul de nombre factoriel
  * Programme de calcul mental. Écrire un programme qui affiche des équations du type "x + 12 = 36" et qui demande à l'utilisateur quelle est la valeur de x. Le programme propose 10 équations en tout et affiche le score final, par exemple 3/10 si on a répondu correctement à 3 équations sur 10. 
  * Programme de calcul mental (facultatif). L'utilisateur a maintenant 3 tentatives pour chaque équations. Le score est calculé ainsi : 3pts si la valeur est trouvée en une seule tentative, 2pts en 2 tentatives, 1pt en une tentative et Opt si la valeur n'est pas trouvée.
</note>
{{:cours:CalculMental.zip|Code C# à compléter pour le calcul mental}}

== CORRIGE ==
{{:cours:calculmentalsolution.zip|Calcul mental}}

//Rappel// : Vous trouverez des compléments d'information sur [[:cours:cours_complet_C#|Cours Complet POO C# de Référence]]

<note>
Compétences acquises : 
  * Boucles while
  * Lecture/écriture de données à la console
  * Utilisation du tirage aléatoire d'un entier 
</note>

== A FAIRE (en séance) ==
<note warning>
  * écrire une fonction qui renvoie le produit scalaire de deux vecteurs.
  * écrire un programme Colle qui prend des mots passés en paramètre du main et qui les colle séparés par _, lancer le programme dans le terminal (cmd). Exemple : //Colle.exe il fait beau// doit afficher il_fait_beau.
  * compléter le projet sur les tableaux en ajoutant la multiplication vectorielle(matrice par vecteur) ainsi que la lecture d'une matrice.
</note>

----
=== Séance 5 : éléments du langage C# hors Objets : types complexes ===

  * Types complexes : tableaux

== Code C# support de cours == 

{{:cours:tableauxcours.zip|Manipulation de tableaux d'entiers}}



== A FAIRE (en séance) ==
<note warning>
  * écrire une fonction qui renvoie le produit scalaire de deux vecteurs.
  * écrire un programme Colle qui prend des mots passés en paramètre du main et qui les colle séparés par _, lancer le programme dans le terminal (cmd). Exemple : //Colle.exe il fait beau// doit afficher il_fait_beau.
</note>

<note>
Compétences acquises : 
  * manipulation de tableaux d'entiers
</note>

//Rappel// : Vous trouverez des compléments d'information sur [[:cours:cours_complet_C#|Cours Complet POO C# de Référence]]


----

=== Travail personnel évalué ===
== A FAIRE  ==
<note warning>
  * compléter le projet sur les tableaux en ajoutant la multiplication vectorielle(matrice par vecteur) ainsi que la lecture d'une matrice.
</note>
== DATES d'évaluation ==
  * Rendu de l'exercice  par email avant le 24/10/17 minuit. Ce rendu prendra la forme :
    * d'un fichier .zip de l'arborescence des répertoires et de fichiers de votre solution Visual Studio 
    * attaché à un mail dont l'objet sera le suivant : [RENDU TP MATRICES BAT4][<votre Nom>]
  * Sur questionnaire papier portant sur ce travail et qui vous sera distribué la semaine de retour des vacances


=== Pour préparer le contrôle de la rentrée ===
{{:cours:tableauescalieroumultidimension.zip|Compléments sur les tableaux : tableaux en escaliers int[,] versus tableaux multi-dimensionnels int[][])}}


----

=== Séance 6 : Introduction du langage C# : types complexes ===

  * Types complexes : struct

== Code C# support de cours == 
{{:cours:polygonecours.zip|La struct Rectangle}}


== A FAIRE  ==
<note warning>
  * Application directe : compléter le projet sur les rectangles en ajoutant le calcul de l'aire du rectangle (des 2 façons, avec ou sans struct)
  * DecoAndCo : On veut repeindre les murs d'un appartement en utilisant la même peinture dans toutes les pièces. On vous demande d'écrire un programme qui lit le pouvoir couvrant de la peinture (i.e. le nombre de m2 que le pot permet de couvrir) puis qui lit les caractéristiques des pièces de l'appartement (nom, hauteur, largeur, longueur), qui affiche pour chaque pièce la surface à peindre et le nombre de pots nécessaires. A la fin, le nombre de pots total est affiché.
</note>

== CORRIGE ==
{{:cours:decoandco.zip| Déco And Co}}

<note>
Compétences acquises : 
  * Créer et manipuler un struct
  * Passer d'un problème à un programme qui modélise ce problème
  * Décomposer un problème en parties => choix des fonctions ou procédures
</note>

//Rappel// : Vous trouverez des compléments d'information sur [[:cours:cours_complet_C#|Cours Complet POO C# de Référence]]

----

=== Séance 7 : Premiers pas vers la programmation orientée Objet par l'exemple ===

  * Des structures aux objets …
      * et si on intégrait des procédures et des fonctions dans un type complexe ?
  * Introduction à la POO : Classes et Objets
  * Portage d'une application simple en C# programmée selon une approche procédurale vers une approche orientée objet
  * Définition d'une //classe//, ses //attributs //et ses //méthodes //

== Code C# support de cours == 

{{:cours:poutre.zip|Exemple de programme manipulant des objets : de la struct poutre à la classe poutre}}

//Rappel// : Vous trouverez des compléments d'information sur les classes sur [[https://msdn.microsoft.com/fr-fr/library/ey4ke239(v=vs.90).aspx]]

== A FAIRE  ==
<note warning>
  * Application directe 1 : reprendre votre solution Polygone pour remplacer la struct Rectangle par une classe Rectangle
  * Application directe 2 : reprendre votre solution DecoAndCo pour remplacer la struct Piece par une classe Piece
  * DecoAndCo cont'd : il s'agit maintenant de repeindre la maison. Votre programme principal contient un tableau de pièces. On demande le nombre de pièces, on lit les caractéristiques des pièces à la console puis on affiche :
     * la surface au sol de la maison
     * la surface totale à peindre (on ne peint que les murs)
     * le nombre de pots de peintures nécessaires pour peindre la maison.
</note>

== CORRIGE ==
{{:cours:rectangle.zip| Classe Rectangle : 1ère version}}

{{:cours:decoandco2.zip| DecoAndCo V2 : version avec la classe Piece}}

----

=== Séance 8 : Séance Programmation orientée Objet en C# (4h) ===
  * champs et méthodes //publics ou privés//
  * Propriétés
  * Constructeurs

** Exemple d'illustration du private versus public et de l'intérêt des propriétés **

{{:cours:exerciceproprietes.zip|Solution de l'exemple d'illustration en C#, Gestion des chaines de caractères contenant un entier}}

//Rappel// : Vous trouverez des compléments d'information sur [[:cours:cours_complet_C#|Cours Complet POO C# de Référence]]

== A FAIRE ==
<note warning>
- Définissez dans la classe rectangle deux propriétés pour éviter qu'une longueur ou qu'une largeur soit inférieure ou égal à 0. 
- Écrire le constructeur par défaut qui initialise les côtés à 0.
</note> 

== CORRIGE ==
{{:cours:rectangle_exercice_avec_proprietes_et_exit.zip|Classe Rectangle avec propriétés pour éviter qu'une longueur ou qu'une largeur soit inférieure ou égal à 0 et sortie de l'application dans le cas contraire}}

<note>
Compétences acquises : 
  * Utilisation des propriétés (ex. public double largeur ... get{}, set{} et mot clef value)
  * Remplacement du constructeur par défaut par un constructeur explicite (ex. public Rectangle(double la, double lo))
</note>
----
=== Séance 9 : Introduction à la programmation orientée Objet en C# ===


  * Héritage : l'héritage est un concept clé des langages orientés objet qui permet de factoriser et de mieux structurer le code. Nous allons juste aborder cette notion, sans rentrer dans toutes les possibilités offertes.

Pour les curieux, les explications détaillées sont là [[https://docs.microsoft.com/fr-fr/dotnet/csharp/programming-guide/classes-and-structs/inheritance||https://docs.microsoft.com/fr-fr/dotnet/csharp/programming-guide/classes-and-structs/inheritance]].


== A FAIRE ==
<note warning>
  - Exercice de cours : Écrire une classe "carré" qui contiendra les mêmes attributs et méthodes que la classe rectangle (héritage) puisqu'il s'agit d'un rectangle particulier. Trois objets seront alors instanciés et testés.
  - Gestion de véhicules. On vous donne la classe Vehicule et la classe Voiture qui étend Vehicule. On vous donne aussi le programme qui gère un tableau de Voiture. 
   * Vous devez créez la classe Moto. En plus des caractéristiques d'un véhicule, une moto a une cylindrée comprise entre 50 et 1000. Le permis nécessaire est le "AM" si la cylindrée est 50, le "A1" si la cylindrée est 125 et le "A2" sinon. 
   * Ajoutez un tableau de motos dans le programme principal. Créez quelques motos et affichez toutes les voitures puis toutes le motos. 
   * plutôt qu'utiliser un tableau de Voiture et un tableau de Moto, utilisez un tableau de Vehicule et pour y stocker aussi bien des Moto que des Voiture.
</note>

{{:cours:vehicules_acompleter.zip| La solution des véhicules à compléter}}
 
//Rappel// : Vous trouverez des compléments d'information sur [[:cours:cours_complet_C#|Cours Complet POO C# de Référence]]

== CORRIGE ==

{{:cours:rectangle_virtual_override.zip|Classe Carre qui hérite Rectangle. Version avec new et override}}

{{:cours:vehicules.zip|Les véhicules avec héritage}}

<note>
Compétences acquises : 
  * Héritage d'une classe (ex. Class Carre : Rectangle)
  * Écriture d'un constructeur dans la classe qui hérite (ex. public Carre(c): base (c,c) dans le cas de la classe héritée Rectangle)
  * Champs protected plutôt que private pour les utiliser au travers de l'héritage
  * Surcharge d'une méthode dans la classe qui hérite avec le mots clef "new" 
  * Utilisation d'une méthode de la classe héritée dans la classe qui hérite (ex. base.affiche())
</note>

----
=== Séance 10 : Programmation orientée Objet et Interface Graphique ===

Programmation d'une interface graphique dans un projet Winforms (Windows Forms) en trois temps :
  - instanciation des objets graphiques (appelés aussi widgets)
        * illustration du concept d'instance de classe
  - modification des propriétés des objets graphiques
  - programmation du comportement de l'application dans les méthodes événementielles des objets graphiques

{{:cours:manipulationinterfacegraphique.pdf |Tutoriel sur les projets de type WinForms avec VisualStudio}}.

== A FAIRE ==
<note warning>
  - Exercice de cours : construire pas à pas votre première interface graphique en suivant le tutoriel ci-dessus.
  - Application : un compteur graphique. 
    * créer une classe qui gère un compteur initialisé à 0, incrémentable avec incr(), réinitialisable avec reset(), lu avec val().
    * en suivant les étapes décrites ci-dessus, créer une interface graphique contenant un bouton qui changera de couleur et de nom quand la souris passera dessus (Rouge/"OUT" et Vert/"IN")
    * Afficher dans la fenêtre principale le compteur qui s'incrémentera à chaque click sur ce bouton ci-dessus,
    * Ajouter un bouton de Reset pour réinitialiser le compteur à 0.
</note>

<note>
Compétences acquises : 
Après ces manipulations, vous devez être capables de créer des programmes C# similaires aux programmes que vous avez développés en mode console et leur rajouter des interfaces graphiques.
</note>
[[http://cplus.about.com/od/learnc/ss/random.htm|Autre référence : C# Programming Tutorial - Programming Winforms in C#]]

----
=== Séance 11 : Test en séance sur la programmation objet ===
  * Écriture d'une classe en mode console
  * QCM sur les objets + questions sur la classe que vous devez écrire.

== Correction en mode console ==

{{:cours:consoleapp1.zip|fichier .zip du projet console manipulant les compteur_set et compteur_nonset}}
----
=== Séance 12 : Interface graphique pour une application métier ===
  * Intégration d'un code métier dans une interface graphique
  * règles de bonnes structuration pour séparer l'affichage (interface graphique) du calcul (code métier):
     - les objets métiers sont déclarés dans la classe Form1,
     - ils sont initialisés dans le constructeur Form1(),
     - les méthodes événementielles (par exemple, le clic souris) :
       * invoquent une méthode sur l'objet métier (par exemple, reset) et affichent l'information correspondante dans un composant graphique (par exemple la valeur 0) 
       * ou à l'inverse, elles récupèrent une information d'un composant (par exemple, une nouvelle valeur) et invoquent une méthode de l'objet métier (par exemple, la méthode Set).

  * REMARQUE : la méthode d'affichage dans la console n'a plus lieu d'être utilisée dès lors que vous travailler avec des WinForms.

== A FAIRE ==
<note warning>
Il s'agit de créer une interface graphique pour le compteur écrit lors de la séance de test. 
  - Finir le code du compteur (code métier), avec les deux versions : compteur qui peut prendre n'importe quelle valeur (Compteur_set), compteur qui ne peut être initialisé qu'à 0 (Compteur_non_set).
  - Créez une interface (projet WinForm) contenant :
    * un TextBox (champ de texte modifiable) qui affiche la valeur du Compteur_set et un Label qui affiche la valeur du Compteur_non_set
    * 5 boutons : //quit// positionné en bas au centre de la fenêtre, //reset// et //incr// positionnés sous le Compteur_set, //reset// et //incr// positionnés sous le Compteur_non_set
    * comportement : appuyer sur //reset// remet le compteur correspondant à 0, appuyer sur //incr// l'incrémente et appuyer sur //quit// ferme la fenêtre.
  - On aurait pu choisir d'afficher le Compteur_non_set dans un TextBox, comment faire pour que le comportement soit cohérent ?
</note>


== Correction en mode console et graphique ==

{{:cours:correction_compteurs_console_winform.zip|fichier .zip des projets Console et Winforms manipulant les compteur_set et compteur_nonset}}

----
=== Séance 13 : Utilisation d'Excel depuis un programme C# ===
Il s'agit d'utiliser une API pour lire/écrire des informations depuis/dans un fichier excel.

== A FAIRE ==
<note warning>
  * télécharger la librairie suivante : {{:cours:excellibrary.zip|ExcelLibray.dll}}, sauvez-la sur votre machine et dé-zipez-la pour récupérer ExcelLibray.dll
  * créer un projet console
  * indiquer que ce projet utilisera cette librairie. Pour cela, menu projet -> ajouter une reference -> parcourir et chercher le fichier ExcelLibray.dll
  * copier/coller le code qui se trouve dans le fichier Program.cs dans la classe Program. {{:cours:program.zip|Program.cs}}
  * exécuter le programme et comprenez ce qu'il fait. 

**Nota 1** : vérifier que le fichier excel a bien été créé, s'il y a un problème de chemin, changer la variable path dans le programme
**Nota 2** : si vous interrompez l'exécution de votre programme C#, le fichier excel reste ouvert. Il faut donc tuer le processus excel qui a été créé via le gestionnaire des tâches.
</note>
{{:cours:excellibrarysol.zip|Pour ceux qui veulent utiliser toutes les fonctionnalité de l'interopérabilité excel, voici la solution de la librairie excel, que vous pouvez étendre si besoin.}}

{{:cours:cours_interoperabilite_avec_c_-_excel.pdf|Cours sur l'interopérabilité avec Excel en C#}}
[[http://csharp.net-informations.com/excel/csharp-excel-tutorial.htm|Tutorial Utilisation d'Excel en C#]]

----


== TP final ==
Ce TP est à faire en séance. A la fin de la séance, vous devrez impérativement envoyer une archive TPfinal.zip à votre responsable de TD dans un mail dont le sujet est : [BAT4] TP final. Ceux qui souhaitent aller plus loin pourront améliorer leur travail en envoyant un mail identique avec une version plus avancée au plus tard le vendredi 22 décembre.

<note warning>
Il s'agit d'afficher dans une interface WINFORM les informations calculées dans un fichier excel qui donnent la classe d'énergie d'un bâtiment en fonction de son SHON et du volume consommé dans les différentes énergies (gaz, fuel ...). Ce fichier provient en partie de l'ADEME.
Les entrées de ce fichier excel sont le SHON et la consommation des différentes énergies. La sortie est une X en face de la classe énergétique (A, B, C,... G). **Vous n'avez pas le droit de modifier ce fichier.**
  * a minima, il faudra fournir dans votre interface graphique en C# un moyen de modifier le SHON et d'afficher la classe énergétique
  * il pourra être intéressant de permettre de modifier aussi les consommations énergétiques
  * l'affichage de la classe énergétique pourra être simplement un label
  * il pourra être intéressant d'afficher une flèche en face du logo des classes énergétiques de l'ADEME.
</note>

L'archive {{cours:tpfinal.zip|TPFinal.zip}} contient :
  * les fichier excel à traiter
  * la dll permettant de lire et écrire dans un fichier excel à partir de C#
  * un exemple d'utilisation de cette dll
  * l'image du logo de l'ADEME ainsi que l'image d'une flèche

----

** Introduction aux bases de données. Exemple de MySQL (1h30 19/01/15)**
[[http://www.mysql.fr/why-mysql/windows/|Site de Téléchargement et d'Installation de MySQL pour Windows]]

  * Installation et configuration de MySQL
  * Manipulation de MySQL 
{{:cours:inrtroduction_base_de_donnees.pdf|Introduction Base e données:MySQL}}

{{:cours:td_mysql.pdf|TD Utilisation de MySQL dans un Programme C#}}
** Utilisation de Scilab depuis un programme C# **

{{:cours:c_.zip| exemple de projet C# utilisant les librairies scilab }}


=== Autres éléments de cours ===

== Import de DLL  ==
  * Import de DLL installée sur la machine (Références / ajouter référence) 
  * Exemple avec System.Speech. Voir la  {{:cours:simple_exemple_import_system.speech.zip|solution}}.


== Cours et illustrations des Notions de Programmation Orientée Objet en C# ==


{{:cours:salaireinterface.zip|Exemple de solution Visual Studio 2012: Interface Salarié}}

{{:cours:cours_2_introduction_aux_objets_c_.pdf|Support du cours 2 Programmation Orienté Objet en C#}}

{{:cours:consolemapremiereclasse.zip|Exemple de Solution Visual Studio 2013 : Ma première classe en C#}}

** Les CONSTRUCTEURS **
{{:cours:consolelesconstructeurs.zip|Exemple de Solution Visual Studio 2013 : Les constructeurs d'une classe en C#}}

**Les PROPRIETES **

{{:cours:sol2_propriete_contructeur.7z|Exemple de Solution Visual Studio 2013 : une propriété dans une classe en C#}}

**Les MEMBRES STATIQUES de CLASSE  **

{{:cours:sol3_static_non_static.zip|Exemple de Solution Visual Studio 2013 : méthodes et attributs  statiques en C#}}

[[cours:exercicesPOOBAT4Exam|Exercices Programmation orientée Objet de base en C#]]

**Les exceptions  **

  * try / catch 
  * try / finally 

**Pour les plus avancés, membres static et héritage ... **

[[cours:exercicesPOOBAT4Classes|Exercices POO et Références de classe]]


**Pour les plus avancés, un peu d'algorithmique en C# ...**

[[cours:exercicesPOOBAT4Avance|Exercices POO et Algorithmique]]





===== Zone Enseignant =====
[[:cours:Cours Environnement_Logiciel_et_Programmation_Zone_Enseignant|Cours BAT Env Log Zone Enseignant]]

===== Années précédentes =====
[[:cours:Cours Environnement Logiciel et Programmation 2013 2014|Cours BAT Env Log 2013 2014]]
[[:cours:Cours Environnement Logiciel et Programmation 2015 2016|Cours BAT Env Log 2015 2016]]
[[:cours:Cours Environnement Logiciel et Programmation 2015 2016|Cours BAT Env Log 2017 2018]]