Network.framework: nw_read_request_get_maximum_datagram_count

Question

我正在尝试让Network.framework中的UDP服务器正常工作。然而，每当我设法连接我的客户机和服务器时，过了一段时间我就收到了错误nw_read_request_get_maximum_datagram_count

我尝试过使用Timer和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()

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

Answer 1

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

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