protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
SetContentView(Resource.Layout.tests_act);
SubjectsId = Intent.GetIntArrayExtra(Args.SUBJECTS_ID);
TestsData.NewInstance(SubjectsId);
FragmentsWatcher.NewInstance();
spinner = (Spinner)FindViewById(Resource.Id.tests_spinner);
viewPager = (ViewPager)FindViewById(Resource.Id.subject_test_viewPager);
}
static void Main(string[] args)
{
TestsData data = TestsData.FromFile("../db/tests.json");
// *************************************************************************************
// DEMO 1: Zeige alle Schüler der 3BHIF
// *************************************************************************************
IEnumerable <Pupil> demo1 = from p in data.Pupil
where p.P_Class == "3BHIF"
select p;
// Alternative mit Method Syntax:
demo1 = data.Pupil.Where(p => p.P_Class == "3BHIF");
// *************************************************************************************
// Schreibe in den nachfolgenden Übungen statt der Zeile
// object resultX = null;
// die korrekte LINQ Abfrage. Verwende den entsprechenden Datentyp statt object.
// *************************************************************************************
// ÜBUNG 1: Gib alle Tests des Lehrers ZUM in der 4EHIF aus.
// *************************************************************************************
// [{"TE_ID":450,"TE_Class":"4EHIF","TE_Teacher":"ZUM","TE_Subject":"BWM3","TE_Date":"2020-05-20T00:00:00","TE_Lesson":8},
// {"TE_ID":451,"TE_Class":"4EHIF","TE_Teacher":"ZUM","TE_Subject":"PRE","TE_Date":"2020-02-17T00:00:00","TE_Lesson":1}]
object result1 = null;
Console.WriteLine("RESULT1");
Console.WriteLine(JsonSerializer.Serialize(result1));
// *************************************************************************************
// ÜBUNG 2: Gib alle Stunden der 3BHIF mit dem Lehrer FZ geordnet nach Tag (L_Day) und
// Unterrichtsstunde (L_Hour) aus.
// *************************************************************************************
// [{"L_ID":27,"L_Untis_ID":16,"L_Class":"3BHIF","L_Teacher":"FZ","L_Subject":"DBI1","L_Room":"C2.10","L_Day":2,"L_Hour":1},
// {"L_ID":695,"L_Untis_ID":536,"L_Class":"3BHIF","L_Teacher":"FZ","L_Subject":"DBI1x","L_Room":"B3.07MM","L_Day":5,"L_Hour":5},
// {"L_ID":696,"L_Untis_ID":536,"L_Class":"3BHIF","L_Teacher":"FZ","L_Subject":"DBI1x","L_Room":"B3.07MM","L_Day":5,"L_Hour":6}]
object result2 = null;
Console.WriteLine(Environment.NewLine + "RESULT2");
Console.WriteLine(JsonSerializer.Serialize(result2));
// *************************************************************************************
// ÜBUNG 3: Wie Übung 2, allerdings soll ein neues Objekt mit den Properties Subject,
// Room, Day und Hour erstellt werden.
// *************************************************************************************
// [{"Subject":"DBI1","Room":"C2.10","Day":2,"Hour":1},
// {"Subject":"DBI1x","Room":"B3.07MM","Day":5,"Hour":5},
// {"Subject":"DBI1x","Room":"B3.07MM","Day":5,"Hour":6}]
object result3 = null;
Console.WriteLine(Environment.NewLine + "RESULT3");
Console.WriteLine(JsonSerializer.Serialize(result3));
// *************************************************************************************
// ÜBUNG 4: Gib alle Lehrer, die NW2 Tests (TE_Subject ist
// NW2) hatten, aus. Erstelle ein neues Objekt mit TeacherID und TeacherName.
// TeacherName ist eine Verknüpfung aus T_Lastname und T_Firstname.
// Hinweis: Verwende Any in der where Klausel.
// *************************************************************************************
// [{"TeacherId":"BOM","TeacherName":"Boltz Michael"},
// {"TeacherId":"BRA","TeacherName":"Bramkamp Heiko"},
// {"TeacherId":"CSR","TeacherName":"Csaszar Robert"},
// {"TeacherId":"HD","TeacherName":"Haidegger Ingrid"},
// {"TeacherId":"HOM","TeacherName":"H\u00F6rzinger Michael"},
// {"TeacherId":"MOS","TeacherName":"Moser Gabriele"},
// {"TeacherId":"PUH","TeacherName":"Puhm Ursula"},
// {"TeacherId":"WAA","TeacherName":"Wagner Anna"},
// {"TeacherId":"WK","TeacherName":"Wodnar Karl"}]
object result4 = null;
Console.WriteLine(Environment.NewLine + "RESULT4");
Console.WriteLine(JsonSerializer.Serialize(result4));
// *************************************************************************************
// ÜBUNG 5: In welchen Fächern (TE_Subject) gab nach der 7. Stunde Tests? Betrachte
// nur Klassen, wo SZ Klassenvorstand ist. Beachte, dass ein KV auch
// von mehreren Klassen KV sein kann.
// Die Fächer sind nur 1x auszugeben, verwende dafür Distinct(). Sortiere
// die Ausgabe nach dem Fach.
// *************************************************************************************
// ["BWM1","BWM2","DBI1","E1","GAD","GGPB","NVS1y","POS1"]
object result5 = null;
Console.WriteLine(Environment.NewLine + "RESULT5");
Console.WriteLine(JsonSerializer.Serialize(result5));
// *************************************************************************************
// ÜBUNG 6: Welche Tests fanden in Klassen mit SZ als Klassenvorstand an einem Montag
// statt? Verwende das DayOfWeek Property des Feldes TE_Date.
// *************************************************************************************
// [{"Class":"4AHIF","Teacher":"GAL","Subject":"E1"},
// {"Class":"4AHIF","Teacher":"NAI","Subject":"GGPB"}]
object result6 = null;
Console.WriteLine(Environment.NewLine + "RESULT6");
Console.WriteLine(JsonSerializer.Serialize(result6));
// *************************************************************************************
// ÜBUNG 7: Zeige alle Tests an, die der Klassenvorstand der 3AHIF in der 5CHIF hatte.
// Hinweis:
// Finde vorher den KV der 3AHIF heraus und speichere ihn in eine string
// Variable.
// *************************************************************************************
// [{"TE_ID":510,"TE_Class":"5CHIF","TE_Teacher":"GC","TE_Subject":"BWM1","TE_Date":"2020-05-09T00:00:00","TE_Lesson":5},
// {"TE_ID":511,"TE_Class":"5CHIF","TE_Teacher":"GC","TE_Subject":"BWM2","TE_Date":"2020-06-12T00:00:00","TE_Lesson":9},
// {"TE_ID":512,"TE_Class":"5CHIF","TE_Teacher":"GC","TE_Subject":"BWM3","TE_Date":"2019-11-01T00:00:00","TE_Lesson":5}]
object result7 = null;
Console.WriteLine(Environment.NewLine + "RESULT7");
Console.WriteLine(JsonSerializer.Serialize(result7));
// *************************************************************************************
// ÜBUNG 8: Welche Unterrichtsstunden der HIF Abteilung (C_Department = HIF) beginnen
// an einem Dienstag (L_Day = 2) nach 17:00? Verwende dafür das TimeOfDay
// Property von P_From und vergleiche mit einem erstellen
// TimeSpan(hour, minute, second) Objekt. Für die Ausgabe erstelle mit
// P_From.ToString("H:mm") den Zeitstring.
// *************************************************************************************
// [{"Class":"1EHIF","Subject":"POS1x","Teacher":"Puljic","Time":"17:10"},
// {"Class":"1EHIF","Subject":"POS1y","Teacher":"Schenk","Time":"17:10"},
// {"Class":"1EHIF","Subject":"POS1z","Teacher":"Lackinger","Time":"17:10"},
// {"Class":"2CHIF","Subject":"BSPKx","Teacher":"Csaszar","Time":"17:10"},
// {"Class":"2CHIF","Subject":"BSPKy","Teacher":"Hofbauer","Time":"17:10"},
// {"Class":"5AHIF","Subject":"POS1","Teacher":"Schletz","Time":"17:10"}]
object result8 = null;
Console.WriteLine(Environment.NewLine + "RESULT8");
Console.WriteLine(JsonSerializer.Serialize(result8));
// *************************************************************************************
// ÜBUNG 9: Wann ist der späteste Test (späteste Unterrichtsstunde in TE_Lesson) von PUH?
// Erstelle dafür mit der Querysyntax eine Liste mit allen Stunden von PUH und
// ermittle dann mit Max() die späteste Stunde.
// *************************************************************************************
// 9
object result9 = null;
Console.WriteLine(Environment.NewLine + "RESULT9");
Console.WriteLine(JsonSerializer.Serialize(result9));
// *************************************************************************************
// ÜBUNG 10: Ermittle die Daten des Lehrers SZ. Achtung: Gib keine Collection, sondern
// ein einzelnes Objekt zurück. Achte bei der Ausgabe darauf, dass das Ergebnis
// in ein JSON Objekt (beginnt mit {) und nicht in ein Array mit einem Element
// serialisiert wird.
// *************************************************************************************
// {"ID":"SZ","Lastname":"Schletz","Firstname":"Michael"}
object result10 = null;
Console.WriteLine(Environment.NewLine + "RESULT10");
Console.WriteLine(JsonSerializer.Serialize(result10));
}
static void Main(string[] args)
{
TestsData data = TestsData.FromFile("../db/tests.json");
// *************************************************************************************
// ÜBUNG 1: Wie viele Klassen gibt es pro Abteilung?
// *************************************************************************************
var result1 = from c in data.Schoolclass
group c by c.C_Department into g
select new
{
Department = g.Key,
Count = g.Count()
};
Console.WriteLine("RESULT1");
Console.WriteLine(JsonSerializer.Serialize(result1));
// *************************************************************************************
// ÜBUNG 2: Wie (1), allerdings sind nur Abteilungen mit mehr als 10 Klassen auszugeben.
// Hinweis: Filtere mit Where nach dem Erstellen der Objekte mit Department
// und Count
// *************************************************************************************
var result2 = from c in data.Schoolclass
group c by c.C_Department into g
where g.Count() > 10
select new
{
Department = g.Key,
Count = g.Count()
};
Console.WriteLine("RESULT2");
Console.WriteLine(JsonSerializer.Serialize(result2));
// *************************************************************************************
// ÜBUNG 3: Wann ist der letzte Test (Max von TE_Date) pro Lehrer und Fach der 5AHIF
// in der Tabelle Test?
// *************************************************************************************
var result3 = from t in data.Test
where t.TE_Class == "5AHIF"
group t by new { t.TE_Teacher, t.TE_Subject } into g
select new
{
Teacher = g.Key.TE_Teacher,
Subject = g.Key.TE_Subject,
LastTest = g.Max(te => te.TE_Date)
};
Console.WriteLine("RESULT3");
Console.WriteLine(JsonSerializer.Serialize(result3));
// *************************************************************************************
// ÜBUNG 4
// Bei Verschmutzungen wird oft der Lehrer, der die letzte Stunde pro Tag in einem Raum
// war, befragt. Dafür filtere die Tabelle data.Lesson so, dass die Stunde gleich der
// letzten Stunde des entsprechenden Raumes und Tages ist. Dafür wird in where eine
// Unterabfrage benötigt, die nochmals data.Lesson filtert und die letzte Stunde
// ermittelt.
// Gib nur die Räume aus C2 (verwende StartsWith) am Montag (L_Day ist 1) aus. Beachte,
// dass L_Room auch null sein kann. Verwende daher den ?. Operator. In diesem Fall soll
// als Standardwert false geliefert werden. Achte außerdem auf die Rangfolge der Operatoren
// ?? und &&.
// *************************************************************************************
var result4 = from l in data.Lesson
where (l.L_Room?.StartsWith("C2") ?? false) && l.L_Day == 1 &&
l.L_Hour == data.Lesson
.Where(le => le.L_Room == l.L_Room && le.L_Day == l.L_Day)
.Max(le => le.L_Hour)
select new
{
Room = l.L_Room,
Day = l.L_Day,
Hour = l.L_Hour,
Teacher = l.L_Teacher,
Class = l.L_Class
};
// {"Room":"C2.09","Day":1,"Hour":16,"Teacher":"PUC","Class":"5BBIF"}
Console.WriteLine("RESULT4");
Console.WriteLine(JsonSerializer.Serialize(result4));
// *************************************************************************************
// ÜBUNG 5 (schwer!)
// Die vorige Abfrage hat eine sehr schlechte Laufzeit: Für jede Stunde wird abgefragt,
// ob sie die letzte Stunde ist. Dafür wird wiederum die gesamte Lesson Tabelle
// aggregiert. In Datenbanken wird dieses Problem daher so gelöst: Es wird eine View
// mit 3 Spalten (Raum, Tag, letzte Stunde) erstellt. Danach wird mit einem Join aus
// der Lesson Tabelle die letzte Stunde geholt.
// Setze diese Technik nun in LINQ um, indem du in lastLesson eine Collection mit Raum,
// Tag und der letzten Stunde (Max von L_Hour) speicherst. Dann führe einen Join durch.
// Der Join mit mehreren Spalten funktioniert in LINQ so:
// from x in table1
// join y in table2 on new { X1 = x.Field1, X2 = Field2 } equals new { X1 = y.Field1, X2 = y.Field2 }
// Die Ausgabe muss natürlich dem Beispiel 4 entsprechen.
// *************************************************************************************
var lastLesson = from l in data.Lesson
group l by new { l.L_Room, l.L_Day } into g
select new
{
Room = g.Key.L_Room,
Day = g.Key.L_Day,
LastLesson = g.Max(le => le.L_Hour)
};
var result5 = from l in data.Lesson
join ll in lastLesson on new { X1 = l.L_Room, X2 = l.L_Day, X3 = l.L_Hour } equals
new { X1 = ll.Room, X2 = ll.Day, X3 = ll.LastLesson }
where (l.L_Room?.StartsWith("C2") ?? false) && l.L_Day == 1
select new
{
Room = l.L_Room,
Day = l.L_Day,
Hour = l.L_Hour,
Teacher = l.L_Teacher,
Class = l.L_Class
};
Console.WriteLine("RESULT5");
Console.WriteLine(JsonSerializer.Serialize(result5));
}
protected override void OnDestroy()
{
TestsData.DeleteInstance();
FragmentsWatcher.DeleteInstance();
base.OnDestroy();
}
public void Post([FromBody] Test test)
{
TestsData testsData = new TestsData();
testsData.UpsertTest(test);
}
public IEnumerable <Test> Get(string testRunId, string status)
{
TestsData testsData = new TestsData();
return(testsData.GetDocuments().Where(t => t.TestRunId == testRunId && t.Result.Status == status));
}
public Test Get(int testNumber)
{
TestsData testsData = new TestsData();
return(testsData.GetTest(testNumber));
}
public IEnumerable <Test> Get(string testRunId)
{
TestsData testsData = new TestsData();
return(testsData.GetDocuments().Where(t => t.TestRunId == testRunId));
}
void GetTestsDone(string data)
{
testsData = JsonUtility.FromJson <TestsData>(data);
StartCoroutine(LoadJson(url + "getAnswers.php", GetAnswersDone));
}
static async Task Main(string[] args)
{
// *************************************************************************************
// Schreibe in den nachfolgenden Übungen statt der Zeile
// object resultX = null;
// die korrekte LINQ Abfrage. Verwende den entsprechenden Datentyp statt object.
// Du kannst eine "schöne" (also eingerückte) Ausgabe der JSON Daten erreichen, indem
// du die Variable WriteIndented auf true setzt.
// *************************************************************************************
var WriteIndented = false;
var serializerOptions = new JsonSerializerOptions {
WriteIndented = WriteIndented
};
TestsData db = await TestsData.FromFile("db/tests.json");
// *************************************************************************************
// ÜBUNG 1: Erstelle für jeden Lehrer eine Liste der Fächer, die er unterrichtet. Es
// sind nur die ersten 10 Datensätze auszugeben. Das kann mit
// .OrderBy(t=>t.TeacherId).Take(10)
// am Ende der LINQ Anweisung gemacht werden. Hinweis: Verwende Distinct für die
// liste der Unterrichtsgegenstände.
// *************************************************************************************
object result1 = null;
Console.WriteLine("RESULT1");
Console.WriteLine(JsonSerializer.Serialize(result1, serializerOptions));
// *************************************************************************************
// ÜBUNG 2: Die 5AHIF möchte wissen, in welchem Monat sie welche Tests hat.
// Hinweis: Mit den Properties Month und Year kann auf das Monat bzw. Jahr
// eines DateTime Wertes zugegriffen werden. Die Ausgabe in DisplayMonth kann
// $"{mydate.Year:00}-{mydate.Month:00}" (mydate ist zu ersetzen)
// erzeugt werden
// *************************************************************************************
object result2 = null;
Console.WriteLine("RESULT2");
Console.WriteLine(JsonSerializer.Serialize(result2, serializerOptions));
// *************************************************************************************
// ÜBUNG 3: Jeder Schüler der 5AHIF soll eine Übersicht bekommen, welche Tests er pro Fach
// abgeschlossen hat.
// Es sind nur die ersten 2 Schüler mit OrderBy(p => p.P_ID).Take(2) am Ende des
// Statements auszugeben.
// Hinweis: Beachte die Datenstruktur in der Ausgabe.
// Pupil <-- Zuerst wird der Schüler projiziert (Select)
// |
// +-- P_ID
// P_Firstname
// P_Lastname
// Tests <-- Hier soll nach Subject gruppiert werden
// |
// +---- Subject <-- Key der Gruppierung
// +---- Termine <-- Projektion der Gruppierung
// |
// +------ TE_Teacher
// +------ TE_Date
// +------ TE_Lesson
// *************************************************************************************
object result3 = null;
Console.WriteLine("RESULT3");
Console.WriteLine(JsonSerializer.Serialize(result3, serializerOptions));
// *************************************************************************************
// ÜBUNG 4: Wie viele Klassen sind pro Tag und Stunde gleichzeitig im Haus?
// Hinweis: Gruppiere zuerst nach Tag und Stunde in Lesson. Für die Ermittlung
// der Klassenanzahl zähle die eindeutigen KlassenIDs, indem mit Distinct eine
// Liste dieser IDs (C_ID) erzeugt wird und dann mit Count() gezählt wird.
// Es sind mit OrderByDescending(g=>g.ClassCount).Take(5) nur die 5
// "stärksten" Stunden auszugeben.
// *************************************************************************************
object result4 = null;
Console.WriteLine("RESULT4");
Console.WriteLine(JsonSerializer.Serialize(result4, serializerOptions));
// *************************************************************************************
// ÜBUNG 5: Wie viele Klassen gibt es pro Abteilung?
// *************************************************************************************
object result5 = null;
Console.WriteLine("RESULT5");
Console.WriteLine(JsonSerializer.Serialize(result5, serializerOptions));
// *************************************************************************************
// ÜBUNG 6: Wie die vorige Übung, allerdings sind nur Abteilungen
// mit mehr als 10 Klassen auszugeben.
// Hinweis: Filtere mit Where nach dem Erstellen der Objekte mit Department
// und Count
// *************************************************************************************
object result6 = null;
Console.WriteLine("RESULT6");
Console.WriteLine(JsonSerializer.Serialize(result6, serializerOptions));
// *************************************************************************************
// ÜBUNG 7: Wann ist der letzte Test (Max von TE_Date) pro Lehrer und Fach der 5AHIF
// in der Tabelle Test?
// *************************************************************************************
object result7 = null;
Console.WriteLine("RESULT7");
Console.WriteLine(JsonSerializer.Serialize(result7, serializerOptions));
}
static void Main(string[] args)
{
TestsData data = TestsData.FromFile("../db/tests.json");
// *************************************************************************************
// Schreibe in den nachfolgenden Übungen statt der Zeile
// object resultX = null;
// die korrekte LINQ Abfrage. Verwende den entsprechenden Datentyp statt object.
// *************************************************************************************
// ÜBUNG 1: Wie viele Klassen gibt es pro Abteilung?
// *************************************************************************************
object result1 = null;
Console.WriteLine("RESULT1");
Console.WriteLine(JsonSerializer.Serialize(result1));
// *************************************************************************************
// ÜBUNG 2: Wie (1), allerdings sind nur Abteilungen mit mehr als 10 Klassen auszugeben.
// Hinweis: Filtere mit Where nach dem Erstellen der Objekte mit Department
// und Count
// *************************************************************************************
object result2 = null;
Console.WriteLine("RESULT2");
Console.WriteLine(JsonSerializer.Serialize(result2));
// *************************************************************************************
// ÜBUNG 3: Wann ist der letzte Test (Max von TE_Date) pro Lehrer und Fach der 5AHIF
// in der Tabelle Test?
// *************************************************************************************
object result3 = null;
Console.WriteLine("RESULT3");
Console.WriteLine(JsonSerializer.Serialize(result3));
// *************************************************************************************
// ÜBUNG 4
// Bei Verschmutzungen wird oft der Lehrer, der die letzte Stunde pro Tag in einem Raum
// war, befragt. Dafür filtere die Tabelle data.Lesson so, dass die Stunde gleich der
// letzten Stunde des entsprechenden Raumes und Tages ist. Dafür wird in where eine
// Unterabfrage benötigt, die nochmals data.Lesson filtert und die letzte Stunde
// ermittelt.
// Gib nur die Räume aus C2 (verwende StartsWith) am Montag (L_Day ist 1) aus. Beachte,
// dass L_Room auch null sein kann. Verwende daher den ?. Operator. In diesem Fall soll
// als Standardwert false geliefert werden. Achte außerdem auf die Rangfolge der Operatoren
// ?? und &&.
// *************************************************************************************
object result4 = null;
// {"Room":"C2.09","Day":1,"Hour":16,"Teacher":"PUC","Class":"5BBIF"}
Console.WriteLine("RESULT4");
Console.WriteLine(JsonSerializer.Serialize(result4));
// *************************************************************************************
// ÜBUNG 5 (schwer!)
// Die vorige Abfrage hat eine sehr schlechte Laufzeit: Für jede Stunde wird abgefragt,
// ob sie die letzte Stunde ist. Dafür wird wiederum die gesamte Lesson Tabelle
// aggregiert. In Datenbanken wird dieses Problem daher so gelöst: Es wird eine View
// mit 3 Spalten (Raum, Tag, letzte Stunde) erstellt. Danach wird mit einem Join aus
// der Lesson Tabelle die letzte Stunde geholt.
// Setze diese Technik nun in LINQ um, indem du in lastLesson eine Collection mit Raum,
// Tag und der letzten Stunde (Max von L_Hour) speicherst. Dann führe einen Join durch.
// Der Join mit mehreren Spalten funktioniert in LINQ so:
// from x in table1
// join y in table2 on new { X1 = x.Field1, X2 = Field2 } equals new { X1 = y.Field1, X2 = y.Field2 }
// Die Ausgabe muss natürlich dem Beispiel 4 entsprechen.
// *************************************************************************************
object result5 = null;
Console.WriteLine("RESULT5");
Console.WriteLine(JsonSerializer.Serialize(result5));
}
static void Main(string[] args)
{
TestsData data = TestsData.FromFile("../db/tests.json");
//Welche Klassen hat die 5CAIF am Freitag? Gib auch die Lehrer aus:
var demo1 = data.Lesson
.Where(l => l.L_Class == "5CAIF" && l.L_Day == 5);
//foreach (var l in demo1)
//{
// Console.WriteLine($"{l.L_Hour}, {l.L_Subject}, {l.L_TeacherNavigation.T_Lastname}");
//}
//var demo2 = data.Schoolclass;
//foreach (var s in demo2)
//{
// foreach (var p in s.Pupils)
// {
// Console.WriteLine($"{p.P_Lastname}");
// }
//}
//var demo3 = data.Lesson
//.Where(l => l.L_Subject == "D")
//.GroupBy(l => new { l.L_Class, l.L_Teacher })
//.Select(g => new
//{
// Class = g.Key.L_Class,
// Lehrer = g.Key.L_Teacher,
// Count = g.GroupBy(g2 => g2.L_Day)
// .Select(g2 => new
// {
// g2.Key,
// Rooms = g2.Select(r => r.L_Room)
// })
//});
//Console.WriteLine(JsonSerializer.Serialize(demo3, new JsonSerializerOptions { WriteIndented = true }));
//var demo4 = data.Lesson
// .GroupBy(l => l.L_Class)
// .Select(g => new
// {
// Class = g.Key,
// Count = g.Count(),
// MaxHour = g.Max(x => x.L_Hour)
// });
//return;
// *************************************************************************************
// Schreibe in den nachfolgenden Übungen statt der Zeile
// object resultX = null;
// die korrekte LINQ Abfrage. Verwende den entsprechenden Datentyp statt object.
// *************************************************************************************
// ÜBUNG 1: Wie viele Klassen gibt es pro Abteilung?
// *************************************************************************************
var result1 = data
.Schoolclass
.GroupBy(s => s.C_Department)
.Select(s => new
{
Department = s.Key,
Count = s.Count()
});
Console.WriteLine("RESULT1");
Console.WriteLine(JsonSerializer.Serialize(result1, new JsonSerializerOptions {
WriteIndented = true
}));
// *************************************************************************************
// ÜBUNG 2: Wie (1), allerdings sind nur Abteilungen mit mehr als 10 Klassen auszugeben.
// Hinweis: Filtere mit Where nach dem Erstellen der Objekte mit Department
// und Count
// *************************************************************************************
object result2 = data
.Schoolclass
.GroupBy(s => s.C_Department)
.Where(s => s.Count() > 10)
.Select(s => new
{
Department = s.Key,
Count = s.Count()
});
Console.WriteLine("RESULT2");
Console.WriteLine(JsonSerializer.Serialize(result2, new JsonSerializerOptions {
WriteIndented = true
}));
// *************************************************************************************
// ÜBUNG 3: Wann ist der letzte Test (Max von TE_Date) pro Lehrer und Fach der 5AHIF
// in der Tabelle Test?
// *************************************************************************************
object result3 = data
.Test
.Where(t => t.TE_Class == "5AHIF")
.GroupBy(t => new { t.TE_Teacher, t.TE_Subject })
.Select(g => new
{
g.Key,
LastTest = g.Max(g => g.TE_Date)
});
Console.WriteLine("RESULT3");
Console.WriteLine(JsonSerializer.Serialize(result3, new JsonSerializerOptions {
WriteIndented = true
}));
// *************************************************************************************
// ÜBUNG 4
// Bei Verschmutzungen wird oft der Lehrer, der die letzte Stunde pro Tag in einem Raum
// war, befragt. Dafür filtere die Tabelle data.Lesson so, dass die Stunde gleich der
// letzten Stunde des entsprechenden Raumes und Tages ist. Dafür wird in where eine
// Unterabfrage benötigt, die nochmals data.Lesson filtert und die letzte Stunde
// ermittelt.
// Gib nur die Räume aus C2 (verwende StartsWith) am Montag (L_Day ist 1) aus. Beachte,
// dass L_Room auch null sein kann. Verwende daher den ?. Operator. In diesem Fall soll
// als Standardwert false geliefert werden. Achte außerdem auf die Rangfolge der Operatoren
// ?? und &&.
// *************************************************************************************
object result4 = data.Lesson
.GroupBy(l => new { l.L_Room, l.L_Day, l.L_Hour, l.L_Teacher, l.L_Class })
.Where(g => g.Max(s => s.L_Hour) == data.Lesson.Max(l2 => l2.L_Hour) &&
(g.Key.L_Room?.StartsWith("C2") ?? false) &&
g.Key.L_Day == 1)
.Select(g =>
new
{
g.Key,
});
// {"Room":"C2.09","Day":1,"Hour":16,"Teacher":"PUC","Class":"5BBIF"}
Console.WriteLine("RESULT4");
Console.WriteLine(JsonSerializer.Serialize(result4, new JsonSerializerOptions {
WriteIndented = true
}));
// *************************************************************************************
// ÜBUNG 5 (schwer!)
// Die vorige Abfrage hat eine sehr schlechte Laufzeit: Für jede Stunde wird abgefragt,
// ob sie die letzte Stunde ist. Dafür wird wiederum die gesamte Lesson Tabelle
// aggregiert. In Datenbanken wird dieses Problem daher so gelöst: Es wird eine View
// mit 3 Spalten (Raum, Tag, letzte Stunde) erstellt. Danach wird mit einem Join aus
// der Lesson Tabelle die letzte Stunde geholt.
// Setze diese Technik nun in LINQ um, indem du in lastLesson eine Collection mit Raum,
// Tag und der letzten Stunde (Max von L_Hour) speicherst. Dann führe einen Join durch.
// Der Join mit mehreren Spalten funktioniert in LINQ so:
// from x in table1
// join y in table2 on new { X1 = x.Field1, X2 = Field2 } equals new { X1 = y.Field1, X2 = y.Field2 }
// Die Ausgabe muss natürlich dem Beispiel 4 entsprechen.
// *************************************************************************************
object result5 = null;
Console.WriteLine("RESULT5");
Console.WriteLine(JsonSerializer.Serialize(result5, new JsonSerializerOptions {
WriteIndented = true
}));
}
