C# Lidgren网络，can'；我无法连接它

在lindgren网络测试中，我无法让客户端连接到服务器。 我尝试了多种连接方式，但每次尝试连接时都会停止。 对不起，如果这是一个广泛的问题，但我做错了什么？ 这是我的密码：

class Program
{
    static NetPeerConfiguration serverconfig;
    static NetPeerConfiguration clientconfig;
    static NetServer server;
    static NetClient client;

    static void Main()
    {
        Console.Title = "LidgrenNetworkTest";
        Console.ForegroundColor = ConsoleColor.Yellow;
        Console.WriteLine("LidgrenNetworkTest console initialized.");
        Console.ForegroundColor = ConsoleColor.Gray;
        Console.Write("Color codes: ");
        Console.ForegroundColor = ConsoleColor.Yellow;
        Console.Write("System ");
        Console.ForegroundColor = ConsoleColor.Gray;
        Console.Write("Input ");
        Console.ForegroundColor = ConsoleColor.Red;
        Console.Write("Sent ");
        Console.ForegroundColor = ConsoleColor.Cyan;
        Console.Write("Received");
        Console.ForegroundColor = ConsoleColor.Yellow;
        Console.WriteLine("\n");

        Console.WriteLine("Configuring server...");
        serverconfig = new NetPeerConfiguration("LidgrenNetworkTest");
        serverconfig.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
        serverconfig.EnableMessageType(NetIncomingMessageType.DiscoveryRequest);
        serverconfig.LocalAddress = NetUtility.Resolve("localhost");
        serverconfig.Port = 8080;
        Console.WriteLine("Server configured.");

        Console.WriteLine("Configuring client...");
        clientconfig = new NetPeerConfiguration("LidgrenNetworkTest");
        clientconfig.EnableMessageType(NetIncomingMessageType.DiscoveryResponse);
        Console.WriteLine("Client configured.");

        Console.WriteLine("Initializing server...");
        server = new NetServer(serverconfig);
        server.Start();
        Console.WriteLine("Server initialized.");

        Console.WriteLine("Initializing client...");
        client = new NetClient(clientconfig);
        client.Start();
        Console.WriteLine("Client initialized.");

        Thread serverthread = new Thread(StartServer);
        serverthread.Start();

        StartClient();

        Console.ForegroundColor = ConsoleColor.Yellow;
        Console.WriteLine("Connecting client to server...");
        //client.Connect(new IPEndPoint(NetUtility.Resolve("localhost"), 8080));
        client.DiscoverLocalPeers(8080);

        AcceptConsoleInput();
    }

    static void StartServer()
    {
        NetIncomingMessage message;

        while ((message = server.ReadMessage()) != null)
        {
            switch (message.MessageType)
            {
                case NetIncomingMessageType.DiscoveryRequest:
                    Console.ForegroundColor = ConsoleColor.Cyan;
                    Console.WriteLine("(Server) Got request from client.");
                    NetOutgoingMessage response = server.CreateMessage();
                    response.Write((byte)1); // Do I need to do this?
                    server.SendDiscoveryResponse(response, message.SenderEndPoint);
                    break;
                case NetIncomingMessageType.ConnectionApproval:
                    Console.ForegroundColor = ConsoleColor.Cyan;
                    Console.WriteLine("(Server) Connection accepted.");
                    message.SenderConnection.Approve();
                    break;
                case NetIncomingMessageType.DebugMessage:
                    Console.ForegroundColor = ConsoleColor.Cyan;
                    Console.WriteLine("(Server) Debug: " + message.ReadString());
                    break;
                default:
                    Console.ForegroundColor = ConsoleColor.Cyan;
                    Console.WriteLine("(Server) Unrecognized message type! (" + message.MessageType + ")");
                    break;
            }
            server.Recycle(message);
        }
    }

    static void StartClient()
    {
        NetIncomingMessage message;

        while ((message = server.ReadMessage()) != null)
        {
            switch (message.MessageType)
            {
                case NetIncomingMessageType.DiscoveryResponse:
                    Console.ForegroundColor = ConsoleColor.Cyan;
                    Console.WriteLine("(Client) Got response from server.");
                    client.Connect(message.SenderEndPoint);
                    Console.WriteLine("(Client) Attempting to connect to server...");
                    break;
                case NetIncomingMessageType.DebugMessage:
                    Console.ForegroundColor = ConsoleColor.Cyan;
                    Console.WriteLine("(Client) Debug: " + message.ReadString());
                    break;
                default:
                    Console.ForegroundColor = ConsoleColor.Cyan;
                    Console.WriteLine("(Client) Unrecognized message type! (" + message.MessageType + ")");
                    break; 
            }
            client.Recycle(message);
        }
    }

    static void AcceptConsoleInput()
    {
        string input = Console.ReadLine();

        if (!string.IsNullOrWhiteSpace(input))
        {
            // Send input from client to server.
        }

        AcceptConsoleInput();
    }
}

