static void Main(string[] args)
{
PruefDb db = PruefDb.FromMockup();
// *************************************************************************************
// MUSTERBEISPIELE
// *************************************************************************************
// 1. Suche den Schüler mit der ID 1003
// Where liefert IEnumerable, also immer eine Collecion.
// Deswegen brauchen wir First, um auf das erste Element zugreifen
// zu können.
Schueler result1 = db.Schuelers.Where(s => s.Id == 1003).First();
// 2. Welcher Schüler hat die Id 999?
// First liefert eine Exception, da die Liste leer ist.
// FirstOrDefault liefert in diesem Fall den Standardwert (null).
Schueler result2 = db.Schuelers.Where(s => s.Id == 999).FirstOrDefault();
// 3. Wie viele Schüler sind in der Liste?
int result3 = db.Schuelers.Count();
// 4. Wie viele Schüler gehen in die 3BHIF?
int result4 = db.Schuelers.Where(s => s.Klasse == "3BHIF").Count();
// Für Count existiert eine Überladung, die auch eine Filterfunktion
// bekommen kann.
result4 = db.Schuelers.Count(s => s.Klasse == "3BHIF");
// *************************************************************************************
// ÜBUNGEN
// *************************************************************************************
// 5. Welche Note hat die Prüferin FAV bei ihrer schlechtesten Prüfung vergeben.
// Schreibe das Ergebnis mit dem richtigen Datentyp in die Variable result5 (kein var verwenden!).
object result5 = null;
Console.WriteLine($"Beispiel 5: FAV gab schlechtestens die Note {result5}.");
// 6. Welchen Notendurchschnitt haben die weiblichen Schülerinnen in POS?
// Schreibe das Ergebnis mit dem richtigen Datentyp in die Variable result6 (kein var verwenden!).
object result6 = null;
Console.WriteLine($"Beispiel 6: Notenschnitt der Schülerinnen in POS: {result6:0.00}");
// 7. Welche Schüler haben 6 oder mehr Prüfungen? Gib eine Liste von Schülern zurück und gib Sie aus.
// Schreibe das Ergebnis mit dem richtigen Datentyp in die Variable result7 (kein var verwenden!).
object result7 = null;
Console.WriteLine("Beispiel 7: Schüler mit mehr als 6 Prüfungen.");
result7.ToList().ForEach(s => { Console.WriteLine($" {s.Name} {s.Vorname} hat mehr 6 oder mehr Prüfungen."); });
// 8. Welche Schüler haben eine DBI Prüfung? Gib eine Liste von Schülern zurück und gib sie aus.
// Hinweis: kombiniere Where und Any, indem Any in der Where Funktion verwendet wird.
// Schreibe das Ergebnis mit dem richtigen Datentyp in die Variable result8 (kein var verwenden!).
object result8 = null;
Console.WriteLine("Beispiel 8: Schüler mit DBI Prüfungen.");
result8.ToList().ForEach(s => { Console.WriteLine($" {s.Name} {s.Vorname} hat eine DBI Prüfung."); });
// 9. Gibt es Schüler, die nur in POS eine Prüfung haben? Gib eine Liste von Schülern zurück und gib sie aus.
// Hinweis: kombiniere Where und All, indem All in der Where Funktion verwendet wird.
// All gibt auch Schüler aus, die keine Prüfung haben. Dies kann so belassen werden.
// Schreibe das Ergebnis mit dem richtigen Datentyp in die Variable result9 (kein var verwenden!).
object result9 = null;
Console.WriteLine("Beispiel 9: Schüler, die nur in POS eine Prüfung haben.");
result9.ToList().ForEach(s => { Console.WriteLine($" {s.Name} {s.Vorname} hat nur in POS eine Prüfung."); });
// 10. Welche Schüler haben keine POS Prüfung? Gib eine Liste von Schülern zurück und gib sie aus.
// Hinweis: kombinieren Where und Any, indem Any in der Where Funktion verwendet wird.
// Schreibe das Ergebnis mit dem richtigen Datentyp in die Variable result10 (kein var verwenden!).
object result10 = null;
Console.WriteLine("Beispiel 10: Schüler, die keine POS Prüfung haben.");
result10.ToList().ForEach(s => { Console.WriteLine($" {s.Name} {s.Vorname} hat keine POS Prüfung."); });
// 11. Welche Schüler haben überhaupt keine Prüfung? Gib eine Liste von Schülern zurück und gib sie aus.
// Hinweis: Verwende das Count Property.
// Schreibe das Ergebnis mit dem richtigen Datentyp in die Variable result11 (kein var verwenden!).
object result11 = null;
Console.WriteLine("Beispiel 11: Schüler, die überhaupt keine Prüfung haben.");
result11.ToList().ForEach(s => { Console.WriteLine($" {s.Name} {s.Vorname} hat keine Prüfung."); });
// 12. Welche Schüler hatten in Juni AM Prüfungen? Gib eine Liste von Prüfungen zurück und gib sie mit dem Schülernamen aus.
// Hinweis: Verwende das Month Property des Datum Feldes.
// Schreibe das Ergebnis mit dem richtigen Datentyp in die Variable result12 (kein var verwenden!).
object result12 = null;
Console.WriteLine("Beispiel 12: Schüler, die im Juni eine AM Prüfung hatten.");
result12.ToList().ForEach(p => { Console.WriteLine($" {p.Schueler.Name} {p.Schueler.Vorname} hat bei {p.Pruefer} eine Prüfung in AM."); });
// 13. Welche Schüler haben bei einer AM Prüfung eine negative Note,
// aber in E nur positive Prüfungen?
// Schreibe das Ergebnis mit dem richtigen Datentyp in die Variable result13 (kein var verwenden!).
object result13 = null;
Console.WriteLine("Beispiel 13: Schüler, die in AM einmal negativ, aber in E immer positiv waren.");
result13.ToList().ForEach(s => { Console.WriteLine($" {s.Name} {s.Vorname} war in AM negativ, in E aber nie."); });
// 14. Welche Schüler haben im Mittel bessere DBI Prüfungen als D Prüfungen. Anders gesagt: Bei wem
// ist der Notenschnitt der DBI Prüfungen kleiner als der Notenschnitt der D Prüfungen.
// Gib eine Liste von Schülern zurück, auf die das zutrifft.
// Hinweise:
// -) Wenn mit Where gefiltert wird, kann es sein, dass eine leere Liste zurückkommt.
// -) Average kann nur von einer Liste mit Elementen aufgerufen werden.
// -) Erstelle daher eine Lambda Expression mit try und catch im inneren, die false im Fehlerfall liefert.
// Schreibe das Ergebnis mit dem richtigen Datentyp in die Variable result14 (kein var verwenden!).
object result14 = null;
Console.WriteLine("Beispiel 14: Schüler, in DBI bessere Prüfungen (Notenschnitt) als in D hatten.");
result14.ToList().ForEach(s => { Console.WriteLine($" {s.Name} {s.Vorname} ist in DBI besser als in D."); });
}
static void Main(string[] args)
{
PruefDb db = PruefDb.FromMockup();
// *************************************************************************************
// MUSTERBEISPIELE
// *************************************************************************************
// Liefere eine Liste aller Prüfungsfächer (IEnumerable<string>)
// Mit Select kann man sich aussuchen, welche Properties geliefert werden.
// Select nennt man auch "Projektion"
IEnumerable <string> uebung1 = db.Pruefungen.Select(p => p.Fach);
// Liste beinhaltet D, E, E, AM, D, AM, ...
IEnumerable <string> uebung2 = db.Pruefungen.Select(p => p.Fach).Distinct();
// Liste beinhaltet D, E, AM, POS, DBI (jedes Fach nur 1x)
// Liefere eine Liste aller Schüler mit der Anzahl der Prüfungen
// als Objekt Name, Vorname, Anzahl
// Der Compiler legt eine anonyme Klasse an:
// class A {
// string Name {get;set;}
// string Vorname {get;set;}
// int Anzahl {get;set;}
// }
var uebung3 = db.Schuelers.Select(s => new
{
Name = s.Name,
Vorname = s.Vorname,
Anzahl = s.Pruefungen.Count() // Propertynamen festlegen
}).OrderBy(x => x.Anzahl).ThenBy(x => x.Name);
// Welche Schüler haben mehr als 6 Prüfungen?
var uebung4 = uebung3.Where(p => p.Anzahl > 6);
// Liefere ein JSON Objekt mit folgendem Aufbau:
// {
// Name: Mustermann,
// Vorname: Max,
// Pruefer: [KY, FAV]
// },...
var uebung5 = db.Schuelers.Select(s => new
{
s.Name,
s.Vorname,
Pruefer = s.Pruefungen.Select(p => p.Pruefer).Distinct()
});
WriteJson(uebung5, "Beispiel 5 - Schüler mit Prüfer", true);
// Liefere ein JSON Objekt mit folgendem Aufbau:
// {
// Name: "Mustermann,"
// Vorname: "Max",
// db.Pruefungen: [{"Pruefer"="KY", "Fach"="AM"}, ...]
// },...
var uebung6 = db.Schuelers
.Where(s => s.Id < 1010)
.Select(s => new
{
s.Name,
s.Vorname,
Pruefungen = s.Pruefungen.Select(p => new
{
p.Pruefer,
p.Fach
}),
Anzahl = s.Pruefungen.Count(),
});
WriteJson(uebung6, "Beispiel 6 - Schüler mit Prüfungen", true);
// *************************************************************************************
// ÜBUNGEN
// Schreibe in den nachfolgenden Übungen statt der Zeile
// object resultX = null;
// die korrekte LINQ Abfrage. Verwende den entsprechenden Datentyp statt object.
// *************************************************************************************
// 1. Drucke eine Liste aller Fächer. Hinweis: Verwende Distinct, um doppelte Einträge
// zu entfernen. Speichere das Ergebnis in IEnumerable<string>.
IEnumerable <string> result1 = db.Pruefungen
.Select(p => p.Fach)
.Distinct();
Console.WriteLine("Die Prüfungsfächer sind " + String.Join(",", result1));
// 2. Ermittle die schlechteste Prüfungsnote in E. Dabei verwende allerdings die Max
// Funktion ohne Parameter, indem vorher eine Liste von int Werten erzeugt wird.
int result2 = db.Pruefungen
.Where(p => p.Fach == "E")
.Select(p => p.Note)
.Max();
Console.WriteLine($"Die schlechteste E Note ist {result2}");
// 3. Liefere eine Liste mit Klasse, Name, Vorname und der Anzahl der Prüfungen
// (soll Anzahl heißen) der 3CHIF. Sortiere die Liste nach Klasse und Name.
// Hinweis: Verwende OrderBy und dann ThenBy.
var result3 = db.Schuelers
.Where(s => s.Klasse == "3CHIF")
.OrderBy(s => s.Klasse)
.ThenBy(s => s.Name)
.Select(s => new
{
s.Klasse,
s.Vorname,
s.Name,
Anzahl = s.Pruefungen.Count(),
});
Console.WriteLine("Beispiel 3");
result3.ToList().ForEach(s => { Console.WriteLine($" {s.Klasse}: {s.Name} {s.Vorname} hat {s.Anzahl} Prüfungen."); });
// 4. Liefere eine Liste der Schüler (Klasse, Name, Vorname) der 3BHIF mit ihren Prüfungsfächern.
// Die Fächer sollen als Stringliste (IEnumerable<string> ohne doppelte Einträge
// in das Property Faecher gespeichert werden.
var result4 = db.Schuelers
.Where(s => s.Klasse == "3BHIF")
.Select(s => new
{
s.Klasse,
s.Name,
s.Vorname,
Faecher = s.Pruefungen.Select(p => p.Fach).Distinct()
});
Console.WriteLine("Beispiel 4");
result4.ToList().ForEach(s => { Console.WriteLine($" {s.Klasse}: {s.Name} {s.Vorname} hat {String.Join(",", s.Faecher)}"); });
// 5. Liefere eine Liste aller Schüler der 3AHIF (Name, Vorname) mit ihren negativen
// Prüfungen. Dabei soll unter dem Property "NegativePruefungen"
// ein neues Objekt mit Datum und Fach aller negativen Prüfungen (Note = 5)
// erzeugt werden. Es sind natürlich 2 new Anweisungen nötig.
// Außerdem sollen nur Schüler der 3AHIF berücksichtigt werden.
var result5 = db.Schuelers
.Where(s => s.Klasse == "3AHIF")
.Select(s => new
{
s.Name,
s.Vorname,
NegativePruefungen = s.Pruefungen
.Where(p => p.Note == 5)
.Select(p => new
{
p.Datum,
p.Fach,
p.Note
})
});
Console.WriteLine("Beispiel 5");
foreach (var schueler in result5)
{
Console.WriteLine($" Negative Prüfungen von {schueler.Name} {schueler.Vorname}:");
foreach (var pruef in schueler.NegativePruefungen)
{
Console.WriteLine($" {pruef.Fach} am {pruef.Datum.ToString("dd.MM.yyyy")}");
}
}
// 6. Liefere eine Liste aller Prüfer mit ihren besten und schlechtesten
// Prüfungsergebnis. Gehe dabei so vor: Erzeuge mit Select und Distinct
// eine Stringliste aller Prüfer. Davon ausgehend erzeuge - wieder mit Select -
// ein neues Objekt mit den Properties Pruefer, BesteNote und SchlechtesteNote.
// BesteNote und SchlechtesteNote werden wieder von allen Prüfungen mit entsprechdem
// Where Filter berechnet.
// Später werden wir dieses Problem mit Group by lösen.
var pruefers = db.Pruefungen.Select(p => p.Pruefer).Distinct();
var result6 = pruefers
.Select(p => new
{
Pruefer = p,
BesteNote = db.Pruefungen.Where(pr => pr.Pruefer == p).Min(pr => pr.Note),
SchlechtesteNote = db.Pruefungen.Where(pr => pr.Pruefer == p).Max(pr => pr.Note),
});
Console.WriteLine("Beispiel 6");
result6.ToList().ForEach(p => { Console.WriteLine($" {p.Pruefer} gibt Noten von {p.BesteNote} bis {p.SchlechtesteNote}"); });
}