Baipyrus/Temperaturverwaltung
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

initial commit

Browse Source
This commit is contained in:
Baipyrus 2022-05-15 17:11:39 +02:00
commit 0b517146cc
5 changed files with 527476 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored Normal file
View File

@ -0,0 +1,2 @@
bin/*
obj/*

28
Pflichtenheft.txt Normal file
View File

@ -0,0 +1,28 @@
Erledigt:
############################################
getAvgTemp(Startdatum, Enddatum):Float
getAvgTemp(Monat):Float
getAvgTemp(Tag):Float
getAvgTemp(Jahr):Float
getAvgTemp():Float
getMaximum(Startdatum, Enddatum):Float
getMaximum(Monat):Float
getMaximum(Tag):Float
getMaximum(Jahr):Float
getMaximum():Float
getMinimum(Startdatum, Enddatum):Float
getMinimum(Monat):Float
getMinimum(Tag):Float
getMinimum(Jahr):Float
getMinimum():Float
getTooCold():String
getTooHot():String
setHotLimit(Temperatur):void
setColdLimit(Temperatur):void
filterDataset(Startuhrzeit, Enduhrzeit):void
getTempDifference(Tag):Float

398
Program.cs Normal file
View File

@ -0,0 +1,398 @@
using System;
using System.IO;
using System.Collections.Generic;
namespace Temperaturverwaltung {
class Program {
static Datensatz[] Datensätze;
static void Main(string[] args) {
// Die Datensätze aus der Textdatei auslesen und in Zeilen aufspalten
string[] TextZeilen = File.ReadAllLines(@"temperaturen.txt");
Datensätze = new Datensatz[TextZeilen.Length];
// Die Datensätze einzeln (Zeile pro Zeile) durchgehen
for (int i = 0; i < TextZeilen.Length; i++) {
string Zeile = TextZeilen[i];
// Datensatz in einzelne (Datum, etc.) Daten aufteilen
string[] daten = Zeile.Split(';');
// Daten zuordnen
string Datum = daten[0];
string Uhrzeit = daten[1];
int Klassenraum = Convert.ToInt32(daten[2]);
float Temperatur = (float)Convert.ToDecimal(daten[3]);
// Datensatz hinzufügen
Datensätze[i] = new Datensatz(Datum, Uhrzeit, Klassenraum, Temperatur);
}
while (true) {
Console.Clear();
Console.WriteLine("############################################");
Console.WriteLine("Was würden Sie gerne tun?");
Console.WriteLine("0) Programm beenden");
Console.WriteLine("1) Durchschnitts Temperatur berechen");
Console.WriteLine("2) Maximale Temperatur anzeigen");
Console.WriteLine("3) Minimale Temperatur anzeigen");
Console.WriteLine("4) Größte Temperatur Differenz anzeigen");
Console.WriteLine("5) Temperaturen außerhalb der Grenzen finden");
Console.WriteLine("6) Datensatz zeitlich filtern");
Console.WriteLine("############################################");
Console.WriteLine();
Console.Write("Ihre Auswahl: ");
string nutzerEingabe = Console.ReadLine();
Console.Clear();
bool closeProgram = false;
switch (nutzerEingabe) {
default:
Console.WriteLine("Ungültige Eingabe.");
Console.Write("Drücken Sie eine beliebige Taste . . . ");
Console.ReadKey(true);
break;
case "0":
closeProgram = true;
break;
case "1":
timespanSelect("Durchschnitts");
break;
case "2":
timespanSelect("Maximale");
break;
case "3":
timespanSelect("Minimale");
break;
case "4":
maxDiffCalculation();
break;
case "5":
badTempCalculation();
break;
case "6":
filterDatabase();
break;
}
if (closeProgram) {
break;
}
}
}
static void timespanSelect(string dataType) {
Console.WriteLine("############################################");
Console.WriteLine("Welche Zeitspanne wollen Sie angeben?");
Console.WriteLine("0) Zurück");
Console.WriteLine("1) Jahr / Monat / Tag");
Console.WriteLine("2) Startdatum bis Enddatum");
Console.WriteLine("############################################");
Console.WriteLine();
Console.Write("Ihre Auswahl: ");
string nutzerEingabe = Console.ReadLine();
Console.Clear();
float tmp = 0f;
bool goBack = false;
switch (nutzerEingabe) {
default:
Console.WriteLine("Ungültige Eingabe.");
break;
case "0":
goBack = true;
break;
case "1":
dateCategories(dataType);
break;
case "2":
Console.Write("Bitte geben Sie das Startdatum an (YYYY-MM-DD): ");
string Startdatum = Console.ReadLine();
Console.Clear();
Console.Write("Bitte geben Sie das Enddatum an (YYYY-MM-DD): ");
string Enddatum = Console.ReadLine();
Console.Clear();
tmp = calcTempLogic(dataType, Startdatum, Enddatum);
Console.WriteLine("Die {0} Temperatur vom {1} bis zum {2} ist: {3}", dataType, Startdatum, Enddatum, tmp);
break;
}
if (!goBack) {
Console.Write("Drücken Sie eine beliebige Taste zum fortfahren . . . ");
Console.ReadKey(true);
}
}
static void dateCategories(string dataType) {
Console.WriteLine("############################################");
Console.WriteLine("Was für ein Datum wollen Sie angeben?");
Console.WriteLine("0) Zurück");
Console.WriteLine("1) Jahr");
Console.WriteLine("2) Monat");
Console.WriteLine("3) Tag");
Console.WriteLine("############################################");
Console.WriteLine();
Console.Write("Ihre Auswahl: ");
string nutzerEingabe = Console.ReadLine();
Console.Clear();
float tmp = 0f;
string Startdatum = "", Enddatum = "";
switch (nutzerEingabe) {
default:
Console.WriteLine("Ungültige Eingabe.");
break;
case "0":
return;
case "1":
// Eingabe des Jahres
Console.Write("Bitte geben Sie das Jahr an (YYYY): ");
string Jahr = Console.ReadLine();
Console.Clear();
Startdatum = Jahr + "-01-01";
Enddatum = Jahr + "-12-31";
tmp = calcTempLogic(dataType, Startdatum, Enddatum);
break;
case "2":
// Eingabe des Monats
Console.Write("Bitte geben Sie das Jahr und den Monat an (YYYY-MM): ");
string JahrMonat = Console.ReadLine();
Console.Clear();
Startdatum = JahrMonat + "-01";
// Letzten Tag des Monats ermitteln
string[] splits = JahrMonat.Split('-');
int jahr = Convert.ToInt32(splits[0]);
int monat = Convert.ToInt32(splits[1]);
Enddatum = JahrMonat + '-' + DateTime.DaysInMonth(jahr, monat);
tmp = calcTempLogic(dataType, Startdatum, Enddatum);
break;
case "3":
// Eingabe des Tages
Console.Write("Bitte geben Sie das Jahr, den Monat und den Tag an (YYYY-MM-DD): ");
string JahrMonatTag = Console.ReadLine();
Console.Clear();
Startdatum = JahrMonatTag;
Enddatum = JahrMonatTag;
tmp = calcAvrTemp(Startdatum, Enddatum);
break;
}
// Runde 'tmp' auf 2 Nachkommastellen
tmp = (float)Math.Round(tmp, 2);
Console.WriteLine("Die {0} Temperatur vom {1} bis zum {2} ist: {3}", dataType, Startdatum, Enddatum, tmp);
}
static float calcTempLogic(string dataType, string sd, string ed) {
switch (dataType) {
case "Durchschnitts":
return calcAvrTemp(sd, ed);
case "Maximale":
return calcMaxTemp(sd, ed);
case "Minimale":
return calcMinTemp(sd, ed);
default:
return 0f;
}
}
static float calcAvrTemp(string sd, string ed) {
DateTime sdParse = DateTime.Parse(sd);
DateTime edParse = DateTime.Parse(ed);
float avrTemp = 0f;
int amount = 0;
foreach (Datensatz s in Datensätze) {
DateTime sParse = DateTime.Parse(s.Datum + " " + s.Uhrzeit);
if (sParse >= sdParse) {
foreach (Datensatz e in Datensätze) {
DateTime eParse = DateTime.Parse(e.Datum + " " + e.Uhrzeit);
if (eParse <= edParse && eParse >= sdParse) {
avrTemp += e.Temperatur;
amount++;
}
}
break;
}
}
avrTemp /= amount;
return avrTemp;
}
static float calcMaxTemp(string sd, string ed) {
DateTime sdParse = DateTime.Parse(sd);
DateTime edParse = DateTime.Parse(ed);
float maxTemp = 0f;
foreach (Datensatz s in Datensätze) {
DateTime sParse = DateTime.Parse(s.Datum + " " + s.Uhrzeit);
if (sParse >= sdParse) {
foreach (Datensatz e in Datensätze) {
DateTime eParse = DateTime.Parse(e.Datum + " " + e.Uhrzeit);
if (eParse <= edParse && eParse >= sdParse && e.Temperatur > maxTemp) {
maxTemp = e.Temperatur;
}
}
break;
}
}
return maxTemp;
}
static float calcMinTemp(string sd, string ed) {
DateTime sdParse = DateTime.Parse(sd);
DateTime edParse = DateTime.Parse(ed);
float minTemp = 0f;
foreach (Datensatz s in Datensätze) {
DateTime sParse = DateTime.Parse(s.Datum + " " + s.Uhrzeit);
if (sParse >= sdParse) {
minTemp = s.Temperatur;
foreach (Datensatz e in Datensätze) {
DateTime eParse = DateTime.Parse(e.Datum + " " + e.Uhrzeit);
if (eParse <= edParse && eParse >= sdParse && (e.Temperatur < minTemp || minTemp == -1)) {
minTemp = e.Temperatur;
}
}
break;
}
}
return minTemp;
}
static void maxDiffCalculation() {
Console.Write("Bitte geben Sie das Jahr, den Monat und den Tag an (YYYY-MM-DD): ");
string JahrMonatTag = Console.ReadLine();
Console.Clear();
DateTime sdParse = DateTime.Parse(JahrMonatTag);
// Größte Temperaturdifferenz am Tag "sdParse" ermitteln
DateTime edParse = sdParse.AddDays(1);
float maxDiff = 0f;
foreach (Datensatz s in Datensätze) {
DateTime sParse = DateTime.Parse(s.Datum + " " + s.Uhrzeit);
if (sParse >= sdParse) {
foreach (Datensatz e in Datensätze) {
DateTime eParse = DateTime.Parse(e.Datum + " " + e.Uhrzeit);
float diff = Math.Abs(s.Temperatur-e.Temperatur);
if (eParse <= edParse && eParse >= sdParse && diff > maxDiff)
maxDiff = diff;
else if (eParse > edParse)
break;
}
break;
}
}
maxDiff = (float)Math.Round(maxDiff, 2);
Console.WriteLine("Die größte Temparaturdifferenz am Tag {0} ist: {1}°C", JahrMonatTag, maxDiff);
Console.ReadKey(true);
}
static void badTempCalculation() {
// Get: Zu 'Heiß/Kalt' => Datensätze mit Temperatur größer/kleiner als angabe
// Set: 'Heiß/Kalt' Limit => Datenspeicher temporär anhand der angabe als limitierung filtern
// Idee: Eine Funktion mit Parametern für Ober- und Untergrenze, die die überschreitenen Datensätze zurückgibt
Console.Write("Temparatur Untergrenze (°C): ");
string uEingabe = Console.ReadLine().ToLower();
if (uEingabe == "exit" || uEingabe == "back" || uEingabe == "zurück" || uEingabe == "")
return;
float untergrenze = float.Parse(uEingabe);
Console.Write("Temparatur Obergrenze (°C): ");
string oEingabe = Console.ReadLine().ToLower();
if (oEingabe == "exit" || oEingabe == "back" || oEingabe == "zurück" || oEingabe == "")
return;
float obergrenze = float.Parse(oEingabe);
Console.Clear();
// Nach Temparaturen außerhalb der Grenzen filtern
List<Datensatz> tmp = new List<Datensatz>();
for (int i = 0; i < Datensätze.Length; i++) {
if (Datensätze[i].Temperatur >= untergrenze && Datensätze[i].Temperatur <= obergrenze) {
tmp.Add(Datensätze[i]);
}
}
// Ausgabe des Ergebnisses und Abfrage nach Löschung
int differenz = Datensätze.Length - tmp.Count;
Console.WriteLine("Es wurden {0} Datensätze gefunden, die {1}°C unterschreiten und/oder {2}°C überschreiten.", differenz, untergrenze, obergrenze);
if (differenz > 0) {
Console.Write("Sollen all diese Datensätze gelöscht werden? (y/N): ");
string answer = Console.ReadLine();
if (answer.ToLower() == "y") {
Datensätze = tmp.ToArray();
Console.Clear();
Console.WriteLine("Es wurden {0} Datensätze erfolgreich gelöscht.", tmp.Count);
Console.ReadKey(true);
} else
return;
} else
Console.ReadKey(true);
}
static void filterDatabase() {
// Filterung der Datenbank anhand von Start- und Enddatum
// Datensätze mit Datum zwischen Start- und Enddatum entfernen
// Warnung anzeigen
Console.WriteLine("WARNUNG: Daten außerhalb der Angaben werden entfernt!");
Console.Write("Trotzdem fortfahren? (Y/n): ");
string answer = Console.ReadLine();
Console.Clear();
if (answer.ToLower() == "n")
return;
// Start- und Enddatum Eingabe
Console.Write("Bitte geben Sie das Startdatum an (YYYY-MM-DD): ");
string Startdatum = Console.ReadLine();
Console.Write("Bitte geben Sie das Enddatum an (YYYY-MM-DD): ");
string Enddatum = Console.ReadLine();
// Datensätze mit Datum zwischen Start- und Enddatum entfernen
List<Datensatz> tmp = new List<Datensatz>(Datensätze);
for (int i = tmp.Count-1; i >= 0; i--) {
DateTime dt = DateTime.Parse(Datensätze[i].Datum + " " + Datensätze[i].Uhrzeit);
if (dt < DateTime.Parse(Startdatum) || dt > DateTime.Parse(Enddatum)) {
tmp.RemoveAt(i);
}
}
int differenz = Datensätze.Length - tmp.Count;
Datensätze = tmp.ToArray();
Console.Clear();
// Ausgabe, wie viele Datensätze entfernt wurden
Console.WriteLine("Es wurden {0} Datensätze entfernt.", differenz);
Console.ReadKey(true);
}
}
class Datensatz {
public string Datum, Uhrzeit;
public float Temperatur;
public int Klassenraum;
public Datensatz(string d, string u, int k, float t) {
Datum = d;
Uhrzeit = u;
Temperatur = t;
Klassenraum = k;
}
}
}

8
Temperaturverwaltung.csproj Normal file
View File

@ -0,0 +1,8 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net5.0</TargetFramework>
</PropertyGroup>
</Project>

527040
temperaturen.txt Normal file
View File

File diff suppressed because it is too large Load Diff