还有，它被卡住的地方： 我发现了您的错误：

在

void StartClient（）

中，您正在while循环中设置

message=server.ReadMessage（）

这实际上应该是

message=client.ReadMessage（）

很抱歉反应太晚。

解决方案

using System;
using System.Threading;
using System.Collections.Generic;
using Lidgren.Network;
using System.Net;

namespace ChatClient
{
  class Program
  {
    static NetPeerConfiguration serverconfig;
    static NetPeerConfiguration clientconfig;
    static NetServer server;
    static NetClient client;

    static void Main()
    {
      NetPeerConfiguration serverconfig = new NetPeerConfiguration("chat");
      serverconfig.Port = 8081;
      serverconfig.MaximumConnections = 100;
      server = new NetServer(serverconfig);
      Thread serverthread = new Thread(StartServer);
      serverthread.Start();





      NetPeerConfiguration clientconfig = new NetPeerConfiguration("chat");
      clientconfig.AutoFlushSendQueue = false;
      client = new NetClient(clientconfig);
      Thread clientthread = new Thread(StartClient);
      clientthread.Start();
      AcceptConsoleInput();

    }

    static void StartServer()
    {
      server.Start();
      NetIncomingMessage message;

      while (true)
      {
        message = server.WaitMessage(500);
        if (message != null)
        {
          switch (message.MessageType)
          {
            case NetIncomingMessageType.DiscoveryRequest:
              NetOutgoingMessage response = server.CreateMessage();
              response.Write((byte)1); // Do I need to do this?
              server.SendDiscoveryResponse(response, message.SenderEndPoint);
              break;
            case NetIncomingMessageType.DebugMessage:
              Console.ForegroundColor = ConsoleColor.Cyan;
              Console.WriteLine("(Server) Debug: " + message.ReadString());
              break;
            case NetIncomingMessageType.StatusChanged:
              NetConnectionStatus status = (NetConnectionStatus)message.ReadByte();

              string reason = message.ReadString();
              Console.WriteLine(NetUtility.ToHexString(message.SenderConnection.RemoteUniqueIdentifier) + " " + status + ": " + reason);

              if (status == NetConnectionStatus.Connected)
                Console.WriteLine("Remote hail: " + message.SenderConnection.RemoteHailMessage.ReadString());
              break;
            case NetIncomingMessageType.Data:
              // incoming chat message from a client
              string chat = message.ReadString();


              // broadcast this to all connections, except sender
              List<NetConnection> all = server.Connections; // get copy
                                                            //all.Remove(message.SenderConnection);
              Console.WriteLine(all + "hello ");

              NetOutgoingMessage om = server.CreateMessage();
              server.SendMessage(om, all, NetDeliveryMethod.ReliableOrdered, 0);

              break;
            default:
              Console.ForegroundColor = ConsoleColor.Cyan;
              Console.WriteLine("(Server) Unrecognized message type! (" + message.MessageType + ")");
              break;
          }
        }
        server.Recycle(message);
      }
      Thread.Sleep(1);
    }

    static void StartClient()
    {
      client.Start();
      client.DiscoverLocalPeers(8081);
      NetOutgoingMessage hail = client.CreateMessage("This is the hail message");


      NetIncomingMessage message;

      while (true)
      {
        message = client.WaitMessage(500);
        if (message != null) { 
        switch (message.MessageType)
        {
            case NetIncomingMessageType.DiscoveryResponse:
              Console.WriteLine("(Client) Got response from server.");
              client.Connect(message.SenderEndPoint, hail);
              Console.WriteLine("(Client) Attempting to connect to server...");
              break;

            case NetIncomingMessageType.DebugMessage:
            Console.WriteLine(message.ReadString());
            break;
          case NetIncomingMessageType.ErrorMessage:
            Console.WriteLine(message.ReadString());
            break;
          case NetIncomingMessageType.WarningMessage:
            Console.WriteLine(message.ReadString());
            break;
          case NetIncomingMessageType.VerboseDebugMessage:
            Console.WriteLine(message.ReadString());
            break;
          case NetIncomingMessageType.Data:
            string chat = message.ReadString();
            break;
          case NetIncomingMessageType.StatusChanged:
            NetConnectionStatus status = (NetConnectionStatus)message.ReadByte();
            Console.WriteLine(status.ToString());
            break;
          default:
            Console.ForegroundColor = ConsoleColor.Cyan;
            Console.WriteLine("(Client) Unrecognized message type! (" + message.MessageType + ")");
            break;
        }
      }
        client.Recycle(message);
      }
    }


    static void AcceptConsoleInput()
    {
      string input = Console.ReadLine();

      if (!string.IsNullOrWhiteSpace(input))
      {
        NetOutgoingMessage om = client.CreateMessage(input);
        client.SendMessage(om, NetDeliveryMethod.ReliableSequenced);
        client.FlushSendQueue();
      }

      AcceptConsoleInput();
    }
  }
}

