Esempio n. 1
0
        /// <summary>
        /// Eventhandler für Nachrichtenempfang im BackgroundWorker
        /// </summary>
        /// <param name="sender">BackgroundWorker</param>
        /// <param name="e">Enthält den UserState in Form eine ServerBackgroundWorkerProgress-Objekts,
        /// welches wiederum die empfangene Nachricht enthält</param>
        protected virtual void serverBackgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            // Wenn Eventhandler registriert wurden
            if (MessageReceived != null)
            {
                // UserState in ServerBackgroundWorkerProgress casten
                ServerBackgroundWorkerProgress progress = e.UserState as ServerBackgroundWorkerProgress;

                // Event auslösen
                MessageReceived(this, new MessageReceivedEventArgs
                {
                    Message = new ChatMessage(progress.Data, key)
                });
            }
        }
Esempio n. 2
0
        /// <summary>
        /// Eventhandler für Nachrichtenempfang im BackgroundWorker
        /// </summary>
        /// <param name="sender">BackgroundWorker</param>
        /// <param name="e">Enthält den UserState in Form eine ServerBackgroundWorkerProgress-Objekts,
        /// welches wiederum die empfangene Nachricht enthält</param>
        protected override void serverBackgroundWorker_ProgressChanged(object sender, System.ComponentModel.ProgressChangedEventArgs e)
        {
            // UserState in ServerBackgroundWorkerProgress casten
            ServerBackgroundWorkerProgress progress = e.UserState as ServerBackgroundWorkerProgress;

            // Nachricht an jeden registrierten Host weiterleiten
            foreach (ChatConnection connection in clientList)
            {
                try
                {
                    // Nachricht senden, wird nicht entschlüsselt
                    ChatClient cc = new ChatClient(connection);
                    cc.Send(new ChatMessage(progress.Data, ""));
                }
                catch (Exception)
                {
                    // Falls nicht erreichbar, Host aus
                    // der Liste löschen
                    RemoveClient(progress.Endpoint);
                }
            }
        }
Esempio n. 3
0
        /// <summary>
        /// Eventhandler für den Betrieb des BackgroundWorker
        /// </summary>
        /// <param name="sender">BackgroundWorker</param>
        /// <param name="e">ServerBackgroundWorkerArgs, welche insb. die zu verwendende Portnummer enthalten</param>
        protected override void serverBackgroundWorker_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e)
        {
            // Argument in ServerBackgroundWorkerArgs casten
            ServerBackgroundWorkerArgs args = e.Argument as ServerBackgroundWorkerArgs;

            // TcpListener zurücksetzen
            TcpListener tcpListener = null;

            try
            {
                // TcpListener erzeugen und starten
                tcpListener = new TcpListener(IPAddress.Loopback, args.PortNumber);
                tcpListener.Start();

                // Byte-Array als Buffer erzeugen
                Byte[] buffer       = new Byte[2048];
                string stringBuffer = null;

                // Loop zum Warten auf Datenempfang
                while (true)
                {
                    // Warten auf Verbindung
                    TcpClient tcpClient = tcpListener.AcceptTcpClient();

                    // Buffer zurücksetzen
                    stringBuffer = null;
                    int numReceivedBytes = 0;

                    // Bereitgestellten Stream lesen
                    NetworkStream stream = tcpClient.GetStream();

                    while ((numReceivedBytes = stream.Read(buffer, 0, buffer.Length)) != 0)
                    {
                        // Empfangene Bytes in String konvertieren
                        stringBuffer = Encoding.UTF8.GetString(buffer, 0, numReceivedBytes);
                    }

                    // Verbindung speichern
                    AddClient(tcpClient.Client.RemoteEndPoint, stringBuffer);

                    // Nach Abschluss des Emfpangs empfange Nachricht über Progress verarbeiten
                    ServerBackgroundWorkerProgress progress = new ServerBackgroundWorkerProgress(stringBuffer)
                    {
                        Endpoint = tcpClient.Client.RemoteEndPoint
                    };

                    serverBackgroundWorker.ReportProgress(0, progress);

                    // TcpClient schließen
                    tcpClient.Close();
                }
            }
            catch (Exception)
            {
                throw;
            }
            finally
            {
                // TcpListener anhalten
                tcpListener.Stop();
            }
        }