Laden...

Werte in Datei schreiben

Letzter Beitrag vor 3 Jahren 3 Posts 849 Views
Werte in Datei schreiben

Hallo,

ich habe eine Aufgabe bei der ich nicht mehr weiter komme. Vorab der Code. Unten schreibe ich die Details.


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

namespace ESA_Projekt
{
    public delegate void TransponderDel(string kennung, Position pos);
    interface ITransponder
    {
        void Transpond(string kennung, Position pos);
    }
    enum Airbus : short { A300, A310, A318, A319, A320, A321, A330, A340, A380, Boeing_717, Boeing_737, Boeing_747, Boeing_777, Boeing_BBJ }

    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 PositionÄndern(int deltaX, int deltaY, int deltaH)
        {
            x = x + deltaX;
            y = y + deltaY;
            h = h + deltaH;
        }
        public void HöheÄndern(int deltaH)//Aufruf in Sinken/Steigen
        {
            h = h + deltaH;
        }
    }

    abstract class Luftfahrzeug
    {
        public string kennung;

        public string Kennung
        {
            protected set { kennung = value; }
            get { return kennung; }
        }

        private int sitzplätze;
        private int fluggäste;
        public int Fluggäste
        {
            set
            {
                if (sitzplätze < (fluggäste + 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, sitzplätze, value + fluggäste - sitzplätze);
                else
                    fluggäste += value;
            }
            get { return fluggäste; }
        }

        public Position pos;
        public abstract void Steigen(int meter);
        public abstract void Sinken(int meter);

    }

    class Flugzeug : Luftfahrzeug
    {
        public Position zielPos;
        protected int streckeProTakt;
        protected int flughöhe;
        protected int steighöheProTakt;
        protected int sinkhöheProTakt;
        protected bool steigt = false;
        protected bool sinkt = false;

        public void Starte(Position zielPos, int streckeProTakt, int flughöhe, int steighöheProTakt, int sinkhöheProTakt)
        {
            // neu Lektion 3
            this.zielPos = zielPos;
            this.streckeProTakt = streckeProTakt;
            this.flughöhe = flughöhe;
            this.steighöheProTakt = steighöheProTakt;
            this.sinkhöheProTakt = sinkhöheProTakt;
            this.steigt = true;
        }

        public Flugzeug(string kennung, Position startPos)
        {
            this.kennung = kennung;
            this.pos = startPos;
        }
        public override void Steigen(int meter)
        {
            pos.HöheÄndern(meter);
            Console.WriteLine(kennung + "steigt " + meter + "Meter, Höhe =" + pos.h);
        }

        public override void Sinken(int meter)
        {
            pos.HöheÄndern(-meter);
            Console.WriteLine(kennung + "sinkt " + meter + "Meter, 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;
        }
        public void Transpond(string kennung, Position pos)
        {
            double abstand = Math.Sqrt(Math.Pow(this.pos.x - pos.x, 2) + Math.Pow(this.pos.y - pos.y, 2));
            //if (kennung.Equals(this.kennung))
            //  Console.WriteLine("{0} an Position x={1}, y={2}, h={3}", kennung, pos.x, pos.y, pos.h);
            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());
            }
            else
            {
                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("\tWARNUNF: {0} hat nur {1} m Höhenabstand!", kennung, Math.Abs(this.pos.h - pos.h));
            }
        }

        // Neu Lektion 3
        double a, b, alpha, a1, b1;
        bool gelandet = false;


        private bool SinkenEinleiten()
        {
            double strecke = Math.Sqrt(Math.Pow(streckeProTakt, 2) - Math.Pow(sinkhöheProTakt, 2));
            int sinkstrecke = (int)(strecke * (pos.h - zielPos.h) / sinkhöheProTakt);
            int zieldistanz = Zieldistanz();
            if (sinkstrecke >= zieldistanz)
            {
                //optinale Consolenausgabe zur Kontrolle
                Console.WriteLine("{0} Sinkstrecke {1} >= Zieldistanz {2}", kennung, sinkstrecke, zieldistanz);
                return true;
            }
            else
                return false;
        }

        // Beim Sinkflug ist ein negativer Wert für den zweiten
        // Parameter anzugeben.

        private void PositionBerechnen(double strecke, int steighöheProTakt)
        {
            // modifizierte Übernahme der bisherigen Berechungen aus "Steuern"
            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.PositionÄndern((int)a1, (int)b1, steighöheProTakt);
        }
        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 > flughöhe)
                {
                    steigt = false;
                }
            }
            else if (sinkt)
            {
                if (pos.h <= zielPos.h + sinkhöheProTakt)
                    gelandet = true;
            }
            else
            {
                //Horizontalflug
                if (this.SinkenEinleiten())
                {
                    sinkt = true;
                }
            }
            if (!gelandet)
            {
                // Zunächst die aktuelle Position ausgeben:
                Program.transponder(kennung, pos);
                //"Strecke" (am Boden) berechnen:
                if (steigt)
                {
                    double strecke = Math.Sqrt(Math.Pow(streckeProTakt, 2) - Math.Pow(steighöheProTakt, 2));
                    this.PositionBerechnen(strecke, steighöheProTakt);
                }
                else if (sinkt)
                {
                    double strecke = Math.Sqrt(Math.Pow(streckeProTakt, 2) - Math.Pow(sinkhöheProTakt, 2));
                    this.PositionBerechnen(strecke, -sinkhöheProTakt);
                }
                else
                {
                    // im Horizontalflug ist "strecke" gleich "streckeProTakt"
                    this.PositionBerechnen(streckeProTakt, 0);
                }
            }
            else
            {
                // Flieger derigistrieren, Transponder abschalten, Abschlussmeldung
                Program.fliegerRegister -= this.Steuern;
                Program.transponder -= this.Transpond;
                Console.WriteLine("\n{0} gelandet (Zieldistanz={1}, Höhendistanz={2}", kennung, Zieldistanz(), pos.h - zielPos.h);
                
            }

            

            
        }



    }

    class Düsenflugzeug : Starrflügelflugzeug
    {
        // CSH03 Lektion 5
        public Airbus typ;
        private int sitzplätze;
        public Düsenflugzeug(string kennung, Position startPos) : base(kennung, startPos)
        {
            bool initialized = this.Starte();
            if (initialized)
            {
                Program.transponder += this.Transpond;
                Program.fliegerRegister += this.Steuern;
               
            }
        }

        public void SchreibeProtokoll( string kennung, Position startPos)
        {
           
            string DoW = DateTime.Now.DayOfWeek.ToString();
            string HoD = DateTime.Now.Hour.ToString();
            string MoD = DateTime.Now.Minute.ToString();
            string SoD = DateTime.Now.Second.ToString();
            string headerContent;
            string LogPath;

            LogPath = @"C:\Users\MyName\source\repos\ESA_CSH03B\ESA_Projekt\bin\Debug\" + kennung + "_" + DoW + "-" + HoD + "-" + MoD + "-" + SoD + ".bin";

            headerContent = "Flug " + kennung + " (Typ " + typ + ") startet an Position " + startPos.x + "-" + startPos.y + "-" + startPos.h + " mit Zielposition " + zielPos.x + "-"+ zielPos.y +"-"+ zielPos.h +".";

            
            
            BinaryWriter writer = new BinaryWriter(File.Open(LogPath, FileMode.Create));
            writer.Write(headerContent);
           
             while(pos.x != null)
            {
                Console.WriteLine(" Testmarker" + pos.x +","+ pos.y +"," + pos.h +"");
                Console.ReadLine();
            }
            
            writer.Close();


        }

        public bool Starte()
        {

            string pfad = @"C:\Users\MyName\source\repos\ESA_CSH03B\ESA_Projekt\" + 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);
                //Zur Kontrolle, später auskommentieren
                //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];
            flughöhe = data[4];
            steighöheProTakt = data[5];
            sinkhöheProTakt = data[6];
            //"typ" aus data[7] initialisieren
            Array typen = Enum.GetValues(typeof(Airbus));
            this.typ = (Airbus)typen.GetValue(data[7]);
            sitzplätze = data[8];
            Console.WriteLine("Flug {0} vom Typ {1} mit {2} Plätzen initialisiert.", kennung, typ, sitzplätze);
            steigt = true;
            Console.WriteLine();
        
            return true;
        }


    }

     class Program
    {

        public static TransponderDel transponder;
        // Wiederholungsaufgabe 2.3
        public delegate void FliegerRegisterDel();
        public static FliegerRegisterDel fliegerRegister;

        public static bool protokollieren = true;

       
        public void ProgrammTaken()
        {
       
            Düsenflugzeug flieger1 = new Düsenflugzeug("LH 500", new Position(3500, 1400, 180));
            Düsenflugzeug flieger2 = new Düsenflugzeug("LH 3000", new Position(3000, 2000, 100));
            
            
            while (fliegerRegister != null)
            {
                
                fliegerRegister();

                Console.WriteLine();
                 
                
                Thread.Sleep(1000);
                
            }

            




        }

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

Meine Aufgabe besteht darin für 2 Flieger (flieger1 und flieger2) die Flugkoordinaten in eine jeweils für den entsprechenden flieger gefertigte Datei zu schreiben. Also sprich eine Art "Blackbox" zu entwickeln.

Mit der Methode ProtokollErstellen() (welche ich für diesen zweck geschrieben habe) werden die Dateien erstellt und der Header der des Fluges (string headerContent) in die Datei geschrieben. Das funktioniert alles.

Das was nun NICHT funktioniert sind die fortlaufenden Koordinaten X,Y,H wobei das H für die Höhe steht.

in der Datei Sollte das dann SO aussehehn:
Flug LH (Typ A300) startet an Position 1000,200,200 mit Zielposition 300,44,4.

1000 201 399
1000 342 300
200 233 234

Dabei muss beachtet werden dass X,Y, und H int werte sein müssen.

ich habe es mit einer whileschleife versucht


while(fliegerRegister 1= null)
{

    writer.write();
}

bekomme aber nur
"ESA_Project.Program.FliegerRegisterDel" in die Datei geschrieben.

was mache ich hier falsch?

vielen dank im Vorraus

Du wirst irgendwo statt dem Inhalt die Klasse als Typ in die Datei schreiben; sehe aber auf die Schnelle auch nicht wo.
Solche Fehler kannst Du aber sehr einfach selbst mit dem Debugger analysieren.
[Artikel] Debugger: Wie verwende ich den von Visual Studio?

Ansonsten Feedback:
Statt ne Plaintext-Datei, speicher solche Dinge lieber in eine XML.


<Protocol>
<Aircraft Type="ABC" From="X" To="Y" />
<Positions>
   <Position On="DateTimeOffset ISO8601" X="" Y="" H="" />
   <Position On="DateTimeOffset ISO8601" X="" Y="" H="" />
   <Position On="DateTimeOffset ISO8601" X="" Y="" H="" />
   <Position On="DateTimeOffset ISO8601" X="" Y="" H="" />
   <Position On="DateTimeOffset ISO8601" X="" Y="" H="" />
   <Position On="DateTimeOffset ISO8601" X="" Y="" H="" />
   <Position On="DateTimeOffset ISO8601" X="" Y="" H="" />
   <Position On="DateTimeOffset ISO8601" X="" Y="" H="" />
   <Position On="DateTimeOffset ISO8601" X="" Y="" H="" />
   <Position On="DateTimeOffset ISO8601" X="" Y="" H="" />
   <Position On="DateTimeOffset ISO8601" X="" Y="" H="" />
   <Position On="DateTimeOffset ISO8601" X="" Y="" H="" />
</Positions>

Deutscher Quellcode resultiert immer in einem Deutsch-Englisch-Mix; nie schön. Aber auch wenn Du in C# mit Umlauten arbeiten kannst, mögen das manche Tooling-Umgebungen nicht. Also wenn es unbedingt in Deutsch sein muss, lass wenigstens die Umlaute weg. Damit machst Du vor allem Dir einen Gefallen.

steigt = false;
sinkt = true;

Man sollte sowas niemals in zwei verschiedenen Booleans speichern, da Du ansonsten zwei Wahrheiten hast.
Nimm dafür nen Enum; dafür sind sie da.

Man verwendet DateTimeOffset für das Halten von Zeitwerden. DateTime braucht man eigentlich nie (wird leider immer noch oft verwendet; und oft leider falsch).

Hallo,

da sind noch einige Fehler in deinem Code.
Warum benutzt du BinaryWriter zum Schreiben einer Textdatei (anstatt z.B. StreamWriter, s.a. Vorgehensweise: Schreiben in eine Textdatei)?
Außerdem schreibst du in deiner SchreibeProtokoll-Methode die Daten nur auf die Konsole, anstatt in die Datei.

Generell ist der Aufbau deines Codes auch viel zu sehr vermischt. Du solltest UI (Konsole), Logik und Dateizugriff voneinander trennen, s. [Artikel] Drei-Schichten-Architektur.
Die Flugzeug-Klassen sollten keinerlei UI- oder Dateizugriffscode enthalten.
Und auch die Benutzung der statischen Program-Member innerhalb der Logik-Klassen ist schlechtes Design.

PS: Warum benutzt du festgelegte Pfade zum Lesen und Schreiben der Dateien (s.a. mein "PS" in Wie kann ich auf einzelne Elemente in einer ObservableCollection zugreifen um das Format zu ändern?)?