使用系统；
使用系统线程；
使用System.Collections.Generic；
使用Lidgren.Network；
Net系统；
命名空间聊天客户端
{
班级计划
{
静态NetPeerConfiguration服务器配置；
静态NetPeerConfiguration客户端配置；
静态网络服务器；
静态网络客户端；
静态void Main（）
{
NetPeerConfiguration serverconfig=新的NetPeerConfiguration（“聊天”）；
serverconfig.Port=8081；
serverconfig.MaximumConnections=100；
服务器=新的NetServer（serverconfig）；
线程服务器线程=新线程（StartServer）；
serverthread.Start（）；
NetPeerConfiguration客户端配置=新NetPeerConfiguration（“聊天”）；
clientconfig.AutoFlushSendQueue=false；
client=新的NetClient（clientconfig）；
线程clientthread=新线程（StartClient）；
clientthread.Start（）；
AcceptConsoleInput（）；
}
静态void StartServer（）
{
server.Start（）；
网络信息；
while（true）
{
message=server.WaitMessage（500）；
如果（消息！=null）
{
开关（message.MessageType）
{
案例NetIncomingMessageType.DiscoveryRequest：
NetOutgoingMessage响应=server.CreateMessage（）；
response.Write（（字节）1）；//我需要这样做吗？
server.SendDiscoveryResponse（响应，message.SenderEndPoint）；
打破
案例NetIncomingMessageType.DebugMessage：
Console.ForegroundColor=ConsoleColor.Cyan；
Console.WriteLine（“（服务器）调试：”+message.ReadString（））；
打破
案例NetIncomingMessageType.StatusChanged：
NetConnectionStatus状态=（NetConnectionStatus）message.ReadByte（）；
字符串原因=message.ReadString（）；
Console.WriteLine（NetUtility.ToHexString（message.SenderConnection.RemoteUniqueIdentifier）+“+”状态+：“+原因）；
如果（状态==NetConnectionStatus.Connected）
Console.WriteLine（“Remote hail:+message.SenderConnection.RemoteHailMessage.ReadString（））；
打破
案例NetIncomingMessageType。数据：
//来自客户端的传入聊天消息
string chat=message.ReadString（）；
//将此消息广播到除发件人之外的所有连接
List all=server.Connections；//获取副本
//全部删除（message.SenderConnection）；
Console.WriteLine（all+“hello”）；
NetOutgoingMessage om=server.CreateMessage（）；
server.SendMessage（om，all，NetDeliveryMethod.ReliableOrdered，0）；
打破
违约：
Console.ForegroundColor=ConsoleColor.Cyan；
Console.WriteLine（“（服务器）无法识别的消息类型！（“+message.MessageType+”））；
打破
}
}
回收（消息）；
}
睡眠（1）；
}
静态void StartClient（）
{
client.Start（）；
client.DiscoverLocalPeers（8081）；
NetOutgoingMessage hail=client.CreateMessage（“这是hail消息”）；
网络信息；
while（true）
{
message=client.WaitMessage（500）；
如果（消息！=null）{
开关（message.MessageType）
{
案例NetIncomingMessageType.DiscoveryResponse：
WriteLine（（客户端）从服务器获得响应）；
client.Connect（message.SenderEndPoint，hail）；
Console.WriteLine（“（客户端）正在尝试连接到服务器…”）；
打破
案例NetIncomingMessageType.DebugMessage：
Console.WriteLine（message.ReadString（））；
打破
案例NetIncomingMessageType.ErrorMessage：
Console.WriteLine（message.ReadString（））；
打破
案例NetIncomingMessageType.WarningMessage：
Console.WriteLine（message.ReadString（））；
打破
案例NetIncomingMessageType.VerboseDebugMessage：
Console.WriteLine（message.ReadString（））；
打破
案例NetIncomingMessageType。数据：
string chat=message.ReadString（）；
打破
案例NetIncomingMessageType.StatusChanged：
NetConnectionStatus状态=（NetConnectionStatus）message.ReadByte（）；
Console.WriteLine（status.ToString（））；
打破
违约：
Console.ForegroundColor=ConsoleColor.Cyan；
Console.WriteLine（“（客户端）无法识别的消息类型！（“+message.MessageType+”））；
打破
}
}
客户端回收（消息）；
}
}
静态无效AcceptConsoleInput（）
{
字符串输入=Console.ReadLine（）；
如果（！string.IsNullOrWhiteSpace（输入））
{
NetOutgoingMessage om=client.CreateMessage（输入）；
SendMessage（om，NetDeliveryMethod.ReliableSequenced）；
client.FlushSendQueue（）；
}
AcceptConsoleInput（）；
}
}
}

我改变了很多，所以我可以测试每个部分。我发现了一个问题，那就是消息几乎立刻就变成空的。我将其更改为连续检查，即使它为空，也会继续检查

提供的样品有效吗