Schleife mit gleichen Werten

Guten Morgen zusammen,

zur Zeit sitze ich an einer Einsendeaufgabe und bei meiner Konsolenausgabe erhalte ich im Sekundentakt immer den gleichen Wert und die Schleife endet nicht....
Bin gerade absolut überfragt, wo genau mein Fehler liegt....

Der Code besteht aus Aufgaben von mehreren Kapiteln und mit "Neu: ESA_Projekt Aufgabe..." habe ich die Codes aus der Einsendeaufgabe hinzugefügt....

Hier mein geschriebener Code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;
using System.IO;

namespace ESA_Projekt
{
    delegate void TransponderDel(string kennung, Position pos);

    interface ITransponder
    {
        void Transpond(string kennung, Position pos);
    }

    enum Düsenflugzeugtyp
    {
        A300, A310, A318, A319, A320, A321, A330, A340, A380
    }

    public struct Position
    {
        public int x, y, h;

        public Position(int x, int y, int h)
        {
            this.x = x;
            this.y = y;
            this.h = h;
        }

        public void PositionAendern(int deltaX, int deltaY, int deltaH)
        {
            x = x + deltaX;
            y = y + deltaY;
            h = h + deltaH;
        }

        //public void HoeheAendern(int deltaH)
        //{
        //    h = h + deltaH;
        //}
    }
    abstract class Luftfahrzeug
    {
        protected string kennung;
        public string Kennung
        {
            protected set { kennung = value; }
            get { return kennung; }
        }

        protected Position pos;

        public abstract void Steigen(int meter);
        public abstract void Sinken(int meter);
    }

    class Flugzeug : Luftfahrzeug
    {
        protected Position zielPos;
        protected int streckeProTakt;
        protected int flughoehe;
        protected int steighoeheProTakt;
        protected int sinkhoeheProTakt;
        protected bool steigt = false;
        protected bool sinkt = false;

        public void Starte(Position zielPos, int streckeProTakt, int flughoehe, int steighoeheProTakt, int sinkhoeheProTakt)
        {
            this.zielPos = zielPos;
            this.streckeProTakt = streckeProTakt;
            this.flughoehe = flughoehe;
            this.steighoeheProTakt = steighoeheProTakt;
            this.sinkhoeheProTakt = sinkhoeheProTakt;
            this.steigt = true;
        }

        public Flugzeug(string kennung, Position startPos)
        {
            this.kennung = kennung;
            this.pos = startPos;
        }

        public override void Steigen(int meter)
        {
            //pos.HoeheAendern(meter);
            pos.PositionAendern(0, 0, meter);
            Console.WriteLine(kennung + " steigt " + meter + " Meter, neue Höhe=" + pos.h);
        }
        public override void Sinken(int meter)
        {
            //pos.HoeheAendern(-meter);
            pos.PositionAendern(0, 0, -meter);
            Console.WriteLine(kennung + " sinkt " + meter + " Meter, neue Höhe=" + pos.h);
        }
    }

    class Starrflügelflugzeug : Flugzeug, ITransponder
    {
        public Starrflügelflugzeug(string kennung, Position startPos) : base(kennung, startPos)
        {
            //Program.transponder += new TransponderDel(Transpond);
            //Program.transponder += Transpond;
        }

        //Neu: ESA_Projekt Aufgabe 3
        protected BinaryWriter writer;
        protected string protokoll;
        public string Protokoll
        {
            get { return protokoll; }
        }

        public void Transpond(string kennung, Position pos)
        {
            //if (kennung.Equals(this.kennung))
            //    Console.WriteLine("{0} an Position x={1}, y={2}", kennung, pos.x, pos.y);

            DateTime timestamp = DateTime.Now;
            if (kennung.Equals(this.kennung))
            {
                Console.Write("{0}:{1}", timestamp.Minute, timestamp.Second);
                Console.Write("\t{0}-Position: {1}-{2}-{3}", this.kennung, base.pos.x, base.pos.y, base.pos.h);
                Console.Write("Zieldistanz: {0} m\n", Zieldistanz());

                //Neu: ESA_Projekt Aufgabe 3
                if (Program.protokollieren && writer != null)
                {
                    writer.Write(pos.x);
                    writer.Write(pos.y);
                    writer.Write(pos.h);
                }
            }
            else
            {
                double abstand = Math.Sqrt(Math.Pow(this.pos.x - pos.x, 2) + Math.Pow(this.pos.y - pos.y, 2));
                Console.Write("\t{0} ist {1} m von {2} entfernt.\n", this.kennung, (int)abstand, kennung);

                if (Math.Abs(this.pos.h - pos.h) < 100 && abstand < 500)
                    Console.WriteLine("\tWARNUNG: {0} hat nur {1} m Höhenabstand!", kennung, Math.Abs(this.pos.h - pos.h));
            }
        }

