Exemplo n.º 1
0
        // Fügt ein Fahrzeug zur Liste hinzu
        public void FahrzeugHinzufuegen(Fahrzeug value)
        {
            Fahrzeuge.Add(value);

            // Aktualisiert die Stellplatzzuordnugen in allen Parkhäusern
            StellplatzZuordnungAktualisieren();
        }
Exemplo n.º 2
0
        // Kontruktor für den Stellplatz zuweisen Dialog
        public FormStellplatzZuweisen(Verwaltung pVerwaltung, Fahrzeug pFahrzeug)
        {
            verwaltung = pVerwaltung;
            fahrzeug   = pFahrzeug;

            // Initialisiere alle Elemente des Dialogs
            // Der Inhalt dieser Funktion wird von Visual Studio erzeugt und soll nicht mauell verändert werden
            InitializeComponent();

            // Fülle Combobox mit allen vorhandenen Parkhäusern
            for (int iParkhaus = 0; iParkhaus < verwaltung.AnzahlParkhaeuser; iParkhaus++)
            {
                // Hole Parkhaus-Objekt aus der Parkhausliste
                Parkhaus ph = verwaltung.ParkhausGet(iParkhaus);

                // Füge Parkhaus (Nummer, Ort, Strasse) zur Combobox hinzu
                comboBoxParkhaus.Items.Add("Parkhaus " + ph.ParkhausNummer + ", " + ph.Ort + ", " + ph.Strasse);
            }

            // Füge zusätzlichen Eintrag "Zuweisung löschen" hinzu, wenn Fahrzeug bereits einen zugwiesenen Stellplatz hat
            if ((fahrzeug.ParkhausNummer > 0) && (fahrzeug.StellplatzNummer > 0))
            {
                comboBoxParkhaus.Items.Add("Stellplatzzuweisung löschen");
            }

            // Wähle erstes (Index = 0) Parkhaus aus
            comboBoxParkhaus.SelectedIndex = 0;
        }
        // Funktion wird aufgerufen, wenn der Stellplatz zuweisen Button gedrückt wurde
        // Die Funktion öffnet einen Dialog, in welchem dem ausgewählten Fahrzeug
        //   ein Parkhaus und ein Stellplatz zugewiesen werden kann
        private void buttonStellplatzZuweisen_Click(object sender, EventArgs e)
        {
            if (listViewFahrzeuge.SelectedItems.Count == 1)
            {
                // Hole Index des selktierten Eintrags
                int ListviewIndex = listViewFahrzeuge.SelectedItems[0].Index;

                // Hole Fahrzeug mit dem Index aus Liste
                Fahrzeug fz = Verwaltung.FahrzeugGet(ListviewIndex);

                // Erzeuge neues Dialog-Objekt
                FormStellplatzZuweisen form = new FormStellplatzZuweisen(Verwaltung, fz);

                // Setzte Title des Dialogs mit Typ und Kennzeichen des Fahrzeugs
                form.Text = "Stellplatz zuweisen für " + fz.Typ + " " + fz.Kennzeichen;
                form.ShowDialog();

                // Prüfen ob Dialog mit OK beendet wurde
                if (form.DialogResult == DialogResult.OK)
                {
                    // Die Darstellung der Parkhausdaten und Fahrzeuge wird aktualisiert
                    View_Update();
                }

                // Der Fokus wird wieder auf den vorher selektierten Eintrag gestzt
                listViewFahrzeuge.Select();
                listViewFahrzeuge.Items[ListviewIndex].Focused  = true;
                listViewFahrzeuge.Items[ListviewIndex].Selected = true;
            }
        }
Exemplo n.º 4
0
        // Weist einem Fahrzeug ein Parkhaus mit Stellplatz zu
        public void StellplatzZuweisen(Fahrzeug fz, int ParkhausNummer, int StellplatzNummer)
        {
            if ((ParkhausNummer > 0) && (StellplatzNummer > 0))
            {
                // Parkhaus suchen
                for (int iParkhaus = 0; iParkhaus < AnzahlParkhaeuser; iParkhaus++)
                {
                    Parkhaus ph = ParkhausGet(iParkhaus);
                    if (ph.ParkhausNummer == ParkhausNummer)
                    {
                        // Parkhaus gefunden, Stellplatz suchen
                        for (int iStellplatz = 0; iStellplatz < ph.AnzahlStellplaetze; iStellplatz++)
                        {
                            Stellplatz sp = ph.StellPlaetze[iStellplatz];
                            if (sp.Nummer == StellplatzNummer)
                            {
                                // Stellplatz gefunden, Parkhaus und Stellplatz dem Fahrzeug zuweisen
                                fz.ParkhausNummer   = ph.ParkhausNummer;
                                fz.StellplatzNummer = sp.Nummer;
                            }
                        }
                    }
                }
            }
            // Stellplatzzuweisung löschen
            else
            {
                fz.ParkhausNummer   = 0;
                fz.StellplatzNummer = 0;
            }

            // Aktualisiert die Stellplatzzuordnugen in allen Parkhäusern
            StellplatzZuordnungAktualisieren();
        }
