OO Programmeren Labo 12 Herhaling

Doelstelling

1. Overzicht van de gemaakt klassen in het SchoolAdmin project
2. Ordenen van de code in Program.cs

Stappenplan

1. Overzicht van de klassen in het SchoolAdmin project
   Met UML (Unified Modelling Language) kan je de klassenstructuur visueel voorstellen. In één oogopslag krijg je een overzicht.
   1. Uitleg bij de gebruikte symbolen

      access-modifiers voor leden:

      1. public (+)
      2. private (-)
      3. protected (#)
      4. static (onderlijnd)
      5. abstract
         De naam van een abstracte klasse wordt in schuinschrift weergegeven.
         Een abstracte methode geef je aan door deze in schuinschrift in het klassendiagram te schrijven.
   2. School

      

   3. Person, Student, Lecturer en AdministrativeStaff

      

   4. Course, LabCourse, TheoryCourse en Seminar

      
2. Ordenen van de code in Program.cs
   In de Program klasse in het bestand Program.cs staat alle code die we geschreven hebben om de klassen uit te proberen. We gaan die nu ordenen door gebruik te maken van functies. Hiermee leer je nog eens waarvoor functies gebruikt kunnen worden, namelijk statements, die één bepaalde doelstelling hebben, groeperen onder één naam. Ik baseer me op de ingestuurde opdracht van de student Elie Mukau Ambel, die zijn code in Program.cs al op die manier geordend heeft.
   2. Overzicht

      

   3. We beginnen met het menu te plaatsen in de Main methode van de Program klasse. Op die manier hebben we een mooi overzicht:

      static void Main(string[] args)
      {
          bool done = false;
          while (!done)
          {
              Console.WriteLine("Welkom bij Schoolbeheer!\n Maak een keuze uit de volgende lijst: ");
              Console.WriteLine("************************************************");
              Console.WriteLine("1. De School klasse testen");
              Console.WriteLine("2. De Student klasse testen");
              Console.WriteLine("3. De Lecturer klasse testen");
              Console.WriteLine("4. Een lijst met Person instanties maken");
              Console.WriteLine("5. De Administrative klasse gebruiken");
              Console.WriteLine("6. De associatie Lecturer en Course klasse");
              Console.WriteLine("7. De verschillende personen met naamkaartje weergeven");
      
              Console.WriteLine("0. Stoppen");
              int choise = int.Parse(Console.ReadLine());
              switch (choise)
              {
                  case 1:
                      TestSchool();
                      break;
                  case 2:
                      TestStudent();
                      break;
                  case 3:
                      TestLecturer();
                      break;
                  case 4:
                          MakePerson();
                      break;
                  case 5:
                      TestAdministrativeStaff();
                      break;
                  case 6:
                      TestLectureCourse();
                      break;
                  case 7:
                      PersonListMetNaamkaartje();
                      break;
                  case 0:
                      done = true;
                      break;
              }
          }
      }

   4. Labo 8 Arrays, lijsten en klassen
      1. We voegen de TestSchool methode in de Program klasse toe:

         static void TestSchool()
         {
             // Labo 8: 2 nieuwe scholen aanmaken, in list steken en in de console tonen
             School school1 = new School("GO! BS de Spits", "Thonetlaan 106", "2050", "Antwerpen", 1);
             School school2 = new School("GO! Koninklijk Atheneum", "Fr. Craeybeckxlaan 22", "2100", "Deurne", 2);
             School.List = new List<School>
             {
                 school1,
                 school2
             };
             Console.WriteLine(school1.ShowOne());   // Slechts één school tonen
             Console.WriteLine(School.ShowAll()); // alle scholen tonen
         }

      2. We voegen de TestStudent methode toe aan de Program klasse:

         static List<Student> TestStudent()
         {
             // Labo 8: 4 nieuwe studenten aanmaken en in list steken
             Student student1 = new Student("Mohamed", "El Farisi", new DateTime(1987, 12, 06), 1, 1, "0489000000");
             Student student2 = new Student("Sarah", "Jansens", new DateTime(1991, 10, 21), 2, 3, "0489000000");
             Student student3 = new Student("Bart", "Jansens", new DateTime(1991, 10, 21), 2, 3, "0489000000");
             Student student4 = new Student("Farah", "El Farisi", new DateTime(1987, 12, 06), 1, 4, "0489000000");
             Student.List = new List<Student>
             {
                 student1,
                 student2,
                 student3,
                 student4
             };
             Console.WriteLine(Student.ShowAll());   // Alle studenten tonen
             Console.WriteLine(student1.ShowOne());  // Slechts één student tonen
             return Student.List;
         }

   5. Labo 9 en 10: abstractie en overerving
      1. We voegen de methode TestLecturer aan de Program klasse toe:

         static List<Lecturer> TestLecturer()
         {
             // Labo 9 en 10: 2 nieuwe lectoren aanmaken en in een list steken
             Lecturer lecturer1 = new Lecturer("Adem", "Kaya", new DateTime(1976, 12, 01), 1, 1, "0489000000");
             Lecturer lecturer2 = new Lecturer("Anne", "Wouters", new DateTime(1968, 04, 03), 2, 2, "0489000000");
             Lecturer.List = new List<Lecturer>
             {
                 lecturer1,
                 lecturer2
             };
             Console.WriteLine(Lecturer.ShowAll());
             Console.WriteLine(lecturer1.ShowOne());
             return Lecturer.List;
         }

      2. We voegen de methode MakePerson aan de Program klasse toe:

         static List<Person> MakePerson()
         {
             // Labo 9 en 10: Een lijst van Person maken met zowel studenten als lectoren in
             // maak de lijst met studenten
             List<Student> studentList = TestStudent();
             // maak de lijst met lectoren
             List<Lecturer> lecturerList = TestLecturer();
             var persons = new List<Person>();
             foreach (Student student in studentList)
             {
                 persons.Add(student);
             }
         
             foreach (Lecturer lecturer in lecturerList)
             {
                 persons.Add(lecturer);
             }
             return persons;
         }
         

      3. We voegen de methode TestAdministrativeStaff aan de Program klasse toe:

         static void TestAdministrativeStaff()
         {
             // Labo 9 en 10: Object maken van AdministrativeStaff en toevoegen aan de lijst van personen
             var administrativeStaff1 = new AdministrativeStaff("Raul", "Jacob", new DateTime(1985, 11, 01), 1, 1, "0489000000");
             List<Person> persons = MakePerson();
             persons.Add(administrativeStaff1);
             Console.WriteLine(administrativeStaff1.ShowOne());
             foreach (var person in persons)
             {
                 Console.WriteLine($"{person.FirstName} {person.LastName}");
             }
             // Labo 9 en 10: De nameTagText tonen voor de 3 soorten personen
             // Zorg ervoor dat voor administratief personeel de tekst (ADMINISTRATIE)
             // verschijnt op het naamkaartje, vlak voor de volledige naam
             Console.WriteLine(administrativeStaff1.GetNameTagText());
         }

   6. Labo 11 Overerving en constructoren

      1. We voegen de methode TestLectureCourse aan de Program klasse toe:

         static void TestLectureCourse()
         {
             // Labo 11: Associëren van lectoren met hun cursussen en aanvullen ShowTaughtCourses()
             // Aanmaken van cursus OOP en associëren met lecturer1
             // Aanmaken seminarie Docker en associëren met lecturer1
             Course theory1 = new TheoryCourse("OO Programmeren", 3);
             Course seminar = new Seminar("Docker");
             Lecturer lecturer1 = new Lecturer("Adem", "Kaya", new DateTime(1976, 12, 01), 1, 1, "0489000000");
         
             lecturer1.Courses.Add(theory1);
             lecturer1.Courses.Add(seminar);
             Console.WriteLine($"{lecturer1.ShowTaughtCourses()}");
         }
         
         

      2. We voegen de methode PersonListMetNaamkaartje aan de Program klasse toe:

         static void PersonListMetNaamkaartje()
         {
             // Labo 11: Voeg een protected property ContactNumber(van type string) toe aan Person en zorg
             // dat deconstructoren dit ook aannemen; zorg dat dit getoond wordt op de naamkaartjes
             // van personeel(Lecturer en AdministrativeStaff) maar niet van studenten.
             Lecturer lecturer1 = new Lecturer("Adem", "Kaya", new DateTime(1976, 12, 01), 1, 1, "0489000000");
             Student student1 = new Student("Mohamed", "El Farisi", new DateTime(1987, 12, 06), 1, 1, "0489000000");
             var administrativeStaff1 = new AdministrativeStaff("Raul", "Jacob", 
                    new DateTime(1985, 11, 01), 1, 1, "0489000000");
             Console.WriteLine(student1.GetNameTagText());
             Console.WriteLine(lecturer1.GetNameTagText());
             Console.WriteLine(administrativeStaff1.GetNameTagText());
             Console.ReadLine();
         }