        double a, b, alpha, a1, b1;
        bool gelandet = false;

        private bool SinkenEinleiten()
        {
            double strecke = Math.Sqrt(Math.Pow(streckeProTakt, 2) - Math.Pow(sinkhoeheProTakt, 2));
            int sinkstrecke = (int)(strecke * (pos.h - zielPos.h) / sinkhoeheProTakt);
            int zieldistanz = Zieldistanz();

            if (sinkstrecke >= zieldistanz)
            {
                //Console.WriteLine("{0} Sinkstrecke {1} >= Zieldistanz {2}", kennung, sinkstrecke, zieldistanz);
                return true;
            }
            else
                return false;
        }

        private void PositionBerechnen(double strecke, int steighoeheProTakt)
        {
            a = zielPos.x - pos.x;
            b = zielPos.y - pos.y;
            alpha = Math.Atan2(b, a);
            a1 = Math.Cos(alpha) * strecke;
            b1 = Math.Sin(alpha) * strecke;
            pos.PositionAendern((int)a1, (int)b1, steighoeheProTakt);
        }

        private int Zieldistanz()
        {
            return (int)Math.Sqrt(Math.Pow(zielPos.x - pos.x, 2) + Math.Pow(zielPos.y - pos.y, 2));
        }

        public void Steuern()
        {
            if (steigt)
            {
                if (this.SinkenEinleiten())
                {
                    steigt = false;
                    sinkt = true;
                }
                else if (pos.h > flughoehe)
                {
                    steigt = false;
                }
            }
            else if (sinkt)
            {
                if (pos.h <= zielPos.h + steighoeheProTakt)
                    gelandet = true;
            }
            else
            {
                if (this.SinkenEinleiten())
                {
                    sinkt = true;
                }
            }
            if (!gelandet)
            {
                Program.transponder(kennung, pos);
                if (steigt)
                {
                    double strecke = Math.Sqrt(Math.Pow(streckeProTakt, 2) - Math.Pow(steighoeheProTakt, 2));
                    this.PositionBerechnen(strecke, steighoeheProTakt);
                }
                else if (sinkt)
                {
                    double strecke = Math.Sqrt(Math.Pow(streckeProTakt, 2) - Math.Pow(sinkhoeheProTakt, 2));
                    this.PositionBerechnen(strecke, -sinkhoeheProTakt);
                }
                else
                {
                    this.PositionBerechnen(streckeProTakt, 0);
                }
            }
            else
            {
                Program.fliegerRegister -= this.Steuern;
                Program.transponder -= this.Transpond;
                Console.WriteLine("\n{0} gelandet (Zieldistanz={1}, Höhendistanz={2})", kennung, Zieldistanz(), pos.h - zielPos.h);

                if (Program.protokollieren && writer != null)
                {
                    writer.Write(pos.x);
                    writer.Write(pos.y);
                    writer.Write(pos.h);
                    writer.Close();
                }
            }
        }
    }

    class Düsenflugzeug : Starrflügelflugzeug
    {
        protected Düsenflugzeugtyp typ;

        protected int sitzplaetze;
        private int fluggaeste;
        public int Fluggaeste
        {
            set
            {
                if (sitzplaetze < (fluggaeste + value))
                    Console.WriteLine("Keine Buchung: Die " + "Fluggastzahl würde mit der Zubuchung " + "von {0} Plätzen die verfügbaren Plätze " + " von {1} um {2} übersteigen!", value, sitzplaetze, value + fluggaeste - sitzplaetze);
                else
                    fluggaeste += value;
            }
            get { return fluggaeste; }
        }
        public Düsenflugzeug(string kennung, Position startPos) : base(kennung, startPos) { }
        
        public void Starte()
        {
            Console.WriteLine("Flieger \"{0}\", Typ {1} ({2} Sitzplätze) startet", Kennung, typ, sitzplaetze);
            steigt = true;
            Program.transponder += this.Transpond;
            Program.fliegerRegister += this.Steuern;
        }

