TCP/Server 我可以从另一个类调用Form1的组件

Question

I have this example as a server. The question that only works well for me on console. I want to pass it to windows Form. And I don't know how to apply it.

Because I understand that it is bad practice from another class such as creating a Form1 Method and using a Form1 object in the Server class.

As if in the server class I call the textbox or things like that.

The question that I think I would have to adapt all the code back for windows Form?

Or stop using the classes and use the typical TcpClient, TpcListener as in the videos that declare it at the moment in Form1.

using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;

namespace Chatroom
{

    delegate void MessageEventHandler(object sender, MessageEventArgs e);

    class MessageEventArgs : EventArgs
    {
        public string Message { get; private set; }

        public MessageEventArgs(string message)
        {
            this.Message = message;
        }
    }

    class Server
    {
        private TcpListener serverSocket;
        private List<Worker> workers = new List<Worker>();

        public Server(int port)
        {
            //serverSocket = new TcpListener(port);// deprecated
            // the same way
            serverSocket = new TcpListener(IPAddress.Any, port);
            serverSocket.Start();
        }

        private void WaitForConnection()
        {
            while (true)
            {
                TcpClient socket = serverSocket.AcceptTcpClient();
                Worker worker = new Worker(socket);
                AddWorker(worker);
                worker.Start();
            }
        }

        private void Worker_MessageReceived(object sender, MessageEventArgs e)
        {
            BroadcastMessage(sender as Worker, e.Message);
        }

        private void Worker_Disconnected(object sender, EventArgs e)
        {
            RemoveWorker(sender as Worker);
        }

        private void AddWorker(Worker worker)
        {
            lock (this)
            {
                workers.Add(worker);
                worker.Disconnected += Worker_Disconnected;
                worker.MessageReceived += Worker_MessageReceived;
            }
        }

        private void RemoveWorker(Worker worker)
        {
            lock (this)
            {
                worker.Disconnected -= Worker_Disconnected;
                worker.MessageReceived -= Worker_MessageReceived;
                workers.Remove(worker);
                worker.Close();
            }
        }

        private void BroadcastMessage(Worker from, String message)
        {
            lock (this)
            {
                message = string.Format("{0}: {1}", from.Username, message);
                for (int i = 0; i < workers.Count; i++)
                {
                    Worker worker = workers[i];
                    if (!worker.Equals(from))
                    {
                        try
                        {
                            worker.Send(message);
                        }
                        catch (Exception)
                        {
                            workers.RemoveAt(i--);
                            worker.Close();
                        }
                    }
                }
            }
        }

        class Worker
        {
            public event MessageEventHandler MessageReceived;
            public event EventHandler Disconnected;
            private readonly TcpClient socket;
            private readonly Stream stream;
            public string Username { get; private set; } = null;

            public Worker(TcpClient socket)
            {
                this.socket = socket;
                this.stream = socket.GetStream();
            }

            public void Send(string message)
            {
                byte[] buffer = Encoding.UTF8.GetBytes(message);
                stream.Write(buffer, 0, buffer.Length);
            }

            public void Start()
            {
                new Thread(Run).Start();
            }

            private void Run()
            {
                byte[] buffer = new byte[2018];
                try
                {
                    while (true)
                    {
                        int receivedBytes = stream.Read(buffer, 0, buffer.Length);
                        if (receivedBytes < 1)
                            break;
                        string message = Encoding.UTF8.GetString(buffer, 0, receivedBytes);
                        if (Username == null)
                            Username = message;
                        else
                            MessageReceived?.Invoke(this, new MessageEventArgs(message));
                    }
                }
                catch (IOException) { }
                catch (ObjectDisposedException) { }
                Disconnected?.Invoke(this, EventArgs.Empty);
            }

            public void Close()
            {
                socket.Close();
            }
        }

        static void Main(string[] args)
        {
            try
            {
                Server server = new Server(3393);
                server.WaitForConnection();
            }
            catch (IOException) { }
        }
    }
}

The problem is this. If I have Form1.

As I relate it, as I do eg. Every time a new Client is created it is added by a list box from the Server class. In theory you can't or if you can or is it bad practice?

Class Server{
private void RemoveWorker(Worker worker)
        {
            lock (this)
            {
                **textbox.text +="Cliente desconectado";**
                worker.Disconnected -= Worker_Disconnected;
                worker.MessageReceived -= Worker_MessageReceived;
                workers.Remove(worker);
                worker.Close();
            }
        }
}

How could it be done without being in the main WindForm class

Answer 1

Here are steps to help you start.

1. Create a new WinForms project in VisualStudio.
2. You project should build and show the form right away without you having to do anything.
3. You should have Program.cs that contains the Main() method. You do not need to change it. This is what causes the Form1 to load and display.

[STAThread]
static void Main()
{
    Application.EnableVisualStyles();
    Application.SetCompatibleTextRenderingDefault(false);
    Application.Run(new Form1());
}

4. You can right-click on the Form1.cs and select View Code to see the code behind page.
5. There you will have the constructor that has InityializeConponent() method that creates all of your GUI "stuff".
6. Add a listener to run when the Form loads. This is where you can add your server stuff.
7. Open your GUI designer, go to Form1 -> Properties and add a new function to the Load
8. This is where you will write your code. For example, you can create and start the server.

private void Form1_Load(object sender, EventArgs e)
{
    try
    {
        Server server = new Server(3393);
        server.WaitForConnection();
    }
    catch (IOException) { // Put something here like a log }
}

9. Your server can go to a new Class that can be in a new file like Server.cs . Just make sure that WaitForConnection() is public .

This should get you started. When you run into an issue, just create a new question on SO and make sure to add your latest code.

Some suggestions:

• Use a delegate to communicate between Server and the GUI
• You may want to run the Server in another thread. Test it first to get it working and see if this is what you need/want
• You don't normally want to run a server as WinForms project. If you accidently close the form, you kill your server.
• Make sure to have a Form1_Close event and shut down your server there correctly