C#与ESP8266之间的WiFi通信

我现在正在做学校的项目，我正在寻找最简单的方法来连接C#和ESP8266，不是通过串行端口（COM4），而是通过ESP8266上的WiFi模块（我必须使用这种方法）。我必须构建一个简单的项目，将测量数据从ESP发送到C#，并从C#接收我自己定义的控制命令（如“LEDON”、“LEDOFF”等字符串），就像远程控制测量项目一样。我对C#以及服务器/互联网之类的基础知识知之甚少。我已经用Arduino IDE代码完成了所有的工作，但我仍然停留在C上，因为我以前从未在那里编程过。我希望你能理解我糟糕的英语和我问题的概念。：）

编辑：

嗯，所以我在我的学校项目中做了一些改变，现在我在这个阶段，我需要解决这部分代码。我希望这是完成我的项目的最后一步。我所要做的就是用以下代码中名为“Writing”的未填充方法解决将数据从C#写入ESP的问题：

using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Threading;

namespace ESP8266
{
    public class Projekt
    {
        public event MessageEventHandler Message;
        public delegate void MessageEventHandler(Projekt sender, string Data);

        public TcpListener server;
        public Thread W_Thread;
        public Thread R_Thread;
        public bool IsLiserning = true;

        public TcpClient client;
        public StreamReader clientdata;
        public StreamWriter serverdata;
        public Projekt()
        {
            server = new TcpListener(IPAddress.Parse(Dns.GetHostEntry(Dns.GetHostName().ToString()).AddressList[1].ToString()), 5000);
            server.Start();

            W_Thread = new Thread(new ThreadStart(Writing));
            W_Thread.Start();

            R_Thread = new Thread(new ThreadStart(Reading));
            R_Thread.Start();
        }

        public void Reading()
        {
            while (IsLiserning == true)
            {
                if (server.Pending() == true)
                {
                    client = server.AcceptTcpClient();
                    clientdata = new StreamReader(client.GetStream());
                }
                try
                {
                    Message?.Invoke(this, clientdata.ReadLine());
                }
                catch (Exception){}
            }
        }

        public void Writing()
        {
            while (IsLiserning == true)
            {
                if (server.Pending() == true)
                {
                    client = server.AcceptTcpClient();
                    serverdata = new StreamWriter(client.GetStream());
                }
                try
                {
                    //NEED_TO_SOLVE_THIS_PART
                }
                catch (Exception){}
            }
        }
    }
}

也许除了那部分代码，你们还缺少了一些东西，我希望你们能帮助我：）谢谢所有的答案：）

你可以看看这个，基本上你想通过TCP/IP在arduino和C#之间进行通信。考虑C作为服务器，ARDUNO作为客户端。然后他们只需要互相发送信息来进行交流

我提供的链接所做的远远超出了需要，所以如果你迷路了，也许可以从一些非常基本的东西开始，看看并检查最后关于c#server的链接。与我的第一个链接相比，它们更容易理解

[编辑]好的，只有链接的答案是危险的，不是最好的，所以这里是我通过第一个链接给出的一个非常简单的版本：

您的服务器将有一个接收者列表，每个接收者只处理一个客户端。这是我的一个项目的一个大简化，我希望通过删除很多东西，我没有破坏任何东西：

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Windows.Data;

namespace DemoServer.Models
{
    public class Server
    {
        public TcpListener Listener { get; set; }
        public int Port { get; set; }
        public bool IsStarted { get; private set; }
        public List<Receiver> Receivers = new List<Receiver>();

        public Server(int port)
        {
            Receivers.Clear();
            BindingOperations.EnableCollectionSynchronization(Receivers, Receivers);
            Port = port;
            IsStarted = false;
        }

        public void Start()
        {
            if (!IsStarted)
            {
                try
                {
                    Listener = new TcpListener(System.Net.IPAddress.Any, 0);
                    Listener.Start();
                    IsStarted = true;
                    IPAddress address = ((IPEndPoint)Listener.LocalEndpoint).Address;
                    int port = ((IPEndPoint) Listener.LocalEndpoint).Port;
                    Console.WriteLine("Server Started");
                    //Start Async pattern for accepting new connections
                    WaitForConnection();
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                    IsStarted = false;
                }
            }
        }

        public void Stop()
        {
            if (IsStarted)
            {
                Listener.Stop();
                IsStarted = false;
                Receivers.Clear();
                Console.WriteLine("Server Stopped");
            }
        }

        private void WaitForConnection()
        {
            Listener.BeginAcceptTcpClient(new AsyncCallback(ConnectionHandler), null);
        }

        private void ConnectionHandler(IAsyncResult ar)
        {
            if (IsStarted)
            {
                Receiver newClient = new Receiver(Listener.EndAcceptTcpClient(ar), this);
                newClient.Start();
                Receivers.Add(newClient);
                WaitForConnection();
            }
        }

        public void SomeInteractionBetweenClients()
        {
            Console.WriteLine("Interaction!");
        }
    }
}