        //Neu: ESA_Projekt Aufgabe 3
        public void Flugschreiber()
        {
            if (Program.protokollieren)
            {
                DateTime timestamp = DateTime.Now;
                string pfad = kennung + "_" + timestamp.Day + "-" + timestamp.Hour + "-" + timestamp.Minute + "-" + timestamp.Second + ".bin";
                protokoll = pfad;

                writer = new BinaryWriter(File.Open(pfad, FileMode.Create));
                string header = "Flug \"" + kennung + "\" (Typ " + this.typ + ") startet an Position " + pos.x + "-" + pos.y + "-" + pos.h + " mit Zielposition " + zielPos.x + "-" + zielPos.y + "-" + zielPos.h;
                writer.Write(header);
            }
        }

        public void Buchen(int plätze)
        {
            Fluggaeste += plätze;
        }

        //public bool Starte()
        //{
        //    string pfad = @".\" + kennung + ".init";
        //    StreamReader reader;
        //    try
        //    {
        //        reader = new StreamReader(File.Open(pfad, FileMode.Open));
        //    }
        //    catch (IOException e)
        //    {
        //        Console.WriteLine("{0} Fehler beim Zugriff auf die Datei " + pfad, e.GetType().Name);
        //        return false;
        //    }
        //    int[] data = new int[9];
        //    for (int i = 0; i < 9; i++)
        //    {
        //        string str = reader.ReadLine();
        //        str = str.Substring(str.IndexOf('=') + 1);
        //        //Console.WriteLine(str);
        //        data[i] = Int32.Parse(str);
        //    }
        //    reader.Close();
        //    this.zielPos.x = data[0];
        //    this.zielPos.y = data[1];
        //    this.zielPos.h = data[2];
        //    streckeProTakt = data[3];
        //    flughoehe = data[4];
        //    steighoeheProTakt = data[5];
        //    sinkhoeheProTakt = data[6];
        //    //"typ" aus data[7] initialisieren
        //    Array typen = Enum.GetValues(typeof(Düsenflugzeugtyp));
        //    this.typ = (Düsenflugzeugtyp)typen.GetValue(data[7]);
        //    sitzplaetze = data[8];
        //    Console.WriteLine("Flug {0} vom Typ {1} mit {2} Plätzen initialisiert.", kennung, typ, sitzplaetze);
        //    steigt = true;
        //    Console.WriteLine();
        //    return true;
        //}
    }

    class Program
    {
        public static TransponderDel transponder;

        public delegate void FliegerRegisterDel();
        public static FliegerRegisterDel fliegerRegister;


        //Neu: ESA_Projekt Aufgabe 3
        public static bool protokollieren = true;

        public void ProgrammTakten()
        {
            Düsenflugzeug flieger1 = new Düsenflugzeug("LH 500", new Position(3500, 1500, 180));
            Düsenflugzeug flieger2 = new Düsenflugzeug("LH 3000", new Position(3000, 2000, 100));

            flieger1.Starte();
            flieger2.Starte();

            while (fliegerRegister != null)
            {
                fliegerRegister();
                Console.WriteLine();
                Thread.Sleep(1000);
            }
        }

        //Neu: ESA_Projekt Aufgabe 4
        public void ProtokollAusgeben(string protokoll)
        {
            BinaryReader reader = new BinaryReader(File.Open(protokoll, FileMode.Open));
            Console.WriteLine(reader.ReadString());
            bool goOn = true;
            while (goOn)
            {
                try
                {
                    for (int i = 0; i < 3; i++)
                        Console.Write("\t{0}", reader.ReadInt32());
                }
                catch
                {
                    goOn = false;
                }
                reader.Close();
                Console.WriteLine();
            }
        }

        static void Main(string[] args)
        {
            Program test = new Program();
            test.ProgrammTakten();
        }
    }
}

Ich würde mich freuen, wenn jemand meinen Fehler erkennt und mir helfen kann... 🙂

LG Irina

Deine Schleife läuft solange bis fliegerRegister NULL ist. Eventuell sollte dort eine andere bzw. weitere Aussteige-Bedingung rein.
Wenn ich es richtig im Debug ( [Artikel] Debugger: Wie verwende ich den von Visual Studio?) gesehen habe, solltest Du Dir nochmal die Methode PositionBerechnen anschauen. Deine Flugzeuge steigen u. sinken nie und bekommen keine neue Position.

Du musst deinen Flieger starten lassen

Starte(Position zielPos, int streckeProTakt, int flughoehe, int steighoeheProTakt, int sinkhoeheProTakt)

Da kannst du dann mitgeben wie weit er sich pro Takt/Sekunde bewegen soll.
Dein Flieger wird nicht gestartet, also bewegt er sich nicht.
Vielleicht hilft ja das.

Vielen Dank für die schnellen Rückantworten.....
Diese haben mir sehr geholfen und ich konnte den Code endlich richtig umsetzen....

Wünsche noch einen schönen Tag.

LG Irina