public void gibAlleDatenAus()
{
//festlegen der jeweiligen Formate für die einzelnen Fahrzeugtypen
String pkw_output = "{0,-20}{1,-20}{2,-20}{3,-20}{4,-20}{5,-20}{6,-20}{7,-20}{8,-20}";
String lkw_output = "{0,-20}\t{1,-20}\t{2,-20}\t{3,-20}\t{4,-20}\t{5,-20}\t{6,-20}\t{7,-20}\t";
String motorrad_output = "{0,-20}\t{1,-20}\t{2,-20}\t{3,-20}\t{4,-20}\t{5,-20}\t{6,-20}\t";
//Hinzufügen der Beschriftungen der Fahrzeuge in einen String
allePKWDaten.Add(String.Format(pkw_output, "Hersteller", "Modell", "Kennzeichen", "Erstzulassung", "Anschaffungspreis", "Hubraum", "Leistung", "Schadstoffklasse", "Stellplatz"));
alleLKWDaten.Add(String.Format(lkw_output, "Hersteller", "Modell", "Kennzeichen", "Erstzulassung", "Anschaffungspreis", "AnzahlAchsen", "Zuladung", "Stellplatz"));
alleMotorradDaten.Add(String.Format(motorrad_output, "Hersteller", "Modell", "Kennzeichen", "Erstzulassung", "Anschaffungspreis", "Hubraum", "Stellplatz"));
//Schleife über alle Fahrzeuge in der Fahrzeugliste laufen lassen
foreach (Fahrzeug fahrzeug in fahrzeugliste)
{
//Prüfen, welcher Fahrzeugtyp vorliegt
switch (fahrzeug.GetType().ToString())
{
//es liegt ein PKW vor
case "Fahrzeugverwaltung.PKW":
//Fahrzeug zu PKW konvertieren
PKW pkw = fahrzeug as PKW;
//alle PKW Daten in einen String übertragen gemäß des festgelegten Formats
allePKWDaten.Add(String.Format(pkw_output, pkw.Hersteller, pkw.Modell, pkw.Kennzeichen, pkw.Erstzulassung.ToString(), pkw.Anschaffungspreis.ToString(), pkw.Hubraum.ToString(), pkw.Leistung.ToString(), pkw.Schadstoffklasse.ToString(), pkw.Stellplatznummer.ToString()));
break;
//es liegt ein LKW vor
case "Fahrzeugverwaltung.LKW":
//Fahrzeug in LKW übertragen
LKW lkw = fahrzeug as LKW;
//alle LKW Daten in einen String übertragen gemäß des festgelegten Formats
alleLKWDaten.Add(String.Format(lkw_output, lkw.Hersteller, lkw.Modell, lkw.Kennzeichen, lkw.Erstzulassung.ToString(), lkw.Anschaffungspreis.ToString(), lkw.Achsenanzahl.ToString(), lkw.Zuladung.ToString(), lkw.Stellplatznummer.ToString()));
break;
//es liegt ein Motorrad vor
case "Fahrzeugverwaltung.Motorrad":
//Fahrzeug zu Motorrad übertragen
Motorrad motorrad = fahrzeug as Motorrad;
//alle Motorrad Daten in einen String übertragen gemäß des festgelegten Formats
alleMotorradDaten.Add(String.Format(motorrad_output, motorrad.Hersteller, motorrad.Modell, motorrad.Kennzeichen, motorrad.Erstzulassung.ToString(), motorrad.Anschaffungspreis.ToString(), motorrad.Hubraum.ToString(), motorrad.Stellplatznummer.ToString()));
break;
}
}
}
// Wird aufgerufen, wenn sich der Inhalt der Textbox Unbestimmt_1 geändert hat.
// Die Funktion prüft den Wert und stellt den Hintergrund im Fehlerfall rot dar.
// PKW : Textbox Unbestimmt_1 enthält Hubraum
// LKW : Textbox Unbestimmt_1 enthält Achsenanzahl
// Motorad: Textbox Unbestimmt_1 enthält Hubraum
private void textBoxUnbestimmt_1_TextChanged(object sender, EventArgs e)
{
// PKW ausgewaehlt
if (comboBoxFahrzeugTyp.SelectedIndex == 0)
{
int i;
// Prüfe Hubraum, zurückgegebener Wert wird nicht verwendet
AlleDatenOK[5] = PKW.TextToHubraum(textBoxUnbestimmt_1.Text, out i);
}
// LKW ausgewaehlt
else if (comboBoxFahrzeugTyp.SelectedIndex == 1)
{
int i;
AlleDatenOK[5] = LKW.TextToAnzahlAchsen(textBoxUnbestimmt_1.Text, out i);
}
// Motorad ausgewaehlt
else
{
int i;
// Prüfe Hubraum, zurückgegebener Wert wird nicht verwendet
AlleDatenOK[5] = Motorrad.TextToHubraum(textBoxUnbestimmt_1.Text, out i);
}
// Hintergrundfarbe der Textbox normal wenn Daten OK
if (AlleDatenOK[5])
{
textBoxUnbestimmt_1.BackColor = System.Drawing.SystemColors.Window;
}
// Hintergrundfarbe der Textbox rot wenn Daten nicht OK
else
{
textBoxUnbestimmt_1.BackColor = System.Drawing.Color.LightCoral;
}
// Enable OK Button, wenn keine Fehler
// Alle Elemente von AlleDatenOK müssen true sein
AktualisiereOkButton();
}
public float berechneSteuerschuldKennzeichen(String kennzeichen)
{
//Anlegen der Variablen steuerschuld
float steuerschuld = 0;
//Finden des Fahrezugs mit dem übergebenen Kennzeichen
Fahrzeug f = sucheFahrzeug(fahrzeugliste, kennzeichen);
//prüfen, ob das Kennzeichen in der Fahrzeugliste existiert
if ((fahrzeugliste.Exists(x => x.Kennzeichen == kennzeichen)) == false)
{
throw new ArgumentException("Kennzeichen nicht vorhanden!");
}
//prüfen, ob Fahrzeug vom Typ PKW ist
if (f.GetType().ToString().Equals("Fahrzeugverwaltung.PKW"))
{
//Konvertieren des Fahrzeugs in den Typ PKW
//um auf spezifische Variablen der Klasse PKW zugreifen zu können
PKW p = (PKW)Convert.ChangeType(f, typeof(PKW));
steuerschuld = (p.Hubraum + 99) / 100 * 10 * (p.Schadstoffklasse + 1);
}
//prüfen, ob Fahrzeug vom Typ LKW ist
else if (f.GetType().ToString().Equals("Fahrzeugverwaltung.LKW"))
{
//Konvertieren des Fahrzeugs in den Typ LKW
//um auf spezifische Variablen der Klasse LKW zugreifen zu können
LKW l = (LKW)Convert.ChangeType(f, typeof(LKW));
steuerschuld = l.Zuladung * 100;
}
//ist das Fahrzeug weder vom Typ LKW noch vom Typ PKW, ist es vom Typ Motorrad
else
{
//Konvertieren des Fahrzeugs in den Typ Motorrad
//um auf spezifische Variablen der Klasse Motorrad zugreifen zu können
Motorrad m = (Motorrad)Convert.ChangeType(f, typeof(Motorrad));
steuerschuld = (m.Hubraum + 99) / 10 * 20;
}
//zurückgeben der Steuerschuld
return(steuerschuld);
}
public static String FahrzeugAusgeben(List <Fahrzeug> aFahrzeugliste, String kennzeichen)
{
//prüfen, ob das Kennzeichen in der Fahrzeugliste existiert
if ((aFahrzeugliste.Exists(x => x.Kennzeichen == kennzeichen)) == false)
{
throw new ArgumentException("Kennzeichen nicht vorhanden!");
}
//festlegen des Ausgabeformats
String output = "";
//finden des Fahrzeugs in der Fahrzeugliste
Fahrzeug f = aFahrzeugliste.Find(x => x.Kennzeichen.Contains(kennzeichen));
//Zurückgeben des Ergebnisses
//Prüfen, welcher Fahrzeugtyp vorliegt
switch (f.GetType().ToString())
{
case "Fahrzeugverwaltung.PKW":
//Format auf PKW anwenden
PKW pkw = f as PKW;
output = "Hersteller: " + pkw.Hersteller + "\r\nModell: " + pkw.Modell + "\r\nKennzeichen: " + pkw.Kennzeichen + "\r\nErstzulassung: " + pkw.Erstzulassung + "\r\nAnschaffungspreis: " + pkw.Anschaffungspreis + "\r\nHubraum: " + pkw.Hubraum + "\r\nLeistung: " + pkw.Leistung + "\r\nSchadstoffklasse: " + pkw.Schadstoffklasse + "\r\nStellplatz: " + pkw.Stellplatznummer;
break;
case "Fahrzeugverwaltung.LKW":
//Format auf LKW anwenden
LKW lkw = f as LKW;
output = "Hersteller: " + lkw.Hersteller + "\r\nModell: " + lkw.Modell + "\r\nKennzeichen: " + lkw.Kennzeichen + "\r\nErstzulassung: " + lkw.Erstzulassung + "\r\nAnschaffungspreis: " + lkw.Anschaffungspreis + "\r\nAnzahlAchsen: " + lkw.Achsenanzahl + "\r\nZuladung: " + lkw.Zuladung + "\r\nStellplatz: " + lkw.Stellplatznummer;
break;
case "Fahrzeugverwaltung.Motorrad":
//Format auf Motorrad anwenden
Motorrad motorrad = f as Motorrad;
output = "\r\nHersteller: " + motorrad.Hersteller + "\r\nModell: " + motorrad.Modell + "\r\nKennzeichen: " + motorrad.Kennzeichen + "\r\nErstzulassung: " + motorrad.Erstzulassung + "\r\nAnschaffungspreis: " + motorrad.Anschaffungspreis + "\r\nHubraum: " + motorrad.Hubraum + "\r\nStellplatz: " + motorrad.Stellplatznummer;
break;
}
//String ausgeben, welcher alle Fahrzeugdaten zurückgibt
return(output);
}
public void neuesMotorradAnlegen(String aHersteller, String aModell, String aKennzeichen, String aErstzulassung, String aAnschaffungspreis, String aHubraum)
{
//Anlegen der Variablen für das Exception Handling
int hubraum = 0;
String stellplatznummer;
//Aufrufen der Methode ExceptionHandling Methode
//diese behandelt die Exceptions, welche in allen abgeleiteten Klassen der Basisklasse Fahzeug auftreten können
ExceptionHandling(aHersteller, aModell, aKennzeichen, aErstzulassung, aAnschaffungspreis);
//Vornehmen des spezifischen Exception Handlings für die Variablen der Klasse PKW
//prüfen, ob der String aHubraum in einen int transofrmiert werden kann
//prüfen, ob der String aHubraum ein Null Wert beinhaltet oder ein Leerzeichen beinhaltet
if (int.TryParse(aHubraum, out hubraum) == false || String.IsNullOrWhiteSpace(aHubraum))
{
throw new ArgumentException("Hubraum überprüfen");
}
//neues Motorrad zur Liste hinzufügen hinzufügen
Motorrad motorrad = new Motorrad(aHersteller, aModell, aKennzeichen, Convert.ToInt32(aErstzulassung), float.Parse(aAnschaffungspreis), Convert.ToInt32(aHubraum));
//Motorrad einem Stellplatz zuweisen
stellplatznummer = stellplatzZuweisen(motorrad);
//prüfen, ob ein freier Stellplatz gefunden wurde
if (stellplatznummer == "-1")
{
throw new ArgumentException("Kein freier Parkplatz gefunden.");
}
//wurde ein freier Stellplatz gefunden, wird die Stellplatznummer dem Motorrad beigefügt
else
{
motorrad.Stellplatznummer = stellplatznummer;
}
//Motorrad in die Fahrzeugliste hinzufügen
fahrzeugliste.Add(motorrad);
}
// Speichert alle Daten, Dialogfenster wird anschliesen geschlossen
private void buttonUebernehmen_Click(object sender, EventArgs e)
{
string Hersteller;
string Modell;
int Erstzulassung;
float Anschaffungspreis;
string Kennzeichen;
// Alle für PKW, LKW, Motorrad gemeinsamen Daten aus den Textboxen auslesen und umwandeln
Fahrzeug.TextToHersteller(textBoxHersteller.Text, out Hersteller);
Fahrzeug.TextToHersteller(textBoxModell.Text, out Modell);
Fahrzeug.TextToErstzulassung(textBoxErstzulassung.Text, out Erstzulassung);
Fahrzeug.TextToAnschaffungspreis(textBoxAnschaffungspreis.Text, out Anschaffungspreis);
Fahrzeug.TextToKennzeichen(textBoxKennzeichen.Text, out Kennzeichen);
// PKW ausgewaehlt
if (comboBoxFahrzeugTyp.SelectedIndex == 0)
{
int Hubraum;
int Leistung;
int Schadstoffklasse;
// Alle PKW spezifischen Daten aus den Textboxen auslesen und umwandeln
PKW.TextToHubraum(textBoxUnbestimmt_1.Text, out Hubraum);
PKW.TextToLeistung(textBoxUnbestimmt_2.Text, out Leistung);
PKW.TextToSchadstoffklasse(textBoxUnbestimmt_3.Text, out Schadstoffklasse);
// Neuen PKW mit eingegeben Daten erzeugen
Fahrzeug = new PKW(
Hersteller,
Modell,
Erstzulassung,
Anschaffungspreis,
Kennzeichen,
0, // Noch kein Parkhaus zugewiesen
0, // Noch kein Stellplatz zugewiesen
Hubraum,
Leistung,
Schadstoffklasse);
}
// LKW ausgewaehlt
else if (comboBoxFahrzeugTyp.SelectedIndex == 1)
{
int AnzahlAchsen;
float Zuladung;
// Alle LKW spezifischen Daten aus den Textboxen auslesen und umwandeln
LKW.TextToAnzahlAchsen(textBoxUnbestimmt_1.Text, out AnzahlAchsen);
LKW.TextToZuladung(textBoxUnbestimmt_1.Text, out Zuladung);
// Neuen LKW mit eingegeben Daten erzeugen
Fahrzeug = new LKW(
Hersteller,
Modell,
Erstzulassung,
Anschaffungspreis,
Kennzeichen,
0, // Noch kein Parkhaus zugewiesen
0, // Noch kein Stellplatz zugewiesen
AnzahlAchsen,
Zuladung);
}
// Motorad ausgewaehlt
else if (comboBoxFahrzeugTyp.SelectedIndex == 2)
{
int Hubraum;
// Alle Motorad spezifischen Daten aus den Textboxen auslesen und umwandeln
Motorrad.TextToHubraum(textBoxUnbestimmt_1.Text, out Hubraum);
// Neues Motorrad mit eingegeben Daten erzeugen
Fahrzeug = new Motorrad(
Hersteller,
Modell,
Erstzulassung,
Anschaffungspreis,
Kennzeichen,
0, // Noch kein Parkhaus zugewiesen
0, // Noch kein Stellplat zugewiesen
Hubraum);
}
}
/// <summary>
/// Beim Starten des Programmes werden alle Daten / Einträge aus der Datenbank in die Fahrzeugliste der Klasse übertragen,
/// damit sie vom letzten Programmablauf wieder zur Verfügung stehen. Die Datenbankanbindung wird mithilfe der Programmierschnitttelle
/// OLE-DB implementiert, wobei unterschiedliche Datenbankabfragen ausgeführt werden können.
/// </summary>
/// <param name="connectionString"></param>
public void datenAusDatenbankAuslesen(String connectionString)
{
OleDbCommand cmd;
DataSet dataSet = new DataSet();
String kennzeichen, hersteller, modell, typ, stellplatznummer;
float anschaffungspreis, zuladung;
int hubraum, erstzulassung, leistung, schadstoffklasse, achsenanzahl;
///SQL-Abfrage zur Wiederherstellung der bereits vorhandenen Fahrzeuge aus der Datenbank
string query = "SELECT kennzeichen, hersteller, modell, erstzulassung, anschaffungspreis, hubraum, leistung, schadstoffklasse, achsenanzahl, zuladung, typ, stellplatznummer FROM fahrzeugliste";
try
{
///Aufbau einer neuen datenbankverbindung
using (OleDbConnection connection = new OleDbConnection(connectionString))
{
using (cmd = new OleDbCommand(query, connection))
{
connection.Open();
OleDbDataReader reader = cmd.ExecuteReader();
/// Es wird jede Reihe aus der Datenbank ausgelesen, damit die Fahrzeuge wiederhergestellt werden können
while (reader.Read())
{
kennzeichen = reader["kennzeichen"].ToString();
hersteller = reader["hersteller"].ToString();
modell = reader["modell"].ToString();
erstzulassung = Int32.Parse(reader["erstzulassung"].ToString());
anschaffungspreis = float.Parse(reader["anschaffungspreis"].ToString());
hubraum = Int32.Parse(reader["hubraum"].ToString());
leistung = Int32.Parse(reader["leistung"].ToString());
schadstoffklasse = Int32.Parse(reader["schadstoffklasse"].ToString());
achsenanzahl = Int32.Parse(reader["achsenanzahl"].ToString());
zuladung = float.Parse(reader["zuladung"].ToString());
typ = reader["typ"].ToString();
stellplatznummer = reader["stellplatznummer"].ToString();
/// Abhängig von dem jeweiligen Fahrzeugtypen, wird ein neuer Fahrzeugtyp in die Liste eingefügt
switch (typ)
{
case "Fahrzeugverwaltung.PKW":
PKW pkw = new PKW(hersteller, modell, kennzeichen, erstzulassung, anschaffungspreis, hubraum, leistung, schadstoffklasse);
pkw.Stellplatznummer = stellplatznummer;
fahrzeugliste.Add(pkw);
break;
case "Fahrzeugverwaltung.Motorrad":
Motorrad motorrad = new Motorrad(hersteller, modell, kennzeichen, erstzulassung, anschaffungspreis, hubraum);
motorrad.Stellplatznummer = stellplatznummer;
fahrzeugliste.Add(motorrad);
break;
case "Fahrzeugverwaltung.LKW":
LKW lkw = new LKW(hersteller, modell, kennzeichen, erstzulassung, anschaffungspreis, achsenanzahl, zuladung);
lkw.Stellplatznummer = stellplatznummer;
fahrzeugliste.Add(lkw);
break;
}
}
reader.Close();
}
connection.Close();
}
}
catch
{
throw new ArgumentException("Inhalt konnte nicht geladen werden");
}
}
/// <summary>
/// Beim Verlassen des Programmes werden alle Daten / Einträge in der Fahrzeugliste in die separate Datenbank übertragen,
/// damit sie beim nächsten Programmstart wieder zur Verfügung stehen. Die Datenbankanbindung wird mithilfe der Programmierschnitttelle
/// OLE-DB implementiert, wobei unterschiedliche Datenbankabfragen ausgeführt werden können.
/// </summary>
/// <param name="connectionString"></param>
public void datenInDatenbankSichern(String connectionString)
{
OleDbCommand cmd;
DataSet dataSet = new DataSet();
Boolean entryExists = false;
try
{
///SQL-Queries in Abhängigkeit von dem Fahrzeugtypen erstellen
foreach (Fahrzeug fahrzeug in fahrzeugliste)
{
String fahrzeugtyp = fahrzeug.GetType().ToString();
String query = "Insert into Fahrzeugliste values('" + fahrzeug.Kennzeichen + "','" + fahrzeug.Hersteller + "','" + fahrzeug.Modell + "'," + fahrzeug.Erstzulassung + "," + fahrzeug.Anschaffungspreis + ",";
entryExists = false;
switch (fahrzeugtyp)
{
case "Fahrzeugverwaltung.PKW":
PKW pkw = fahrzeug as PKW;
query = query + pkw.Hubraum + "," + pkw.Leistung + "," + pkw.Schadstoffklasse + ",0,0,'" + pkw.GetType().ToString() + "','" + pkw.Stellplatznummer.ToString() + "');";
break;
case "Fahrzeugverwaltung.Motorrad":
Motorrad motorrad = fahrzeug as Motorrad;
query = query + motorrad.Hubraum + ",0,0,0,0,'" + motorrad.GetType().ToString() + "','" + motorrad.Stellplatznummer.ToString() + "');";
break;
case "Fahrzeugverwaltung.LKW":
LKW lkw = fahrzeug as LKW;
query = query + "0,0,0," + lkw.Achsenanzahl + "," + lkw.Zuladung + ",'" + lkw.GetType().ToString() + "','" + lkw.Stellplatznummer.ToString() + "');";
break;
}
///neue OLE-DB Verbindung herstellen, um auf die Datenbank zuzugreifen
using (OleDbConnection connection = new OleDbConnection(connectionString))
{
///prüfen, ob Kennzeichen bereits in der Datenbank vorhanden ist
using (cmd = new OleDbCommand("Select kennzeichen from Fahrzeugliste", connection))
{
connection.Open();
OleDbDataReader reader = cmd.ExecuteReader();
String kennzeichen;
while (reader.Read())
{
kennzeichen = reader["kennzeichen"].ToString();
if (kennzeichen.Equals(fahrzeug.Kennzeichen))
{
entryExists = true;
}
}
}
/// Wenn der Datensatz nicht existiert wird ein neuer Eintrag angelegt
if (!entryExists)
{
using (cmd = new OleDbCommand(query, connection))
{
OleDbDataAdapter dataAdapter = new OleDbDataAdapter(cmd);
dataAdapter.Fill(dataSet);
connection.Close();
dataSet.Dispose();
};
}
}
}
}
catch
{
throw new Exception("Datenbankeintrag konnte nicht angelegt werden");
}
}
// Lädt die Daten aller Fahrzeuge aus einer Datei
// Die Daten jedes Fahrzeugs sind in einer Zeile gespeichert
// Die einzelnen Daten eines Fahrzeuges sind durch das Zeichen ; getrennt
// Der Fahrzeugtyp ist das erste Datum in der Zeile
// z.B "PKW; VW; Käfer; 1965; 9999; K-GS-01; 1; 11; 1000; 30; 1"
private void LadenFahrzeuge()
{
string Textzeile;
// Öffne Textdatei zum Lesen
// Hier fehlt noch die Fehlerbehandlung, falls Datei nicht geöffnet werden kann
System.IO.StreamReader file = new System.IO.StreamReader(@"Fahrzeuge.txt");
// Schleife bis alle Textzeilen gelesen wurden
while ((Textzeile = file.ReadLine()) != null)
{
// Zerlege Textzeile und kopiere alle Datenelemente eines Fahrzeugs in ein String-Array
string[] DatenArray = Textzeile.Split(';');
// Erstes Datenelement gibt an, dass ein PKW erzeugt werden soll
if (DatenArray[0].Trim() == "PKW")
{
// Prüfe Datenzeile und erzeuge PKW, wenn Datenzeile OK ist
// Die Funktion PKW.ErzeugeFahrzeug gibt ein PKW Objekt zurück,
// wenn die Datenzeile Ok ist, sonst wird null zurückgegeben.
Fahrzeug fz = PKW.ErzeugeFahrzeug(Textzeile);
if (fz != null)
{
// Datenzeile war OK und Fahrzeug wurde erzeugt
// Füge Fahrzeug zur Fahrzeugliste hinzu
Fahrzeuge.Add(fz);
}
}
// Erstes Datenelement gibt an, dass ein LKW erzeugt werden soll
else if (DatenArray[0].Trim() == "LKW")
{
// Prüfe Datenzeile und erzeuge LKW, wenn Datenzeile OK ist.
// Die Funktion LKW.ErzeugeFahrzeug gibt ein LKW Objekt zurück,
// wenn die Datenzeile Ok ist, sonst wird null zurückgegeben.
Fahrzeug fz = LKW.ErzeugeFahrzeug(Textzeile);
if (fz != null)
{
// Datenzeile war OK und Fahrzeug wurde erzeugt
// Füge Fahrzeug zur Fahrzeugliste hinzu
Fahrzeuge.Add(fz);
}
}
// Erstes Datenelement gibt an, dass ein Motorrad erzeugt werden soll
else if (DatenArray[0].Trim() == "Motorrad")
{
// Prüfe Datenzeile und erzeuge Motorrad, wenn Datenzeile OK ist.
// Die Funktion Motorad.ErzeugeFahrzeug gibt ein Motorad Objekt zurück,
// wenn die Datenzeile Ok ist, sonst wird null zurückgegeben.
Fahrzeug fz = Motorrad.ErzeugeFahrzeug(Textzeile);
if (fz != null)
{
// Datenzeile war OK und Fahrzeug wurde erzeugt
// Füge Fahrzeug zur Fahrzeugliste hinzu
Fahrzeuge.Add(fz);
}
}
else
{
// Unbekannter Fahrzeugtyp. Die Textzeile wird ignoriert
}
}
// Schliesse Datei nachdem alle Daten gelesen wurden
file.Close();
}
static void Main(string[] args)
{
List<BaseFahrzeuge> autoStamm = new List<BaseFahrzeuge>();
List<BaseFahrzeuge> motorradStamm = new List<BaseFahrzeuge>();
List<BaseFahrzeuge> lieferwagenStamm = new List<BaseFahrzeuge>();
string input = "0";
const string doExit = "9";
while (input != doExit) // Magische Zahl "9" mit einer sprechenden Konstanten zu ersetzen macht den Code leichter verständlich
// Siehe http://de.wikipedia.org/wiki/Magische_Zahl_%28Informatik%29#Magische_Zahlen_in_Code
{
Console.WriteLine("Bitte wählen Sie eine Aktion:\n");
Console.WriteLine(" [1]= Auto ");
Console.WriteLine(" [2]= Motorrad");
Console.WriteLine(" [3]= Lieferwagen");
Console.WriteLine(" [8]= Alle anzeigen");
Console.WriteLine(" [9]= Beenden");
Console.WriteLine("**************************************************");
input = Console.ReadLine();
switch (input)
{
//Auto
case "1":
Console.WriteLine("AUTO erfassen\n");
BaseFahrzeuge auto = new Auto();
autoStamm.Add(auto);
break;
//Motorrad
case "2":
Console.WriteLine("MOTORRAD erfassen\n");
BaseFahrzeuge motorrad = new Motorrad();
motorradStamm.Add(motorrad);
break;
//Lieferwagen
case "3":
Console.WriteLine("LIEFERWAGEN erfassen\n");
BaseFahrzeuge lieferwagen = new Lieferwagen();
lieferwagenStamm.Add(lieferwagen);
break;
case "8":
// Den ganzen Code, den du hier unter case "8" hattest, habe ich in eine Methode AlleFahrzeugeAnzeigen ausgelagert
// Jetzt sieht man auf einem Blick, was case "8" eigentlich genau macht
// Vorher musste ich den ganze Code-Block durchlesen, um zu verstehen, was eigentlich genau gemacht wurde
// Generell ist das Ziel möglichst kleine Code-Häppchen zu haben und keine langen Code-Blöcke und Methoden
AlleFahrzeugeAnzeigen(autoStamm, motorradStamm, lieferwagenStamm);
break;
}
}
}
static void Main(string[] args)
{
// (1) Fahrzeugobjekte anlegen
Auto a1 = new Auto("LU 25958", "Toyota", "Corolla");
Auto a2 = new Auto("LU 122298");
a2.Marke = "Volvo";
a2.Typ = "V40";
a2.Motor.Hubraum = 1800; //ccm
a2.Motor.Leistung = 135; //PS
a2.Motor.AnzahlZylinder = 4; //Zylinder
a2.Motor.Bauart = Motorbauuarten.ReihenMotor;
Auto a3 = new Auto("LU 64624", "VW", "Käfer", 1500 /*ccm*/, 70 /*PS*/, 4 /*Zylinder*/, Motorbauuarten.BoxerMotor);
//
Motorrad m1 = new Motorrad("LU 14062", "Kawasaki", "Zephir");
Motorrad m2 = new Motorrad("LU 14064");
m2.Marke = "Piaggio";
m2.Typ = "Vespa";
m2.Motor.Hubraum = 125; //ccm
m2.Motor.Leistung = 8; //PS
m2.Motor.AnzahlZylinder = 1; //Zylinder
Motorrad m3 = new Motorrad("LU 74256", "Yamaha", "XV Wildstar", 1600 /*ccm*/, 63 /*PS*/, 2 /*Zylinder*/, Motorbauuarten.VMotor);
//
Fahrrad f1 = new Fahrrad("K124AS123", "Wheeler", "Cross1");
Fahrrad f2 = new Fahrrad("D424AS144");
f2.Marke = "Wheeler";
f2.Typ = "Cross3";
Fahrrad f3 = new Fahrrad("K123AD351", "Wheeler", "Cross3");
// (2) Fahrzeugobjekte im Fahrzeugverzeichnis(Arrayliste) speichern
Fahrzeugverzeichnis f = new Fahrzeugverzeichnis();
f.Add(a1);
f.Add(a2);
f.Add(a3);
f.Add(m1);
f.Add(m2);
f.Add(m3);
f.Add(f1);
f.Add(f2);
f.Add(f3);
// (3) Personenobjekte erstellen
Person p1 = new Person();
p1.setPersNr(120);
p1.setName("Gugerli");
p1.setVorname("Armin");
p1.setStrasse("Schürstrasse");
p1.getWohnort().setPlz("6020");
p1.getWohnort().setOrt("Emmenbruecke");
Person p2 = new Person(123, "Bucher", "Roland", "Sonnbüel13");
p2.getWohnort().setPlz("6024");
p2.getWohnort().setOrt("Hildisrieden");
Person p3 = new Person(130, "Waldburger", "Max", "Hauptweg 101", new Ortschaft("8805", "Freienbach"));
// (4) Fahrzeuge den Personenobjekten zuweisen oder/und umgekehrt
a1.setBesitzer(p2);
m1.setBesitzer(p2);
a2.setBesitzer(p2);
p1.AddFahrzeug(a2);
p1.AddFahrzeug(f2);
// (5) Ausgabe aller Fahrzeuge
Console.WriteLine("*********************************");
Console.WriteLine("A L L E F A H R Z E U G E ");
Console.WriteLine("*********************************");
foreach (Fahrzeug f in Fahrzeugverzeichnis.Fahrzeuge)
{
f.Datenausgabe();
Console.WriteLine("----------------------------------");
}
Console.WriteLine("*********************************");
Console.WriteLine("A L L E P E R S O N E N ");
Console.WriteLine("*********************************");
p1.Datenausgabe();
p2.Datenausgabe();
p3.Datenausgabe();
Console.ReadLine();
}