使用系统；
使用System.Collections.Generic；
使用System.Collections.ObjectModel；
使用系统诊断；
使用System.Linq；
Net系统；
使用System.Net.Sockets；
使用System.Windows.Data；
名称空间DemoServer.Models
{
公共类服务器
{
公共TcpListener侦听器{get；set；}
公共int端口{get；set；}
公共布尔值已开始{get；private set；}
公共列表接收者=新列表（）；
公共服务器（int端口）
{
接收器。清除（）；
BindingOperations.EnableCollectionSynchronization（接收器，接收器）；
端口=端口；
IsStarted=false；
}
公开作废开始（）
{
如果（！IsStarted）
{
尝试
{
侦听器=新的TcpListener（System.Net.IPAddress.Any，0）；
Listener.Start（）；
IsStart=true；
IPAddress地址=（（IPEndPoint）Listener.LocalEndpoint）.address；
int port=（（IPEndPoint）Listener.LocalEndpoint）.port；
Console.WriteLine（“服务器已启动”）；
//启动异步模式以接受新连接
WaitForConnection（）；
}
捕获（例外e）
{
控制台写入线（e）；
IsStarted=false；
}
}
}
公共停车场（）
{
如果（已启动）
{
Listener.Stop（）；
IsStarted=false；
接收器。清除（）；
Console.WriteLine（“服务器已停止”）；
}
}
私有void WaitForConnection（）
{
BeginAcceptTcpClient（新的异步回调（ConnectionHandler），null）；
}
私有无效连接处理程序（IAsyncResult ar）
{
如果（已启动）
{
Receiver newClient=newreceiver（Listener.EndAcceptTcpClient（ar），this）；
newClient.Start（）；
接收者。添加（新客户机）；
WaitForConnection（）；
}
}
public void客户端之间的某些交互（）
{
Console.WriteLine（“交互！”）；
}
}
}

然后是接收器代码，您可以在其中真正处理与客户的通信：

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

namespace DemoServer.Models
{
    public class Receiver : ModelBase
    {
        bool ConnectionStatus = false;

        private uint m_Id = 0;
        public uint Id
        {
            get { return m_Id; }
            set => SetAndRaisePropertyChanged(ref m_Id, value);
        }

        private Thread receivingThread;
        private Thread sendingThread;
        public Server Server { get; set; }
        public TcpClient Client { get; set; }
        public List<String> MessageQueue { get; private set; }


        public Receiver(TcpClient client, Server server)
        {
            MessageQueue = new List<String>();
            Server = server;
            Client = client;
            Client.ReceiveBufferSize = 1024;
            Client.SendBufferSize = 1024;
            ConnectionStatus = true;
        }

        public void Start()
        {
            receivingThread = new Thread(ReceivingMethod);
            receivingThread.IsBackground = true;
            receivingThread.Start();

            sendingThread = new Thread(SendingMethod);
            sendingThread.IsBackground = true;
            sendingThread.Start();
        }

        private void Disconnect()
        {
            if (!ConnectionStatus) return;
            ConnectionStatus = false;
            Client.Client.Disconnect(false);
            Client.Close();
        }


        private void SendingMethod()
        {
            while (ConnectionStatus)
            {
                if (MessageQueue.Count > 0)
                {
                    var message = MessageQueue[0];
                    try
                    {
                        NetworkStream clientStream = Client.GetStream();
                        StreamWriter streamWriter = new StreamWriter(clientStream);
                        streamWriter.Write(message);
                        streamWriter.Flush();
                        Console.WriteLine($"We are sending '{message}' to the client");
                    }
                    catch
                    {
                        Disconnect();
                    }
                    finally
                    {
                        MessageQueue.RemoveAt(0);
                    }
                }
                Thread.Sleep(30);
            }
        }

        private void ReceivingMethod()
        {
            while (ConnectionStatus)
            {
                if (Client.Available > 0)
                {
                    try
                    {
                        NetworkStream clientStream = Client.GetStream();
                        StreamReader streamReader = new StreamReader(clientStream);
                        char[] puchBuffer = new char[Client.Available];
                        int iQtt = streamReader.Read(puchBuffer, 0, Client.Available);
                        string msg = String.Empty;
                        for (int i = 0; i < puchBuffer.Length; i++)
                        {
                            msg = $"{msg}{Convert.ToString(puchBuffer[i])}";
                        }
                        OnMessageReceived(msg);
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine(e.Message);
                    }
                }
                Thread.Sleep(30);
            }
        }

        private void OnMessageReceived(String msg)
        {
            // Here you can parse the messages coming ffrom the client and do whatever is needed
            // If needed, you can even call some public methods from the server to forward some info to an other client for example or just the server:
            // eg: Server.SomeInteractionBetweenClients();
        }
    }
}

使用系统；
使用System.Collections.Generic；
使用System.IO；
使用System.Net.Sockets；
使用系统线程；
名称空间DemoServer.Models
{
公共类接收器：ModelBase
{
bool ConnectionStatus=false；
私有单元m_Id=0；
公共uint Id
{
获取{return m_Id；}
set=>SetAndRaisePropertyChanged（参考m_Id，值）；
}
私有线程接收读取；
私有线程发送线程；
公共服务器{get；set；}
公共TcpClient客户端{get；set；}
公共列表消息队列{get；private set；}
公用接收器（TCP客户端、服务器）
{
MessageQueue=新列表（）；
服务器=服务器；
客户=客户；
Client.ReceiveBufferSize=1024；
Client.SendBufferSize=1024；
ConnectionStatus=true；
}
公开作废开始（）
{
ReceivingRead=新线程（ReceivingMethod）；
receivingtread.IsBackground=true；
receivingtread.Start（）；
sendingThread=新线程（SendingMethod）；
sendingThread.IsBackground=true；
sendingThread.Start（）；
}
私有无效断开连接（）
{
如果（！ConnectionStatus）返回；
ConnectionStatus=false；
Client.Client.Disconnect（false）；
Client.Close（）；
}
私有void发送方法（）
{
while（连接状态）
{