Swift Network.framework:nw\u read\u request\u get\u max\u datagram\u count

我正在尝试使UDP服务器在Network.framework中运行。然而，每当我设法连接客户端和服务器时，经过一段时间后，我收到错误

nw\u read\u request\u get\u maximum\u datagram\u count

我尝试过使用计时器和DispatchQueue进行循环，但最终服务器或客户端会因上述错误而崩溃

客户

import Foundation
import Network

class ExampleClient {
    lazy var connection: NWConnection = {
        let connection = NWConnection(
            to: .service(
                name: "Emma’s MacBook Pro",
                type: "_test._udp",
                domain: "local",
                interface: nil
            ),
            using: .udp
        )

        connection.stateUpdateHandler = { (newState) in
            switch newState {
            case .ready:
                self.loopForever()
            case .failed(let error):
                print("client failed with error: \(error)")
            default:
                break
            }
        }

        return connection

    }()

    func run() {
        connection.start(queue: DispatchQueue(label: "client"))

    }

    func loopForever() {
        while true {
            connection.send(content: "hello".data(using: .utf8), completion: .contentProcessed({ (error) in
                if let error = error {
                    print("error while sending hello: \(error)")
                }

                self.connection.receiveMessage { (data, context, isComplete, error) in
                    return

                }

            }))

        }

    }

}

let client = ExampleClient()
client.run()

RunLoop.main.run()

服务器

import Foundation
import Network

class ExampleServer {
    var connections = [NWConnection]()
    lazy var listener: NWListener = {
        let listener = try! NWListener(using: .udp)

        listener.service = NWListener.Service(type: "_test._udp")
        listener.serviceRegistrationUpdateHandler = { (serviceChange) in
            switch serviceChange {
            case .add(let endpoint):
                switch endpoint {
                case let .service(name, _, _, _):
                    print("listening as name \(name)")
                default:
                    break
                }
            default:
                break
            }

        }
        listener.newConnectionHandler = { (newConnection) in
            newConnection.start(queue: DispatchQueue(label: "new client"))
            self.connections.append(newConnection)

        }

        return listener

    }()

    func run() {
        self.listener.start(queue: DispatchQueue(label: "server"))

        while true {
            for connection in self.connections {
                connection.receiveMessage { (message, context, isComplete, error) in
                    connection.send(content: "world".data(using: .utf8), completion: .contentProcessed({ (error) in
                        if let error = error {
                            print("error while sending data: \(error)")

                        }

                    }))

                }

            }

        }

    }

}

let server = ExampleServer()
server.run()

RunLoop.main.run()

---

在客户端或服务器手动断开连接之前，我希望保持服务器和客户端之间的持续连接。

在接收器中，不要将接收处理程序排队到发送的完成处理程序中

在服务器中，不要尝试将无限多的接收处理程序排队。每个连接一次一个就足够了