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: 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?