Encontramos esta información que consideramos muy valiosa para ser compartida contigo y nos dimos a la tarea de traducirla, esperamos que la disfrutes.

Swift Dispatch ofrece una excelente forma de programar y controlar el código concurrente.   Aquí hay cinco maneras fáciles de mejorar tu experiencia en Dispatch.

1. Agregando Segundos

Swift facilita la búsqueda de el tiempo actual como DispatchTime.


let timeNow = DispatchTime.now()

Puedes añadir fácilmente segundos a now (en incrementos dobles) usando el operador +. Como puedes ver en su firma, el RHS del operador + espera un valor doble de segundos.

Aquí hay un par de ejemplos que muestran lo fácil que es hacer esto:


let timeInFive = DispatchTime.now() + 5
 let timeInSevenAndHalf: DispatchTime = .now() + 7.5

DispatchTime también admite el operador menos, aunque la sustracción se utiliza raramente en Dispatch:


public func -(time: DispatchTime, seconds: Double) -> DispatchTime

2. Agregar tiempo de unidad

DispatchTimeInterval ofrece unidades prácticas para microsegundos, milisegundos, nanosegundos y segundos. Todos ellos toman argumentos enteros:

Por ejemplo, puede enviar cinco comandos de impresión, cada uno desplazado por un número de segundos creciente:


(1 ... 5).forEach {
 DispatchQueue.main.asyncAfter(
 deadline: .now() + .seconds($0)) {
 print("Hi there!")
 }
 }

Este enfoque funciona mezclando y haciendo coincidir DispatchTime y DispatchTimeInterval. Estos operadores también se cocinan en Swift:


public func +(time: DispatchTime, interval: DispatchTimeInterval) -> DispatchTime
 public func -(time: DispatchTime, interval: DispatchTimeInterval) -> DispatchTime

Esta versión es discutiblemente más legible y más fácil de mantener que el raw + 5 del trick #1:


let timeInFive = DispatchTime.now() + .seconds(5)

3.Usando Puntos Flotantes con Intervalos de tiempo de Dispatch

Los inicializadores de caso DispatchTimeInterval están limitados a argumentos enteros. Puedes extender el tipo para agregar soporte a valores dobles, devolver una instancia de nanosegundo con el valor equivalente para un número doble de segundos:


// Built-in enumeration
 public enum DispatchTimeInterval {
 case seconds(Int)
 case milliseconds(Int)
 case microseconds(Int)
 case nanoseconds(Int)
 }

// Custom factory using a `Double` value
 extension DispatchTimeInterval {
 public static func seconds(_ amount: Double) -> DispatchTimeInterval {
 let delay = Double(NSEC_PER_SEC) * amount
 return DispatchTimeInterval.nanoseconds(Int(delay))
 }
 }

Al igual que el uso anterior de DispatchTimeInterval, este constructor de conveniencia mejora la legibilidad del código al pasar por alto los inicializadores de caso Int-only:


let timeInEightAndHalf: DispatchTime = .now() + .seconds(8.5)

4.Delanteros asincrónicos

Aunque las matemáticas de DispatchTime son convenientes, es super común programar el código con respecto al tiempo actual. ¿Por qué no dejar que DispatchTime haga el trabajo pesado para ti? En lugar de decir .now () + algún intervalo, considera extender DispatchTime para incorporar ahora a la llamada. He aquí un ejemplo que introduce un secondsFromNow (_ :)dispatch time:


extension DispatchTime {
 public static func secondsFromNow(_ amount: Double) -> DispatchTime {
 return DispatchTime.now() + amount
 }
 }

stride(from: 1.0, through: 5.0, by: 1.0).forEach {
 DispatchQueue.main.asyncAfter(deadline: .secondsFromNow($0)) {
 print("Hi there!")
 }
 }

5. Pruebas en los Playgrounds

Cuando trabaje con el despacho en los Playgrounds, asegúrese de que la ejecución continúe hasta que termine su trabajo. Utilice la ejecución indefinida de PlaygroundPage y la detención para controlar ese trabajo.


import PlaygroundSupport

PlaygroundPage.current.needsIndefiniteExecution = true
DispatchQueue.main.asyncAfter(deadline: .now() + .seconds(10)) {
print(“Ending Execution”)
PlaygroundPage.current.finishExecution()
}

 

DEJA UNA RESPUESTA

Please enter your comment!
Please enter your name here