예제 #1
0
        public void neuenPKWAnlegen(String aHersteller, String aModell, String aKennzeichen, String aErstzulassung, String aAnschaffungspreis, String aHubraum, String aLeistung, String aSchadstoffklasse)
        {
            //Anlegen von Variablen, die zum Überprüfen der Exceptions verwendet werden
            int    hubraum          = 0;
            int    leistung         = 0;
            int    schadstoffklasse = 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");
            }
            //prüfen, ob der String aLeistung in einen int transofrmiert werden kann
            //prüfen, ob der String aLeistung ein Null Wert beinhaltet oder ein Leerzeichen beinhaltet
            if (int.TryParse(aLeistung, out leistung) == false || String.IsNullOrWhiteSpace(aLeistung))
            {
                throw new ArgumentException("Leistung überprüfen");
            }
            //prüfen, ob der String aSchadstoffklasse in einen int transofrmiert werden kann
            //prüfen, ob der String aSchadstoffklasse ein Null Wert beinhaltet oder ein Leerzeichen beinhaltet
            if (int.TryParse(aSchadstoffklasse, out schadstoffklasse) == false || String.IsNullOrWhiteSpace(aSchadstoffklasse))
            {
                throw new ArgumentException("Schadstoffklasse überprüfen");
            }

            try
            {
                //neuen PKW zur Liste hinzufügen hinzufügen
                PKW pkw = new PKW(aHersteller, aModell, aKennzeichen, Convert.ToInt32(aErstzulassung), float.Parse(aAnschaffungspreis), Convert.ToInt32(aHubraum), Convert.ToInt32(aLeistung), Convert.ToInt32(aSchadstoffklasse));
                //PKW einem Stellplatz zuweisen
                stellplatznummer = stellplatzZuweisen(pkw);
                //prüfen, ob kein freier Stellplatz gefunden wurde
                if (stellplatznummer == "-1")
                {
                    throw new ArgumentException("Kein freier Stellplatz gefunden.");
                }
                //wurde ein freier Stellplatz geunden, wird dem PKW die Stellplatz nummer beigefügt
                else
                {
                    pkw.Stellplatznummer = stellplatznummer;
                }
                //neuen PKW der Fahrzeugliste hinzufügen
                fahrzeugliste.Add(pkw);
            }

            //Abfangen einer Exception, sollte eine aufgerufen werden
            catch (ArgumentException ex)
            {
                throw new ArgumentException(ex.Message);
            }
        }
예제 #2
0
        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;
                }
            }
        }
예제 #3
0
        // Wird aufgerufen, wenn sich der Inhalt der Textbox Unbestimmt_2 geändert hat.
        // Die Funktion prüft den Wert und stellt den Hintergrund im Fehlerfall rot dar.
        // PKW    : Textbox Unbestimmt_2 enthält Leistung
        // LKW    : Textbox Unbestimmt_2 enthält Zuladung
        // Motorad: Textbox Unbestimmt_2 ist niht benutzt
        private void textBoxUnbestimmt_2_TextChanged(object sender, EventArgs e)
        {
            // PKW ausgewaehlt
            if (comboBoxFahrzeugTyp.SelectedIndex == 0)
            {
                int i;

                // Prüfe Leistung, zurückgegebener Wert wird nicht verwendet
                AlleDatenOK[6] = PKW.TextToLeistung(textBoxUnbestimmt_2.Text, out i);
            }
            // LKW ausgewaehlt
            else if (comboBoxFahrzeugTyp.SelectedIndex == 1)
            {
                float f;

                // Prüfe Zuladung, zurückgegebener Wert wird nicht verwendet
                AlleDatenOK[6] = LKW.TextToZuladung(textBoxUnbestimmt_2.Text, out f);
            }
            // Motorad ausgewaehlt
            else
            {
                // Keine Daten für Motorad, daher immer OK
                AlleDatenOK[6] = true;
            }

            // Hintergrundfarbe der Textbox normal wenn Daten OK
            if (AlleDatenOK[6])
            {
                textBoxUnbestimmt_2.BackColor = System.Drawing.SystemColors.Window;
            }
            // Hintergrundfarbe der Textbox rot wenn Daten nicht OK
            else
            {
                textBoxUnbestimmt_2.BackColor = System.Drawing.Color.LightCoral;
            }

            // Enable OK Button, wenn keine Fehler
            // Alle Elemente von AlleDatenOK müssen true sein
            AktualisiereOkButton();
        }
예제 #4
0
        // 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();
        }
예제 #5
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);
        }
예제 #6
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);
        }
예제 #7
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);
            }
        }
예제 #8
0
        /// <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");
            }
        }
예제 #9
0
        /// <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");
            }
        }
예제 #10
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();
        }