Exemplo n.º 5
0
        // Erzeugt ein LKW Objekt aus einer Datenzeile.
        // Die Datenzeile wird geprüft.
        // Sind die Daten OK wird ein LKW Objekt erzeugt und zurückgegeben.
        // Sind die Daten nicht OK wird kein LKW Objekt erzeugt und es wird null zurückgegeben.
        // Jede Datenzeile muss folgendermassen aufgebaut sein
        // <Fahrzeugtyp>;<Fahrzeugmodell>;<Jahr der Erstzulassung>;<Anschaffungspreis>;<Kennzeichen>;<AnzahlAchsen>;<Zuladung>
        // Beispiel: LKW; Mercedes; LG 315; 1960; 23000; K-GS-04; 2; 5,5
        public static LKW ErzeugeFahrzeug(
            string Datenzeile)
        {
            string Hersteller;
            string Modell;
            int    Erstzulassung;
            float  Anschaffungspreis;
            string Kennzeichen;
            int    ParkhausNummer;
            int    StellplatzNummer;

            int   AnzahlAchsen = 0;
            float Zuladung     = 0;

            // Prüfe, die für alle Fahrzeuge gemeinsamen Daten, durch Funktion der Elternklasse
            bool DatenOk = Fahrzeug.TextToFahrzeugDaten(
                Datenzeile,
                out Hersteller,
                out Modell,
                out Erstzulassung,
                out Anschaffungspreis,
                out Kennzeichen,
                out ParkhausNummer,
                out StellplatzNummer);

            // Prüfen der LKW Daten, wenn gemeinsame Daten OK sind
            if (DatenOk)
            {
                string[] DataArray = Datenzeile.Split(';');

                // Erstes Datenelement muss LKW sein
                if (DataArray[0] != "LKW")
                {
                    DatenOk = false;
                }

                // Prüfe und kopiere Achsenanzahl
                if (DatenOk)
                {
                    DatenOk = TextToAnzahlAchsen(DataArray[8], out AnzahlAchsen);
                }

                // Prüfe und kopiere Zuladung
                if (DatenOk)
                {
                    DatenOk = TextToZuladung(DataArray[8], out Zuladung);
                }
            }

            // Erzeuge PKW Objekt, wenn die Daten OK sind. Sonst wird null zurückgegeben.
            if (DatenOk)
            {
                return(new LKW(Hersteller, Modell, Erstzulassung, Anschaffungspreis, Kennzeichen, ParkhausNummer, StellplatzNummer, AnzahlAchsen, Zuladung));
            }
            else
            {
                return(null);
            }
        }
Exemplo n.º 6
0
        public static Fahrzeug sucheFahrzeug(List <Fahrzeug> aFahrzeugliste, String kennzeichen)
        {
            //finden des Fahrzeugs in der Fahrzeugliste
            Fahrzeug f = aFahrzeugliste.Find(x => x.Kennzeichen.Contains(kennzeichen));

            //Zurückgeben des Ergebnisses
            return(f);
        }
Exemplo n.º 7
0
        // Erzeugt ein Motorad Objekt aus einer Datenzeile.
        // Die Datenzeile wird geprüft.
        // Sind die Daten OK wird ein Motorad Objekt erzeugt und zurückgegeben.
        // Sind die Daten nicht OK wird kein Motorad Objekt erzeugt und es wird null zurückgegeben.
        // Jede Datenzeile muss folgendermassen aufgebaut sein
        // <Fahrzeugtyp>;<Fahrzeugmodell>;<Jahr der Erstzulassung>;<Anschaffungspreis>;<Kennzeichen>;<Hubraum>
        // Beispiel: Motorrad; BMW; R1200R; 1999; 6000; K-GS-03; 1170
        public static Motorrad ErzeugeFahrzeug(
            string Datenzeile)
        {
            string Hersteller;
            string Modell;
            int    Erstzulassung;
            float  Anschaffungspreis;
            string Kennzeichen;
            int    ParkhausNummer;
            int    StellplatzNummer;

            int Hubraum = 0;

            // Prüfe, die für alle Fahrzeuge gemeinsamen Daten, durch Funktion der Elternklasse
            bool DatenOk = Fahrzeug.TextToFahrzeugDaten(
                Datenzeile,
                out Hersteller,
                out Modell,
                out Erstzulassung,
                out Anschaffungspreis,
                out Kennzeichen,
                out ParkhausNummer,
                out StellplatzNummer);

            // Prüfen der Motorad Daten, wenn gemeinsame Daten OK sind
            if (DatenOk)
            {
                string[] DataArray = Datenzeile.Split(';');

                if (DatenOk)
                {
                    if (DataArray[0] != "Motorrad")
                    {
                        DatenOk = false;
                    }
                }

                // Wandle String in int um für Hubraum (50 ccm - 2000 ccm)
                if (DatenOk)
                {
                    DatenOk = PruefeInteger(DataArray[8], 50, 2000, out Hubraum);
                }
            }

            // Erzeuge Motorad Objekt, wenn die Daten OK sind. Sonst wird null zurückgegeben.
            if (DatenOk)
            {
                return(new Motorrad(Hersteller, Modell, Erstzulassung, Anschaffungspreis, Kennzeichen, ParkhausNummer, StellplatzNummer, Hubraum));
            }
            else
            {
                return(null);
            }
        }
Exemplo n.º 8
0
        public String stellplatzZuweisen(Fahrzeug f)
        {
            //Definieren einer Abbruchvariable
            bool abbruch = false;
            //Stellplatznummer standardmäßig auf -1 setzen
            //wird -1 zurückgegeben, indiziert dies, dass kein freier Parkplatz gefunden wurde
            String stellplatznummer = "-1";

            //Schleife über alle Parkhäuser in der Parkhausliste laufen lassen
            foreach (Parkhaus element in Parkhausverwaltung.Parkhausliste)
            {
                //Schleife über alle Stellplätze in einem Parkplatz
                foreach (Stellplatz s in element.Stellplatzliste)
                {
                    //Fahrzeugtyp abfregen
                    String fahrzeugtyp = f.GetType().ToString();
                    //prüfen ob der Stellplatz belegt
                    if (s.IstBelegt == false)
                    {
                        //Prüfen, ob der Stellplatztyp dem Typ des Fahrzeugs entspricht
                        if (s.Stellplatztyp == fahrzeugtyp)
                        {
                            //dem Stellplatz das Kennzeichen zuweisen
                            s.Kennzeichen    = f.Kennzeichen;
                            s.Parkhausnummer = element.Parkhausnummer;
                            //stellplatznummer zuweisen
                            stellplatznummer = s.Nummer;
                            //Variable istBelegt des Stellplatzes auf true stellen
                            s.IstBelegt = true;
                            //Schleifen durchlauf abbrechen
                            abbruch = true;
                            break;
                        }
                    }
                }
                //prüfen, ob die Schleife abgebrochen wurde
                //ist der Fall, wenn ein freier Stellplatz gefunden wurde
                if (abbruch == true)
                {
                    break;
                }
            }
            //stellplatznummer zurückgeben
            return(stellplatznummer);
        }
Exemplo n.º 9
0
        // Speichert die Daten aller Fahrzeug in einer Datei
        // Die Daten eines Fahrzeugs sind in einer Zeile gespeichert
        // Die einzelnen Daten eines Fahrzeuges sind durch das Zeichen ; getrennt
        // z.B "PKW; VW; Käfer; 1965; 9999; K-GS-01; 1; 11; 1000; 30; 1"
        private void SpeichernFahrzeuge()
        {
            // Öffne Datei zum Schreiben der Fahrzeugdaten
            System.IO.StreamWriter file = new System.IO.StreamWriter("Fahrzeuge.txt");

            // Schleife über alle Fahrzeuge
            for (int ii = 0; ii < AnzahlFahrzeuge; ii++)
            {
                // Hole Fahrzeugobjekt aus der Fahrzeugliste
                Fahrzeug fz = FahrzeugGet(ii);

                // Wandle Fahrzeugobjekt in String und speichere diesen als Textzeile in Datei
                file.WriteLine(fz.ToString());
            }

            // Schliesse Datei nachdem alle Daten geschrieben wurden
            file.Close();
        }
Exemplo n.º 10
0
        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);
        }
Exemplo n.º 11
0
        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);
        }
Exemplo n.º 12
0
        // 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);
            }
        }
        // Aktualisiert die Darstellung der Fahrzeuge im Hauptfenster
        private void ViewFahrzeuge_Update()
        {
            string GewaehlterFahrzeugTyp = comboBoxFahrzeugTyp.Text;
            string GewaehltesKennzeichen = textBoxKennzeichen.Text.Trim();

            // Gesamte über alle Fahrzeuge aufsummierte KFZ-Steuer
            float SteuerGesamt = 0f;

            // Lösche alle Einträge im Listview
            listViewFahrzeuge.Items.Clear();

            // Spalten mit zusätzliche PKW-Daten
            if (GewaehlterFahrzeugTyp == "PKW")
            {
                columnUnbestimmt_1.Text = "Hubraum";
                columnUnbestimmt_2.Text = "Leistung";
                columnUnbestimmt_3.Text = "Schadstoffklasse";
            }
            // Spalten mit zusätzliche LKW-Daten
            else if (GewaehlterFahrzeugTyp == "LKW")
            {
                columnUnbestimmt_1.Text = "Achsen";
                columnUnbestimmt_2.Text = "Zuladung";
                columnUnbestimmt_3.Text = "";
            }
            // Spalten mit zusätzliche Motoraddaten
            else if (GewaehlterFahrzeugTyp == "Motorrad")
            {
                columnUnbestimmt_1.Text = "Hubraum";
                columnUnbestimmt_2.Text = "";
                columnUnbestimmt_3.Text = "";
            }
            // Keine Zusatzdaten, wenn alle Fahrzeugtypen dargestellt werden
            else
            {
                columnUnbestimmt_1.Text = "";
                columnUnbestimmt_2.Text = "";
                columnUnbestimmt_3.Text = "";
            }

            // Füge die Daten aller Fahrzeuge zum Listview hinzu
            for (int ii = 0; ii < Verwaltung.AnzahlFahrzeuge; ii++)
            {
                // Hole Fahrzeugobjekt aus der fahrzeugliste
                Fahrzeug fz = Verwaltung.FahrzeugGet(ii);

                // Filter für Fahrzeugtyp und Kennzeichen anwenden
                // Gewaelter Fahrzeugtyp muss "Alle" sein oder Fahrzeug muss dem gewählten Typ entsprechen
                //  und
                // Eingegebenes Kennzeichen muss leer sein oder der Anfang des Fahrzeugkennzeichens sein
                if (((GewaehlterFahrzeugTyp == "Alle") || (fz.Typ == GewaehlterFahrzeugTyp)) &&
                    ((GewaehltesKennzeichen.Length == 0) || (fz.Kennzeichen.IndexOf(GewaehltesKennzeichen) == 0)))
                {
                    // Addiere Steuer des Fahrzeuges zur Gesamtsteuer
                    float Steuer = fz.Steuer;
                    SteuerGesamt += Steuer;

                    // Alle dargestellten Daten eines Fahrzeuges werden in ein Array kopiert
                    // Das Array entspricht einer Zeile im Listview
                    // Jedes Array-Element entspricht dabei einer Spalte im Listview
                    string[] ListviewZeile = new string[12];

                    // Spalte 1: Typ
                    ListviewZeile[0] = fz.Typ;

                    // Spalte 2: Hersteller
                    ListviewZeile[1] = fz.Hersteller;

                    // Spalte 3: Modell
                    ListviewZeile[2] = fz.Modell;

                    // Spalte 4: Kennzeichen
                    ListviewZeile[3] = fz.Kennzeichen;

                    // Spalte 5: Parkhausnummer
                    if (fz.ParkhausNummer > 0)
                    {
                        ListviewZeile[4] = fz.ParkhausNummer.ToString();
                    }
                    else
                    {
                        ListviewZeile[4] = "-";
                    }

                    // Spalte 6: Stellplatznummer
                    if (fz.StellplatzNummer > 0)
                    {
                        ListviewZeile[5] = fz.StellplatzNummer.ToString();
                    }
                    else
                    {
                        ListviewZeile[5] = "-";
                    }

                    // Spalte 7: Jahr der Erstzulassung
                    ListviewZeile[6] = fz.Erstzulassung.ToString();

                    // Spalte 8:  Anschaffungspreis in Euro mit 2 Nachkommastellen (C2)
                    ListviewZeile[7] = String.Format("{0:C2}", fz.Anschaffungspreis);

                    // Spalte 9:  Steuer in Euro mit 2 Nachkommastellen (C2)
                    ListviewZeile[8] = String.Format("{0:C2}", Steuer);

                    // Zusätzliche PKW-Daten
                    if (GewaehlterFahrzeugTyp == "PKW")
                    {
                        ListviewZeile[9]  = ((PKW)fz).Hubraum.ToString() + " ccm";;
                        ListviewZeile[10] = ((PKW)fz).Leistung.ToString() + " kW";;
                        ListviewZeile[11] = ((PKW)fz).Schadstoffklasse.ToString();
                    }
                    // Zusätzliche LKW-Daten
                    else if (GewaehlterFahrzeugTyp == "LKW")
                    {
                        ListviewZeile[9]  = ((LKW)fz).AnzahlAchsen.ToString();
                        ListviewZeile[10] = ((LKW)fz).Zuladung.ToString() + " t";
                        ListviewZeile[11] = "";
                    }
                    // Zusätzliche Motorraddaten
                    else if (GewaehlterFahrzeugTyp == "Motorrad")
                    {
                        ListviewZeile[9]  = ((Motorrad)fz).Hubraum.ToString() + " ccm";
                        ListviewZeile[10] = "";
                        ListviewZeile[11] = "";
                    }
                    // Keine Zusatzdaten, wenn alle Fahrzeugtypen dargestellt werden
                    else
                    {
                        ListviewZeile[9]  = "";
                        ListviewZeile[10] = "";
                        ListviewZeile[11] = "";
                    }


                    // Füge neue Zeile  mit Fahrzeugdaten zum Listview hinzu
                    listViewFahrzeuge.Items.Add(new ListViewItem(ListviewZeile));
                }
            }

            // Passe die Breite aller Spalten so an, dass alle Daten sichtbar sind
            foreach (ColumnHeader ch in listViewFahrzeuge.Columns)
            {
                ch.Width = -2;
            }

            // Ausgabe der Gesamtsteuer
            labelSteuerGesamt.Text = String.Format("{0:C2}", SteuerGesamt);
        }
Exemplo n.º 14
0
        // Trägt das Kennzeichen jedes Fahrzeugs, das einen Stellplatzeintag besitzt,
        // in den jeweiligen Stellplatz des jeweiligen Parkhauses ein.
        // Die Funktion muss nach folgenden Aktionen aufgerufen werden:
        //    - nach dem Laden der Parkhäuser und Fahrzeuge
        //    - nach dem Löschen eines Fahrzeuges
        //    - nach dem Hinzufügen eines Fahrzeuges
        //    - nach der Zuweisung eines Stellplatzes zu einem Parkhaus
        //    - nach dem Löschen eines Parkhauses
        private void StellplatzZuordnungAktualisieren()
        {
            // Alle Stellplatzzuweisungen in allen Parkhäusern löschen
            for (int iParkhaus = 0; iParkhaus < AnzahlParkhaeuser; iParkhaus++)
            {
                Parkhaus ph = Parkhaeuser[iParkhaus];

                // Lösche alle Kennzeichen aus allen Stellplätzen
                for (int iStellplatz = 0; iStellplatz < ph.AnzahlStellplaetze; iStellplatz++)
                {
                    ph.StellPlaetze[iStellplatz].Kennzeichen = "";
                }
            }

            // Suche für alle Fahrzeuge mit zugeordenten Stellplatz das Stellplatzobjekt
            for (int iFahrzeug = 0; iFahrzeug < AnzahlFahrzeuge; iFahrzeug++)
            {
                Fahrzeug fz = Fahrzeuge[iFahrzeug];

                int ZugeordnetesParkhaus   = fz.ParkhausNummer;
                int ZugeordneterStellplatz = fz.StellplatzNummer;

                // Für gültige Stellplatzzuordnung müssen Parkhaus- und Stellplatznummer größer 0 sein
                if ((ZugeordnetesParkhaus > 0) && (ZugeordneterStellplatz > 0))
                {
                    // Wird auf true gesetzt, wenn Stellplatz gefunden wurde
                    bool StellplatzGefunden = false;

                    // Suche zugeordnetes Parkhause
                    for (int iParkhaus = 0; (iParkhaus < AnzahlParkhaeuser) && (StellplatzGefunden == false); iParkhaus++)
                    {
                        Parkhaus ph = Parkhaeuser[iParkhaus];
                        if (ph.ParkhausNummer == ZugeordnetesParkhaus)
                        {
                            // Parkhaus gefunden, suche zugeordneten Stellplatz
                            for (int iStellplatz = 0; (iStellplatz < ph.AnzahlStellplaetze) && (StellplatzGefunden == false); iStellplatz++)
                            {
                                Stellplatz sp = ph.StellPlaetze[iStellplatz];
                                // Zuweisung wenn
                                //   - Stellplatznummer übereinstimmt und
                                //   - Stellplatztyp mit Fahrzeugtyp übereinstimmt und
                                //   - Stellplatz frei ist
                                if ((ZugeordneterStellplatz == sp.Nummer) &&
                                    (sp.Typ == fz.Typ) &&
                                    (sp.Kennzeichen.Length == 0))
                                {
                                    sp.Kennzeichen     = fz.Kennzeichen;
                                    StellplatzGefunden = true;
                                }
                            }
                        }
                    }
                    // Lösche Stellplatzzuordnung im Fahrzeug,
                    //  - wenn der Parkhaus oder Stellplatz nicht gefunden wurde oder
                    //  - wenn der Stellplatz nicht frei ist
                    if (StellplatzGefunden == false)
                    {
                        fz.ParkhausNummer   = 0;
                        fz.StellplatzNummer = 0;
                    }
                }
            }
        }
Exemplo n.º 15
0
        // 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();
        }
Exemplo n.º 16
0
        // Erzeugt ein PKW Objekt aus einer Datenzeile.
        // Die Datenzeile wird geprüft.
        // Sind die Daten OK wird ein PKW Objekt erzeugt und zurückgegeben.
        // Sind die Daten nicht OK wird kein PKW Objekt erzeugt und es wird null zurückgegeben.
        // Jede Datenzeile muss folgendermassen aufgebaut sein
        // <Fahrzeugtyp>;<Fahrzeugmodell>;<Jahr der Erstzulassung>;<Anschaffungspreis>;<Kennzeichen>;<Hubraum>;<Leistung>;<Schadstoffklasse>
        // Beispiel: PKW; VW; Käfer; 1965; 9999; K-GS-01; 1000; 30; 1
        public static PKW ErzeugeFahrzeug(
            string Datenzeile)
        {
            string Hersteller;
            string Modell;
            int    Erstzulassung;
            float  Anschaffungspreis;
            string Kennzeichen;
            int    ParkhausNummer;
            int    StellplatzNummer;

            int Hubraum          = 0;
            int Leistung         = 0;
            int Schadstoffklasse = 0;

            // Prüfe, die für alle Fahrzeuge gemeinsamen Daten, durch Funktion der Elternklasse
            // Prüfe, die für alle Fahrzeuge gemeinsamen Daten, durch Funktion der Elternklasse
            bool DatenOk = Fahrzeug.TextToFahrzeugDaten(
                Datenzeile,
                out Hersteller,
                out Modell,
                out Erstzulassung,
                out Anschaffungspreis,
                out Kennzeichen,
                out ParkhausNummer,
                out StellplatzNummer);


            // Prüfen der PKW Daten, wenn gemeinsame Daten OK sind
            if (DatenOk)
            {
                // Kopieren der durch ; getrennten Datenelement aus einer Textzeile in ein Array
                string[] DataArray = Datenzeile.Split(';');

                // Erstes Datenelement muss PKW sein
                if (DataArray[0] != "PKW")
                {
                    DatenOk = false;
                }

                // Prüfe und kopiere Hubraum
                if (DatenOk)
                {
                    DatenOk = TextToHubraum(DataArray[8], out Hubraum);
                }

                // Prüfe und kopiere Leistung
                if (DatenOk)
                {
                    DatenOk = TextToLeistung(DataArray[9], out Leistung);
                }

                // Prüfe und kopiere Schadstoffklasse
                if (DatenOk)
                {
                    DatenOk = TextToSchadstoffklasse(DataArray[10], out Schadstoffklasse);
                }
            }

            // Erzeuge PKW Objekt, wenn die Daten OK sind. Sonst wird null zurückgegeben.
            if (DatenOk)
            {
                return(new PKW(Hersteller, Modell, Erstzulassung, Anschaffungspreis, Kennzeichen, ParkhausNummer, StellplatzNummer, Hubraum, Leistung, Schadstoffklasse));
            }
            else
            {
                return(null);
            }
        }