Willkommen auf myCSharp.de! Anmelden | kostenlos registrieren
 | Suche | FAQ

Hauptmenü
myCSharp.de
» Startseite
» Forum
» Suche
» Regeln
» Wie poste ich richtig?

Mitglieder
» Liste / Suche
» Wer ist online?

Ressourcen
» FAQ
» Artikel
» C#-Snippets
» Jobbörse
» Microsoft Docs

Team
» Kontakt
» Cookies
» Spenden
» Datenschutz
» Impressum

  • »
  • Portal
  • |
  • Mitglieder
Beiträge von Loofsy
Thema: Datenübertragung mit JSON
Am im Forum: Netzwerktechnologien

Hallo,

durch ein logging habe ich herrausgefunden, dass die daten zwar richtig an den server rausgehen jedoch der server die anführungszeichen entfernt.

der Folgende code ist der empfangsteil


public static void ReadCallback(IAsyncResult ar)
        {
            _serverOperate = new Process();
                String content = String.Empty;

                // Retrieve the state object and the handler socket  
                // from the asynchronous state object.  
                StateObject state = (StateObject)ar.AsyncState;
                Socket handler = state.workSocket;
                // Read data from the client socket.
                int bytesRead = handler.EndReceive(ar);

                if (bytesRead > 0)
                {
                    // There  might be more data, so store the data received so far.  
                    state.sb.Append(Encoding.ASCII.GetString(
                        state.buffer, 0, bytesRead));

                    // Check for end-of-file tag. If it is not there, read
                    // more data.  
                    content = state.sb.ToString();
                if (content.IndexOf("<EOF>") > -1)
                {
                    // All the data has been read from the
                    // client. Display it on the console.  
                    //Console.WriteLine("Read {0} bytes from socket. \n Data : {1}",
                    //    content.Length, content);
                    // Echo the data back to the client.  
                    try
                    {


                        _serverOperate.StartInfo.FileName = _operationAppPath;
                        _serverOperate.StartInfo.Arguments = "" + DBHost + ";" + DBName + ";" + DBUserName + ";" + DBUserPassword + ";" + content;
                        _serverOperate.StartInfo.UseShellExecute = false;
                        _serverOperate.StartInfo.RedirectStandardOutput = true;
                        _serverOperate.Start();
                        StreamReader reader = _serverOperate.StandardOutput;
                        string output = reader.ReadToEnd();
                        Application.Base.SysLogger.WriteLog(output, @"H:\Test.txt"); //Speichert den empfangenen json in eine textdatei
                        Send(handler, output);
                    }
                    catch(Exception err)
                    {
                        Send(handler, err.Message);
                    }

                }
                else
                {
                    // Not all data received. Get more.  
                    handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
                    new AsyncCallback(ReadCallback), state);
                }

Thema: Datenübertragung mit JSON
Am im Forum: Netzwerktechnologien

Hallo

Ich habe folgende Frage:

Ich möchte daten (Text) mittels JSON von meinem Client an einen Server Übertragen (funktioniert auch). Die Daten werden vor dem Versenden in ein Json Formatiert (funktioniert auch)
{"TEST":"datan"}

Der server empängt die anfrage und sendet diese jedoch ohne anführungszeichen zurück. Im meinem Fall wird der ankommende string einfach wieder nur zurückgeschickt.

Woran kann das liegen? Ich nutze C# und System.Text.Json.

Danke im vorraus

Thema: Wie Json mit Double Quotes statt Single Quotes serialisieren?
Am im Forum: Grundlagen von C#

Danke Apt

hatte mit dem aber nix zu tun.

Sollte ein seperater thread werden. Ich habs schon den Mods gemeldet

Thema: Wie Json mit Double Quotes statt Single Quotes serialisieren?
Am im Forum: Grundlagen von C#

Hallo an alle,

ich würde gerne einen string in JSON serialisieren (Klappt auch) und wieder Deserialisieren (das klappt nicht)

ich bekomme dabei den Fehler das ein illegales Zeichen um Pfad ist.


public string BaseDeserializer(string json)
        {
            try
            {
                    IncomeData uld = JsonConvert.DeserializeObject<IncomeData>(json);
                    return uld.ApplicationName; 
            }
            catch(Exception err)
            {
                string a = err.Message ;

                return a;
            }
           
        }

Was mir aufgefallen ist, dass der Serialisierte JSON ('') benutzt statt("") macht das einen unterschied? wenn ja wie bekomme ich das weg?

danke im vorraus

Thema: Antwort aus Programm herraus
Am im Forum: Grundlagen von C#

@Abt,

wie meinst du das mit den technischen Bedingungen?

Thema: Antwort aus Programm herraus
Am im Forum: Grundlagen von C#

@Abt,

zunächst Danke ich dir für deine (wenn auch sehr kritisch formulierte) Antwort. Ich bin aber sicher, dass du diese nicht als persönlichen Angriff meintest daher werte ich dies auch nicht so.

Zum Thema Sicherheit: Du hast Recht! Diese weise der Programmierung ist sehr unsicher. Stell dir vor, die Daten werden sogar unverschlüsselt übertragen und das hat seinen Grund!
Die Anwendung bildet ersteinmal nur das Grundgerüst. Das Fundament sozusgen. Sie ist rein Experimentell (noch). Erstmal soll alles im Grundprinzip funktionieren. Der Ausbau und die Sicherheit kommt erst dann in den eigentlichen Testphasen und bis dahin ist es noch ein sehr sehr weiter weg. Zudem soll sie ohnehin nur für meine Privaten zwecke verwendet werden und keine Nutzerdaten übers Inet transportieren.

Die Bedingungen zum aufrufen der arbeitsanwendung stehen doch da!
Bei einer Clientanfrage empfängt der Server die Daten, öffnet das programm und leitet die Daten an das Programm weiter; anschließend wartet der Server auf die Antwort des Programms und sendet die antwort zurück an den client. das Programm schließt sich automatisch nach der abarbeitung und wird immer nur aufgerufen wenn ein Client eine anfrage sendet!

lg

Thema: Antwort aus Programm herraus
Am im Forum: Grundlagen von C#

Danke T-Virus,

das ".Start()" habe ich übersehen. Aber ändert leider das Problem nicht. Der gleiche fehler tritt auf.
ich habe das zwischen StreamReader oder StandartOutput geschrieben.

Thema: Antwort aus Programm herraus
Am im Forum: Grundlagen von C#

Hallo liebe Mitentwickler,

ich arbeite gerade an einem flexiblen Serversystem und möchte wissen ob die folgende umsetzung möglich ist.

Mein Server soll in der Lage sein, anfragen aus dem Internet (egal ob vom Handy, Tablet, PC oder what ever) aufzunehmen und zu verarbeiten. (Funktioniert auch). Nun soll er aber flexibler werden. Ich möchte nun Mehrere Serverinstanzen auf verschiedenen Ports starten (funktioniert auch) und die empfangenen Daten jedoch underschiedlich behandeln. Dazu Soll jeder Server ein jeweils eigenes Programm aufrufen, die daten übergeben und (jetzt kommt der casus knacksus) dieses Programm soll die Antwort an den Server zurückgeben und dieser an den Client zurücksenden.

Die eigentliche Client Server Communikation funktioniert auch.
Im Internet habe ich die Methode "RedirectStandartOutput" gefunden welche (so die quelle) die Antwort als Consle.WriteLine(); an den Server zurückgeben soll


_serverOperate.StartInfo.FileName = _operationAppPath; // enthält den Path des Programms welches die eigentliche Verarbeitung durchführt und die antwort an den Client ausgibt (Soll vom Server aufgerufen werden und nach der Antwortausgabe wieder geschlossen werden)
                    _serverOperate.StartInfo.Arguments = ""+DBHost+";"+DBName+";"+DBUserName+";"+DBUserPassword+";"+content; // content enthält einen JSon string
                    _serverOperate.StartInfo.UseShellExecute = false;
                    _serverOperate.StartInfo.RedirectStandardOutput = true;
                    StreamReader reader = _serverOperate.StandardOutput;
                    string output = reader.ReadToEnd();
                    Send(handler, output); // sendet die daten an den Client zurück

Ich bekomme jedoch eine Exeption ausgegeben
Fehler
"System.InvalidOperationException: StandartOut wurde nicht Umgeleitet, oder der Prozess wurde noch nicht gestartet."


Nun ist meine Frage: Leide ich an Programmierblindheit oder ist das so wie ich das umsetzen möchte gar nicht möglich und och habe die Methode falsch verstanden?

Vielen Dank im Vorraus

Thema: ByteArray in Object Convertieren
Am im Forum: Netzwerktechnologien

Hallo liebe Mitentwickler,

ich habe folgende frage:

Ich habe ein Client Serversystem entwickelt. Dieses soll nun die Möglichkeit haben verschiedene Objekte wie String, Integers, oder auch DataSet´s zum client zu senden.

dazu ist es (für mich) wichtig das die ankommenden Daten (als ByteArray) als object zu konvertieren.

Die derzeitige Lösung überführt das Array jedoch in einen String was nicht sein soll.


Encoding.ASCII.GetString(state.buffer, 0, bytesRead)

Um die Zwischenschritte zu Dokumentieren habe ich kein kleines Loggongprogramm geschrieben.

Nun Passiert folgendes:

wenn mein Client nun daten aus einer Datenbank (MS SQL) benötigt, sendet er die Anfrage an seinen Server. Der server wiederrum kommuniziert mit der Datenbank und sendet nun die erhalltenen Daten zurück an den Client.

Wenn ich nun ein DataGridView mit diesen Daten füllen will, versuche ich das so:


dgv1.DataSource = _client.RequestToServer(sqlString); //RequestToServer ist vom Datentyp object

der Server soll nun ein DataSet übermitteln!

Laut dem ankommenden Logdaten kommt jedoch nur der String "Table" zurück. Wie kann ich also das ByteArray in object convertieren um das opject dann später als DataSet zu convertieren?

vielen dank für die Hilfe.

Thema: Xamarin StackLayout über ViewModel darstellen
Am im Forum: GUI: WPF und XAML

Hallo,

ich versuche mich gerade an meiner ersten Xamarin App. Nachdem ich auf der default Page (die von Visual Studio generiert wurde) ein bisschen Experimentiert habe, möchte ich nun den Content nicht über XAML schreiben sondern zb. einen Text oder Content zb aus einer MSSQL oder MySQL Datenbank holen.

Ich scheitere jedoch bereits daran, dass ich es nicht mal schaffe, ein einfaches Label über eine ViewModel darzustellen.

Mein C# Code:


using System;
using System.Windows.Input;
using Xamarin.Essentials;
using Xamarin.Forms;

namespace MyApp.ViewModels
{
    public class AboutViewModel : BaseViewModel
    {
        public AboutViewModel()
        {
            //Title = "About";
            OpenWebCommand = new Command(async () => await Browser.OpenAsync("https://aka.ms/xamarin-quickstart"));
        }

        public ICommand OpenWebCommand { get; }

        public void Display()
        {
            StackLayout al = new StackLayout
            {
                Children =
                {
                    new Button
                    {
                        Text = "Test",
                        TextColor = Color.Red,
                        

                    }
                }
            };


            
        }
    }
}

Ich weiss bereits das die Methode Display() an die Property MainPage in der class App übergebenwerden muss (da wo standart nur AppShell() übergeben wird (MainPage = new AppShell()

Wenn ich das aber (unter einbindung der class AboutViewModel) mache bekomme ich keinen Inhalt angezeigt. Eigentlich sollte ein Label mit "Test" in Roter Schriftfarbe angezeigt werden.

Auf binded-viewmodel-content-to-stacklayout habe ich zwar die einbindung über XAML gefunden:.....

<ContentPage x:Name="ParentView">

     <ScrollView x:Name = "CategoriesScrollView">
          <controls:CustomStackLayout Orientation="Horizontal" Spacing="20" Items = "{Binding BindingContext.CategoryName, Source={x:Reference ParentView}}" />
     </ScrollView>

... verstehe aber nicht WO der punkt ist im zb. Display() einzufügen

wär super wenn mir da jemand helfen könnte

lg

Thema: Einträge in der Menüleiste werden nicht Freigeschaltet
Am im Forum: GUI: WPF und XAML

Hallo liebe Community,

ich entwickle gerade eine Firmenlösung auf WPF Basis. In meinem Hauptfenster gibt es eine Menüleiste welche ich so eingestellt hab, dass Mitarbeiter sich erst einloggen müssen ehe sie von den Menüreitern gebrauch machen können.


<Window x:Class="Delphin.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:Delphin"
        mc:Ignorable="d"
        Title="MainWindow" Height="768" Width="1024" WindowStartupLocation="CenterScreen" WindowState="Maximized" ResizeMode="NoResize">
    <Grid>
        <DockPanel LastChildFill="False">
            <Menu DockPanel.Dock="Top" x:Name="Menu">
                <Menu.Background>
                    <LinearGradientBrush EndPoint="0.5,1" StartPoint="0.5,0">
                        <GradientStop Color="White" Offset="0"/>
                        <GradientStop Color="#FF54DFE6" Offset="1"/>
                    </LinearGradientBrush>
                </Menu.Background>
                <MenuItem Header="Datei" >
                    <MenuItem Header="Anmelden" x:Name="Menu_File_Logon" Click="Menu_File_Logon_Click" />
                    <MenuItem Header="Abmelden" x:Name="Menu_File_Logoff" Click="Menu_File_Logoff_Click" />
                    <MenuItem Header="Beenden" x:Name="Menu_File_Exit" Click="Menu_File_Exit_Click" />
                </MenuItem>
                <MenuItem Header="Mitarbeiter" x:Name="Menu_Employee">

                </MenuItem>
                <MenuItem Header="Kunde" x:Name="Menu_Customer">

                </MenuItem>
                <MenuItem Header="Produkte" x:Name="Menu_Products">

                </MenuItem>
                <MenuItem Header="Webseite" x:Name="Menu_Website">

                </MenuItem>
                <MenuItem Header="Firma" x:Name="Menu_Company">

                </MenuItem>
                <MenuItem Header="Einstellungen" x:Name="Menu_Settings">

                </MenuItem>
                <MenuItem Header="Hilfe" x:Name="Menu_Help">

                </MenuItem>
            </Menu>
        </DockPanel>
        <Canvas>
            <Frame x:Name="MainContent" Height="718" Width="1018" Canvas.Top="21"/>
        </Canvas>
    </Grid>
</Window>



using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using Delphin.View.File;
using Delphin.ViewModels;
using Delphin.Res.Includes;

namespace Delphin
{
    /// <summary>
    /// Interaktionslogik für MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        private SystemConfig _sc; // läd im wesentlichen die Property public bool IsUserLoggedOn {get; set;} dessen wert Standart false ist

        public MainWindow()
        {
            InitializeComponent();
            StdLoad();
            _sc = new SystemConfig();
        }

        private void StdLoad()
        {
            Menu_Employee.IsEnabled = false;
            Menu_Customer.IsEnabled = false;
            Menu_Products.IsEnabled = false;
            Menu_Website.IsEnabled = false;
            Menu_Company.IsEnabled = false;
            Menu_Settings.IsEnabled = false;
            Menu_Help.IsEnabled = false;
            Menu_File_Logoff.IsEnabled = false;
        }

        public void Update()
        {
            Menu_File_Exit.IsEnabled = false;
            Menu_File_Logon.IsEnabled = false;
            Menu_Employee.IsEnabled = _sc.IsUserLoggedOn;
            Menu_Customer.IsEnabled = _sc.IsUserLoggedOn;
            Menu_Products.IsEnabled = _sc.IsUserLoggedOn;
            Menu_Website.IsEnabled = _sc.IsUserLoggedOn;
            Menu_Company.IsEnabled = _sc.IsUserLoggedOn;
            Menu_Settings.IsEnabled = _sc.IsUserLoggedOn;
            Menu_Help.IsEnabled = _sc.IsUserLoggedOn;
            Menu_File_Logoff.IsEnabled = _sc.IsUserLoggedOn;
            Menu.UpdateLayout();
        }
        private void Menu_File_Logon_Click(object sender, RoutedEventArgs e)
        {
            MainContent.Content = new LogonPage();
        }

        private void Menu_File_Logoff_Click(object sender, RoutedEventArgs e)
        {

        }

        private void Menu_File_Exit_Click(object sender, RoutedEventArgs e)
        {

        }
    }
}

Nun zu meinem Problem. Wenn man Datei->Anmelden anklickt wird das Anmeldeformular geladen. Siehe:


<Page x:Class="Delphin.View.File.LogonPage"
      xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
      xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
      xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
      xmlns:local="clr-namespace:Delphin.View.File"
      mc:Ignorable="d" 
      d:DesignHeight="768" d:DesignWidth="1024"
     
      Title="LogonPage"
      >

    <Grid>
        <Canvas>
            <TextBox Height="23" Canvas.Left="393" TextWrapping="Wrap" Canvas.Top="201" Width="120"/>
            <PasswordBox Canvas.Left="393" Canvas.Top="238" Width="120" Height="23"/>
            <Label Content="Benutzerkennung" Canvas.Left="250" Canvas.Top="197"/>
            <Label Content="Passwort" Canvas.Left="295" Canvas.Top="235"/>
            <Button Content="Anmelden" Click="Logon_Btn_Logon" Canvas.Left="393" Canvas.Top="285" Width="120"/>
            
        </Canvas>

    </Grid>
</Page>


Logon_Btn_Logon löst DoLogon() aus und soll nun die gesperrten Menüelemente freigeben:


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Delphin.Res.Includes;

namespace Delphin.ViewModels.File
{
    public class LogonPageModel
    {
        private SystemConfig _sc;
        private MainWindowModel _mwm;
        public LogonPageModel()
        {
            _sc = new SystemConfig();
            _mwm = new MainWindowModel();
        }

        public void DoLogon()
        {
            _sc.IsUserLoggedOn = true;
            SetLogon();
        }

        public void SetLogon()
        {
/**
public void Update()
        {
            Menu_File_Exit.IsEnabled = false;
            Menu_File_Logon.IsEnabled = false;
            Menu_Employee.IsEnabled = _sc.IsUserLoggedOn;
            Menu_Customer.IsEnabled = _sc.IsUserLoggedOn;
            Menu_Products.IsEnabled = _sc.IsUserLoggedOn;
            Menu_Website.IsEnabled = _sc.IsUserLoggedOn;
            Menu_Company.IsEnabled = _sc.IsUserLoggedOn;
            Menu_Settings.IsEnabled = _sc.IsUserLoggedOn;
            Menu_Help.IsEnabled = _sc.IsUserLoggedOn;
            Menu_File_Logoff.IsEnabled = _sc.IsUserLoggedOn;
            Menu.UpdateLayout();
        }
*/
            _mwm.Update();
            
        }
    }
}

Doch die schaltung auf Enable funktioniert nicht. Leider wird auch keine Fehlermeldung ausgegeben. Woran liegt das?

Also kurz zusammengefast: Die Menüelemente sind standart IsEnable=false. Nach dem Click auf "Anmelden" sollen die Elemete auf IsEnable=true schalten.

Danke im vorraus

Thema: Eingehnde Daten werden nicht in Variable übernommen
Am im Forum: Netzwerktechnologien

Hallo liebe Mitentwickler.

Ich habe meine Serverklasse soweit fertig (funktioniert im wesentlichen auch). Allerdings mit einer kleinen aber problematischen Einschränkung.

Nachdem der Socket die Verbindung angenommenhat, sollen die werte von _socket1.Available in int chach1 geschrieben werden (int cache1 = _socket1.Available

Im Debugmodus von VS 2019 funktioniert dies solange man mit haltepunkten schrit für schritt über diese zeile geht. Nimmt man die Haltepunkte weg oder lässt das Programm so durchlaufen werden die werte aus _socket1.Available nicht übernommen (obwohl sie da sind). Weiss einer woran das liegt bzw wie man das beheben kann?

Ich habe bereits versucht mit Thread.Sleep(1000); mehrere "Wartepunkte" zu erstellen weil ich vermute dass das programm zu schnell abgearbeitet wird aber daran liegt es nicht.

Nachfolgend der ganzze code und danke im Vorraus.


public ServerEngine()
        {
            IPHostEntry ipHostInfo = Dns.Resolve("MUSTER-PC");
            IPAddress ipAddress = ipHostInfo.AddressList[2];
            Controller._serverIPEndPoint = new IPEndPoint(ipAddress, 9090);
            Controller._listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

        }

        public void ServerRun()
        {

            try
            {
                Controller._listener.Bind(Controller._serverIPEndPoint);
                Controller._listener.Listen(10000);

                Protocoll.Write($"######### Protokoll { DateTime.Now.ToString("G")}#########");
                Protocoll.Write($"");
                Protocoll.Write($"PRTW-Server gestartet!");
                Protocoll.Write($"");
                Protocoll.Write($"##########################################################");

                Thread run = new Thread(() =>
                {
                byte[] _receivePufferSize;

                    while (true)
                    {


                        Socket _socket1 = Controller._listener.Accept(); // wartet auf eingehende Verbindungy
                        int cache1 = _socket1.Available; // Legt Empfangswert in zwischenspeicher
                        if (cache1 == _socket1.Available) // Prüfung ab Daten korrekt empfangen wurden.
                        {
                            _receivePufferSize = new byte[cache1];// festlegen des Empfangsspeichers
                            _receivePuffer = _socket1.Receive(_receivePufferSize); // empfangen der Daten
                            _content = Encoding.ASCII.GetString(_receivePufferSize, 0, _receivePuffer); // Übersetzen in String

                            #region Zerlegen der eingehenden Information (sofern das Format stimmt)
                            //Format ClientName:ServiceName:Identifier:Command
                            string[] values;
                            string clientName;
                            string serviceName;
                            string identifier;
                            string command;
                            string param = _content;
                            string connectParam;
                            values = param.Split(':');

                            if (values.Length == 4) // Prüft ob das Format korrekt ist
                            {
                                // Weisst die Arraywwerte den Variablen zu
                                clientName = values[0];
                                serviceName = values[1];
                                identifier = values[3];
                                command = values[2];

                                #endregion
                                #region Eingehende Anfrage wird gefiltert und sortiert
                                if (identifier == "195c40c4-842d-4e72-ad29-fd6b16c9e4aa" && clientName != "PRTG_Client")
                                {
                                    Protocoll.Write($"######### Protokoll { DateTime.Now.ToString("G")}#########");
                                    Protocoll.Write($"");
                                    Protocoll.Write($"Der Dienst -> {serviceName} <- möchte sich anmelden!");
                                    Protocoll.Write($"");
                                    Protocoll.Write($"##########################################################");


                                    if (ClientLister._TWPro_ClientRequestList.ContainsKey(serviceName)) // Prüft ob TWPro_Dienst bereits angemeldet ist.
                                    {
                                        Protocoll.Write($"######### Protokoll { DateTime.Now.ToString("G")}#########");
                                        Protocoll.Write($"");
                                        Protocoll.Write($"Der Dienst -> {serviceName} <- hat sich bereits angemeldet!");
                                        Protocoll.Write($"");
                                        Protocoll.Write($"##########################################################");
                                    }
                                    else // Wenn nicht, melde Dienst an
                                    {

                                        Protocoll.Write($"######### Protokoll { DateTime.Now.ToString("G")}#########");
                                        Protocoll.Write($"");
                                        Protocoll.Write($"Der Dienst -> {serviceName} <- wurde angemeldet!");
                                        Protocoll.Write($"");
                                        Protocoll.Write($"##########################################################");
                                        ClientLister._TWPro_ClientRequestList.Add(serviceName, _socket1);
                                    }

                                }


                                if (identifier == "195c40c4-842d-4e72-ad29-fd6b16c9e4aa" && clientName == "PRTG_Client")
                                {
                                    Protocoll.Write($"######### Protokoll { DateTime.Now.ToString("G")}#########");
                                    Protocoll.Write($"");
                                    Protocoll.Write($"PRTG ruft {serviceName}!");
                                    Protocoll.Write($"");
                                    Protocoll.Write($"##########################################################");


                                    if (ClientLister._TWPro_ClientRequestList.ContainsKey(serviceName))
                                    {
                                        Protocoll.Write($"######### Protokoll { DateTime.Now.ToString("G")}#########");
                                        Protocoll.Write($"");
                                        Protocoll.Write($"Der Dienst -> {serviceName} <- wurde gefunden...");
                                        Protocoll.Write($"{command} wurde übertragen!");
                                        Protocoll.Write($"");
                                        Protocoll.Write($"##########################################################");


                                        Socket ip = (Socket)ClientLister._TWPro_ClientRequestList[serviceName];



                                        try
                                        {
                                            if (ip.Connected) // Prüfe ob verbindung zum TWPro-Dienst besteht
                                            {
                                                // Sende Anfage an TWPro Dienst
                                                byte[] sendPuffer = Encoding.ASCII.GetBytes(command);
                                                ip.Send(sendPuffer);

                                                Protocoll.Write($"######### Protokoll { DateTime.Now.ToString("G")}#########");
                                                Protocoll.Write($"");
                                                Protocoll.Write($"{command} wurde an {ip.RemoteEndPoint} gesendet!");
                                                Protocoll.Write($"Warten auf antwort.......");
                                                Protocoll.Write($"");
                                                Protocoll.Write($"##########################################################");

                                                // Empfange Antwort vom TWPro Dienst
                                                int cache = ip.Available;
                                                _receivePufferSize = new byte[cache];
                                                _receivePuffer = ip.Receive(_receivePufferSize);
                                                string receiveMsg = Encoding.ASCII.GetString(_receivePufferSize, 0, _receivePuffer);

                                                Protocoll.Write($"######### Protokoll { DateTime.Now.ToString("G")}#########");
                                                Protocoll.Write($"");
                                                Protocoll.Write($"{receiveMsg} wurde von {ip.RemoteEndPoint} empfangen!");
                                                Protocoll.Write($"Sende antwort an PRTG");
                                                Protocoll.Write($"");
                                                Protocoll.Write($"##########################################################");
                                                // Sende Antwort an PRTG_Client
                                                _socket1.Send(_receivePufferSize);
                                                // byte[] sendPuffer2 = Encoding.ASCII.GetBytes(_receivePuffer);
                                            }
                                            else // wenn nicht sende Fehler und entferne Dienst aus der Liste
                                            {
                                                byte[] sender = Encoding.ASCII.GetBytes("false:2:TWPro-Dienst antwortet nicht!");
                                                _socket1.Send(sender);
                                                ClientLister._TWPro_ClientRequestList.Remove(serviceName);
                                            }
                                        }
                                        catch (Exception e)
                                        {
                                            Protocoll.Write($"######### Protokoll { DateTime.Now.ToString("G")}#########");
                                            Protocoll.Write($"");
                                            Protocoll.Write($"Fehler bei der kommunikation!");
                                            Protocoll.Write($"");
                                            Protocoll.Write($"##########################################################");
                                        }
                                    }
                                    else
                                    {
                                        Protocoll.Write($"######### Protokoll { DateTime.Now.ToString("G")}#########");
                                        Protocoll.Write($"");
                                        Protocoll.Write($"Der Dienst -> {serviceName} <- wurde nicht gefunden!");
                                        Protocoll.Write($"Sende Fehler an PRTG");
                                        Protocoll.Write($"");
                                        Protocoll.Write($"##########################################################");
                                        string cont = "false:" + PRTG_Code.ReturnInfo((short)PRTG_Code.PRTG_Code_Enum.WARNING) + "," + SystemMessages.ServerMessages((short)SystemMessages.ServerCode.ClientNotConnect) + "";
                                        byte[] sendPuffer = Encoding.ASCII.GetBytes(cont);
                                        _socket1.SendTo(sendPuffer, _socket1.RemoteEndPoint);
                                    }
                                }
                                #endregion
                            }
                            else
                            {
                                byte[] errSend = Encoding.ASCII.GetBytes("false:4:Ungültiges Format!");
                                _socket1.Send(errSend);
                            }
                        }
                        else
                        {
                            byte[] errSend = Encoding.ASCII.GetBytes("false:4:Fehler beim Datenempfang!");
                            _socket1.Send(errSend);
                        }
                    }
                });
                run.Start();
            }
            catch (Exception e)
            {
                Protocoll.Write($"{e.Message}");
            }
        }

Thema: Wie mache ich einen Server Multitaskingfähig?
Am im Forum: Netzwerktechnologien

hat sich erledigt. Danke für die Hilfe

Thema: TCP Socketverbindung aufrecht halten.
Am im Forum: Netzwerktechnologien

Hi,

gibt es eine möglichkeit eine TCP Verbindung aufrecht zu erhalten?

Zb. ein Client meldet sich beim Server an und "Wartet" bis er von einem anderen Client eine Anfrage bekommt. ähnlich wie in einem Chat.


Lg

Thema: Wie mache ich einen Server Multitaskingfähig?
Am im Forum: Netzwerktechnologien

In der Tat habe ich mir auch schon die Async Variante angesehen. Allerdings auf der MS Doc seite Asynchrone Programmierung in C#
.

Soweit ich das verstanden habe sorgt async dafür, dass vorgänge Paralel abgearbeitet werden und bei sync wird jede Anfrage nacheinander abgearbeitet.

Thema: Eigenen Auth-Handshake über TCP entwickeln
Am im Forum: Netzwerktechnologien

Ich habs bereits gemerkt XD. Das ist ein echtes Brett

Thema: Wie mache ich einen Server Multitaskingfähig?
Am im Forum: Netzwerktechnologien

Hallo liebe Mitentwickler,

ich dabei einen Server zu entwickeln, welcher anfragen von Clients aufnimmt und weiterleitet sowie die antwort an den anfragenden Client zurückgibt. So als eine Art "Router".

Der Server selber im Grundgerüst (als Dienst funktioniert)


Anbei etwas Code: Das Auskommentierte kann ignoriert werden.


Code der Dienststeuerung (Start und Stopp)


namespace Server
{
    public partial class ServerService : ServiceBase
    {
        #region ServerControlls
        public ServerService()
        {
            InitializeComponent();
        }

        protected override void OnStart(string[] args)
        {
            StartUP();
        }

        protected override void OnStop()
        {
            
        }
        #endregion

        #region Backend
        internal void StartUP()
        {
            ServerEngine serverEngine = new ServerEngine(9090);

            // WorkerTasks.IncomingRequest(serverEngine);
            //Thread iRT = new Thread(WorkerThreads.IncomingRequestThread);
            //iRT.Start(serverEngine);

            //Thread cWT = new Thread(WorkerThreads.ClientWorkingThread);
            //cWT.Start();

            //Thread rT = new Thread(WorkerThreads.RoutingThread);
            //rT.Start();

        }
        #endregion
    }
}


Code der Server Engine (Das eigentliche Serverprogramm)


namespace Server
{
    /// <summary>
    /// Beinhaltet alle Methoden für die Serververbindung
    /// </summary>
   public class ServerEngine
    {
        #region Parameter
        private int _port;
        public TcpListener _tcpServerListener;
        public static TcpClient _tcpServerClient;
        public IPEndPoint _serverIPEndPoint;
        public Socket _serverSocket;
        public IPAddress _serverIPAdress;
        public IPHostEntry _serverIPHost;
        public static NetworkStream _networkStream;
        public static ClientLister _cl;
        public static string _data;
        #endregion

        #region Konstruktor
        public ServerEngine(int port)
        {
            int maxUserPerServer = 1000;
            _port = port;
            _serverIPHost = Dns.GetHostEntry(Dns.GetHostName());
            _serverIPAdress = _serverIPHost.AddressList[3];
            _serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            _serverIPEndPoint = new IPEndPoint(_serverIPAdress, _port);
            _tcpServerListener = new TcpListener(_serverIPEndPoint);
            
            _tcpServerListener.Start();

            //_tcpServerListener.Server.Bind(_serverIPEndPoint);
            //_tcpServerListener.Server.Listen(maxUserPerServer);
            
            
            _cl = new ClientLister();
        }
        #endregion

        #region public Methods
        /// <summary>
        /// Empfängt alle Anfragen an den Server und Speichert diese in einer Liste.
        /// </summary>
        public static void Receiver(object server)
        {
            _tcpServerClient = new TcpClient();
            if (((ServerEngine)server)._tcpServerListener.Pending()) // Prüft ob eingehende Anfragen vorliegen
            {
                _tcpServerClient = ((ServerEngine)server)._tcpServerListener.AcceptTcpClient(); // Nimmt die eingehende Anfrage an!

                // Interne Methodenvariablen //

                string[] saveIncomeData;
                string substrg;
                byte[] _receiverPuffer = new byte[_tcpServerClient.Available];
                //////////////////////////////////

                if (_receiverPuffer.Length < 1) // prüft ob Daten empfangen wurden; wenn nicht löse fehler aus!
                {
                    Protocoll.Write($"Es wurden keinen Daten von { _tcpServerClient.Client.RemoteEndPoint } übergeben! ");
                }
                else
                {
                    _networkStream = _tcpServerClient.GetStream();// Ruft den Netzwerkstream ab

                    ////// Empfängt Daten vom Client
                    _networkStream.Read(_receiverPuffer, 0, _tcpServerClient.Available);
                    _data = Encoding.ASCII.GetString(_receiverPuffer);

                    _cl.AddIncomingRequest(_tcpServerClient.Client.RemoteEndPoint, _data); // Speichert eingehende Verbindung
                    Protocoll.Write($"{_tcpServerClient.Client.RemoteEndPoint},,, {_data}");
                    Protocoll.Write($"{_cl.CountIncomingRequest()}");
                }
            }
        }
        /// <summary>
        /// Prüft ob sich Clients am Server angemeldet haben
        /// </summary>
        /// <returns></returns>
        public static bool IsContainedValues()
        {
            if(_cl.CountIncomingRequest()>0)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        
        public static bool Handshake()
        {
            try
            {
                if(_data != null)
                {
                    string[] splitData = _data.Split(':');
                    string[] splitData2 = splitData[0].Split('-');
                    
                }
                return true;
            }
            catch(Exception Err)
            {
                return false;
            }
        }
        #endregion



    }
}


Der Kostruktor beinhaltet den eigentlichen Server. Die Methode "Receiver()" ist für den Datenempfang zuständig.

Nun mein Problem:

Der Server soll nun ständig auf anfragen warten und sobald eine eingeht soll diese in einem seperaten Thread ausgelagert werden und dort weiterverarbeitet werden, sodass der server sofort für die nächste Anfrage bereit ist.

Ich habe versucht den Thread in der SartUP Medhode des ServerService zu implementieren:


Thread iRT = new Thread(WorkerThreads.IncomingRequestThread);
iRT.Start(serverEngine);

zur Kontrolle habe ich eine Protokollmethode geschrieben die mir die Zwischenergebnisse zeigt. Leider ohne erfolg. Auch habe ich versucht den eigentlichen Speichervorgang (für die Clients) in einem Task auszulagern. Siehe wie Folgt:


  public static class WorkerThreads
    {
        public static void IncomingRequestThread(object serverEngine)
        { 
                WorkerTasks.IncomingRequest(serverEngine);  
        }
    }


   public static class WorkerTasks
    {
        #region Parameter
       
        #endregion
        public static void IncomingRequest(object serverEngine)
        {
            Task _workTask = Task.Run(() =>
            {
                Protocoll.Write($"Incoming tread 1"); // Kontrollpunkt für mich selbst
                ServerEngine.Receiver(serverEngine);
            });                                                                                                                                                             
        }
      }

Leider war auch das nicht von erfolg gekrönt.

Ich weiss das es viel Code ist und ich habe versucht es übersichtlich und verständlich wie möglich zu formulieren.

Thema: Eigenen Auth-Handshake über TCP entwickeln
Am im Forum: Netzwerktechnologien

Vllt ist der Begriff "Handshake" inkorrekt.

Der Prozess soll im Wesentlichen folgendes machen.

1. Starte Server -> Server wartet auf anfrage
2. Client sendet Anfrage an den Server (inhalt: Clientname und einen Identifier)
3. Server nimmt Anfrage entgegen und prüft ob sich der Client anmelden darf. Ist das der Fall geht der Client sammt Tcp-Verbindung in den Cache (in meinem Fall ein Dictionary)
4. Client sendet nun anfrage an anderen Client und der Server leitet die anfrage weiter.
5. Angefragter Client verarbeitet die Anfrage und sendet antwort über den Server an den Anfragenden Client.


soll soll der grobe Ablauf sein.

Thema: Formularwechsel mit .DLL funktioniert nicht
Am im Forum: GUI: Windows-Forms

syntaktisch genauso.

Ich lösche den Panelinhalt mit Clear(); und füge den neuen Inhalt mit Add(form) ein.

Thema: Formularwechsel mit .DLL funktioniert nicht
Am im Forum: GUI: Windows-Forms

Hallo liebe Mitentwickler,

ich stehe vor einem verständnisproblem.

Ich Habe eine Hauptanwendung (Muster.exe) und eine DLL (MuserForm.DLL).

Meine Muster.exe gibt ein WindowsForm "MainWindow.cs" aus welches ein Panel enthällt. Dieses Panel soll alle Formulare ausgeben welche der Nutzer haben möchte (Zb. Kalender oder Notizen)

Wenn ich die entsprechenden UserControlls mit:


MainWindow.Panel1.Controls.Clear();
MainWindow.Panel1.Controls.Add(form);

aufrufe funktioniert der Formularwechsel reibungslos. Soweit sogut.

Ich habe die DLL über Verweise (Nutze VS 2019 Enterprise) eingefügt und über


using
bekannt gemacht und möchte jetzt die UserControls der DLL in meinem Panel der MainForm.exe aufrufen (zb. via Button). Dies funktioniert jedoch nicht.
der Button selber scheint jedoch io da er ohne weiteres eine MessageBox ausgibt. Ich sollte vllt noc dazu erwähnen: Das UC Form mit dem Button befindet sich bereits in der DLL.

Nun Frage ich mich warum funktioniert der Formwechsel in der exe, aber nicht in der DLL?


Danke im vorraus

Thema: Eigenen Auth-Handshake über TCP entwickeln
Am im Forum: Netzwerktechnologien

Ich arbeite als Softwareentwickler C# und habe den Auftrag erhalten einen Handshake zu entwickeln. Leider darf ich auf die Details nicht eingehen aber soviel kann ich sagen.
Es wird keine Websache entwickelt. Allgeimein gesprochen soll ein Serverdienst laufen (läuft auch) welcher auf Clients zum anmelden wartet. Der Verbindungsaufbau an sich funktioniert und auch der Datenaustausch.

Nun soll sich der Client erst anmelden und und der Server (Dienst) die Anmeldung bestätigen.

Thema: Eigenen Auth-Handshake über TCP entwickeln
Am im Forum: Netzwerktechnologien

Hallo,

ich bin dabei ein Server-Client system zu entwickeln. Die eigentliche Verbindung und Datenkommunikation funktioniert auch. Nun möchte ich, dass sich die Clients per Handshake authentifizieren.

Über google konnte ich nur eine C# methode für einen Seriellen Port finden. Diese hilft mir jedoch nicht.

Wie kann ich einen Handshake für ein TCP Netzwerk entwickeln?

Vielen Dank im vorraus.

Thema: WPF zwischen Seiten wechseln
Am im Forum: GUI: WPF und XAML

Hallo,

ich habe ein WPF Haupseite erstellt mit Menü usw. Funktioniert auch alles soweit tadellos. Nun habe ich aber folgende herrausforderung.

Wenn ich Zb über das Menü eine Seite (Page.xaml) aufrufe, öffnet sich diese. Wenn ich danach jedoch über das Menü eine andere Seite (Page2.xaml) aufrufen möchte passiert überhaupt nichts.

Zum besseren verständnis hier der code der Menübuttons:


       private void Menu_CRM_Kundensuche(object sender, RoutedEventArgs e)
        {
            Kundensuche ks = new Kundensuche();
            
            this.Content = ks;
        }

        private void Menu_CRM_Kundenakte(object sender, RoutedEventArgs e)
        {
            FormKundenakte ka = new FormKundenakte();
            
            this.Content = ka;
        }


Die einzelnen Button funktionieren für sich. Allerdings muss das Programm jedes mal neu gestartet werden. Meine Frage ist daher. Wie erreiche ich den Pagewechsel?

Danke im Vorraus

Thema: Werte in Datei schreiben
Am im Forum: Grundlagen von C#

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

Thema: Wie kann ich 7 Zeilen mit je 11 Zeichen in eine Textdatei speichern?
Am im Forum: Grundlagen von C#

Hallo an alle,

Gegeben sei das folgende Byte-Array:


byte[] array = {32, 32, 67, 67, 32, 32, 32, 35, 32, 35, 32,
                       32, 67, 32, 32, 67, 32, 32, 35, 32, 35, 32,
		       67, 32, 32, 32, 32, 32, 35, 35, 35, 35, 35,
		       67, 32, 32, 32, 32, 32, 32, 35, 32, 35, 32,
		       67, 32, 32, 32, 32, 32, 35, 35, 35, 35, 35,
		       32, 67, 32, 32, 67, 32, 32, 35, 32, 35, 32,
		       32, 32, 67, 67, 32, 32, 32, 35, 32, 35, 32 };

Nun soll ich dieses array in eine Textdatei speicher (klappt einwandfrei) und mit einer anderen Methode in einer Console ausgeben. Der Clou ist nun das ich nur 7 Zeilen mit je max 11 zeichen an platz verwenden soll.

Meine derzeitige lösung:


public void ESAOut(string pfad)
        {
            FileStream reader =  File.Open(pfad, FileMode.Open);

            byte[] array = new byte[reader.Length];
            reader.Read(array, 0, (int)array.Length);



                for (int i = 0; i < array.Length; i++)
                {
                    Console.Write("{0} {0} {0} {0} {0} {0} {0} {0} {0} {0} {0} \n", (byte)array[i]);
                    
                }
            
            reader.Close();
            Console.ReadLine();
        }
ist nicht so die lösung.

wer kann mir helfen. ich hänge da seit 3 Wochen dran.

Thema: Wie kann ich eine Datei erstellen?
Am im Forum: Grundlagen von C#

Hallo alle zusammen,

ich Studiere gerade bei der ILS Fachinformatik und habe eine "eigentlich" einfache Aufgabe welche ich nicht lösen kann. Ich soll eine Datei erstellen.

  class Program
    {
        public void Datei(string path, byte[] array)
        { 

            using (FileStream stream = new FileStream(path, FileMode.Create))
            {
                stream.Write(array, 0, array.Length);
                stream.Close();
            }
        }
        
        static void Main(string[] args)
        {
           

            Program test = new Program();
            string path = @"C:\testordner\datei.txt";
            byte[] array = { 68, 97, 116, 101, 105 };
            test.Datei(path, array);

        }

Die Datei "datei.txt" wird jedoch nicht erstellt. Ich habe meinen Fernlehrer hierzu gefragt und der meinte das der Code korrekt ist. Ändert aber nichts an der sachlage.

Das Programm ist eine Consolenanwendung (mit Visual Studio geschrieben) und wird mit:
Das Programm "[6980] ESA.exe: Programmablaufverfolgung" wurde mit Code 0 (0x0) beendet.
Das Programm "[6980] ESA.exe" wurde mit Code 0 (0x0) beendet.

Auch eine Ausnahme bleibt aus. Selbst wenn ich


try
{
 using (stream = new FileStream(path, FileMode.Create))
            {
                stream.Write(array, 0, array.Length);
                stream.Close();
            }
}
catch(Exception e)
            {
                Console.WriteLine("Error");
            }

schreibe wird keine Ausnahme ausgelöst. Bei Microsoft habe ich den Hinweis mit dem FileAccess gefunden und den Code wie folgt umgestellt



using (FileStream stream = new FileStream(path, FileMode.Create, FileAcces access))


Aber auch das blieb erfolglos. Was mache ich hier falsch?