Question

我有一个异步函数，必须在自己的私有队列中向调用者报告。我没有在我的函数定义中添加几个队列和闭包，而是想要使用封装结构这就是：

func doStuff(input : String, progressQeue : dispatch_queue_t, completionQueue :dispatch_queue_t, progress : ()->(), completion : ()->())

成为这个：

func doStuff(input : String, dispatch : Dispatch?)

使用：

struct Dispatch<ProgressionType,CompletionType>
{
    var progressQueue       : dispatch_queue_t
    var completionQueue     : dispatch_queue_t
    var progression : ProgressionType //a closure
    var completion  : CompletionType //a closure


    //dispatch with gcd
    func complete_sync(input : ()->())
    {
        dispatch_sync(completionQueue) {
            input()
        }
    }

    func complete_async(input : ()->())
    {
        dispatch_async(completionQueue) {
            input()
        }
    }

    ...
}

你可以在函数中调用这样的调度：

func doStuff(input : String, dispatch : Dispatch<()->(),()->(String,Int)>?)
{
  //do work
  ...
  //callback
  dispatch?.complete_async{dispatch!.completion("a", 3) }
}

优势：您隐藏一个可选参数

后面的队列和回调函数

缺点：调度＆lt;＆gt;定义可以变得相当长调度语法有点奇怪。这样的事情会更好：

  dispatch?.complete_async("a", 3)

但我不知道如何将这些参数传递给struct中的completion函数。如果通用CompletionType接受参数

，则可变参数可以工作

func complete_async(parameters : AnyObject...)
{
    dispatch_async(completionQueue) {
        completion( ??? )
    }
}

如果您对此方法有任何反馈，那就非常欢迎。

修改我刚刚意识到回调闭包总是有一个void返回：

(...) -> ()

所以这成为可能：

struct Dispatch< CompletionType > {
   var function : (CompletionType -> ())?

   init()
   {
   }

   func complete_async(parameters : T)
   {
      dispatch_async(completionQueue) {
        completion(parameters)
      }
   }
}

称为：

 dispatch?.complete_async( ("pi", 3.14) )

这里唯一的限制是CompletionType是一个元组，例如：（String，Double）

模式：用gcd快速回调

0 个答案: