Network Framework Migration Guides

Migration 1: From BSD Sockets to NWConnection

Migration mapping

BSD Sockets NWConnection Notes

socket() + connect()

NWConnection(host:port:using:) + start()

Non-blocking by default

send() / sendto()

connection.send(content:completion:)

Async, returns immediately

recv() / recvfrom()

connection.receive(minimumIncompleteLength:maximumLength:completion:)

Async, returns immediately

bind() + listen()

NWListener(using:on:)

Automatic port binding

accept()

listener.newConnectionHandler

Callback for each connection

getaddrinfo()

Let NWConnection handle DNS Smart resolution with racing

SCNetworkReachability

connection.stateUpdateHandler waiting state No race conditions

setsockopt()

NWParameters configuration Type-safe options

Example migration

Before (BSD Sockets)

// BEFORE — Blocking, manual DNS, error-prone var hints = addrinfo() hints.ai_family = AF_INET hints.ai_socktype = SOCK_STREAM

var results: UnsafeMutablePointer<addrinfo>? getaddrinfo("example.com", "443", &hints, &results)

let sock = socket(results.pointee.ai_family, results.pointee.ai_socktype, 0) connect(sock, results.pointee.ai_addr, results.pointee.ai_addrlen) // BLOCKS

let data = "Hello".data(using: .utf8)! data.withUnsafeBytes { ptr in send(sock, ptr.baseAddress, data.count, 0) }

After (NWConnection)

// AFTER — Non-blocking, automatic DNS, type-safe let connection = NWConnection( host: NWEndpoint.Host("example.com"), port: NWEndpoint.Port(integerLiteral: 443), using: .tls )

connection.stateUpdateHandler = { state in if case .ready = state { let data = Data("Hello".utf8) connection.send(content: data, completion: .contentProcessed { error in if let error = error { print("Send failed: (error)") } }) } }

connection.start(queue: .main)

Benefits

• 20 lines → 10 lines

• No manual DNS, no blocking, no unsafe pointers

• Automatic Happy Eyeballs, proxy support, WiFi Assist

Migration 2: From NWConnection to NetworkConnection (iOS 26+)

Why migrate

• Async/await eliminates callback hell

• TLV framing and Coder protocol built-in

• No [weak self] needed (async/await handles cancellation)

• State monitoring via async sequences

Migration mapping

NWConnection (iOS 12-25) NetworkConnection (iOS 26+) Notes

connection.stateUpdateHandler = { state in }

for await state in connection.states { }

Async sequence

connection.send(content:completion:)

try await connection.send(content)

Suspending function

connection.receive(minimumIncompleteLength:maximumLength:completion:)

try await connection.receive(exactly:)

Suspending function

Manual JSON encode/decode Coder(MyType.self, using: .json)

Built-in Codable support

Custom framer TLV { TLS() }

Built-in Type-Length-Value

[weak self] everywhere No [weak self] needed Task cancellation automatic

Example migration

Before (NWConnection)

// BEFORE — Completion handlers, manual memory management let connection = NWConnection(host: "example.com", port: 443, using: .tls)

connection.stateUpdateHandler = { [weak self] state in switch state { case .ready: self?.sendData() case .waiting(let error): print("Waiting: (error)") case .failed(let error): print("Failed: (error)") default: break } }

connection.start(queue: .main)

func sendData() { let data = Data("Hello".utf8) connection.send(content: data, completion: .contentProcessed { [weak self] error in if let error = error { print("Send error: (error)") return } self?.receiveData() }) }

func receiveData() { connection.receive(minimumIncompleteLength: 10, maximumLength: 10) { [weak self] (data, context, isComplete, error) in if let error = error { print("Receive error: (error)") return } if let data = data { print("Received: (data)") } } }

After (NetworkConnection)

// AFTER — Async/await, automatic memory management let connection = NetworkConnection( to: .hostPort(host: "example.com", port: 443) ) { TLS() }

// Monitor states in background task Task { for await state in connection.states { switch state { case .preparing: print("Connecting...") case .ready: print("Ready") case .waiting(let error): print("Waiting: (error)") case .failed(let error): print("Failed: (error)") default: break } } }

// Send and receive with async/await func sendAndReceive() async throws { let data = Data("Hello".utf8) try await connection.send(data)

let received = try await connection.receive(exactly: 10).content
print("Received: \(received)")

}

Benefits

• 30 lines → 15 lines

• No callback nesting, no [weak self]

• Errors propagate naturally with throws

• Automatic cancellation on Task exit

Migration 3: From URLSession StreamTask to NetworkConnection

When to migrate

• Need UDP (StreamTask only supports TCP)

• Need custom protocols beyond TCP/TLS

• Need low-level control (packet pacing, ECN, service class)

When to STAY with URLSession

• Doing HTTP/HTTPS (URLSession optimized for this)

• Need WebSocket support

• Need built-in caching, cookie handling

Example migration

Before (URLSession StreamTask)

// BEFORE — URLSession for TCP/TLS stream let task = URLSession.shared.streamTask(withHostName: "example.com", port: 443)

task.resume()

task.write(Data("Hello".utf8), timeout: 10) { error in if let error = error { print("Write error: (error)") } }

task.readData(ofMinLength: 10, maxLength: 10, timeout: 10) { data, atEOF, error in if let error = error { print("Read error: (error)") return } if let data = data { print("Received: (data)") } }

After (NetworkConnection)

// AFTER — NetworkConnection for TCP/TLS let connection = NetworkConnection( to: .hostPort(host: "example.com", port: 443) ) { TLS() }

func sendAndReceive() async throws { try await connection.send(Data("Hello".utf8)) let data = try await connection.receive(exactly: 10).content print("Received: (data)") }

Resources

Skills: axiom-ios-networking, axiom-networking-legacy