Блог

В Objective-C я часто обхожу блоки. Я использую их очень часто для реализации шаблонов, которые помогают избежать хранения данных в переменных экземпляра, тем самым избегая проблем с потоками / синхронизацией.

Например, я назначаю их CAAnimation через -[CAAnimation setValue:forKey:] , чтобы я мог выполнить блок после завершения анимации. (Objective-C может обрабатывать блоки как объекты; вы также можете выполнять [someBlock copy] и [someBlock release] .)

Однако попытка использовать эти шаблоны в Swift вместе с Objective-C кажется очень сложной. (Редактировать: и мы видим, что язык все еще находится в процессе изменения: адаптировали код, чтобы он работал на Xcode6-beta2, предыдущая версия работала на Xcode6-beta1.)

Например, я не могу преобразовать AnyObject обратно в блок / замыкание. Следующее выдает ошибку компилятора:

 override func animationDidStop(anim: CAAnimation!, finished flag: Bool)
{
    let completion : AnyObject! = anim.valueForKey("completionClosure")
    (completion as (@objc_block ()->Void))()
    // Cannot convert the expression's type 'Void' to type '@objc_block () -> Void'
}
  

Я нашел обходной путь, но он довольно уродливый, ИМХО: в моем связующем заголовке у меня есть:

 static inline id blockToObject(void(^block)())
{
    return block;
}

static inline void callBlockAsObject(id block)
{
    ((void(^)())block)();
}
  

И теперь я могу сделать это в Swift:

 func someFunc(completion: (@objc_block ()->Void))
{
    let animation = CAKeyframeAnimation(keyPath: "position")
    animation.delegate = self
    animation.setValue(blockToObject(completion), forKey: "completionClosure")
    …
}

override func animationDidStop(anim: CAAnimation!, finished flag: Bool)
{
    let completion : AnyObject! = anim.valueForKey("completionClosure")
    callBlockAsObject(completion)
}
  

Это работает, но мне понадобилась бы новая функция для каждого типа блока, который я хотел бы использовать, и я взламываю компилятор, который тоже не может быть хорошим.

Итак, есть ли способ решить это чисто быстрым способом?

Как насчет универсального, Block параметризованного с типом функции?

 class Block<T> {
  let f : T
  init (_ f: T) { self.f = f }
}
  

Выделите одно из них; это будет подтип AnyObject и, таким образом, его можно будет назначить в словари и массивы. Это не кажется слишком обременительным, особенно с синтаксисом завершающего замыкания. Используется:

   5> var b1 = Block<() -> ()> { print ("Blocked b1") }
b1: Block<() -> ()> = {
  f = ...
}
  6> b1.f()
Blocked b1
  

и еще один пример, в котором выводится Block тип:

  11> var ar = [Block { (x:Int) in print ("Block: (x)") }]
ar: [Block<(Int) -> ()>] = 1 value {
  [0] = {
    f = ...
  }
}
 12> ar[0].f(111)
Block: 111
  

Мне нравится решение Гозонера — обернуть блок в пользовательский класс — но поскольку вы просили фактический «Быстрый способ» для выполнения приведения между блоком и AnyObject, я просто дам ответ на этот вопрос: приведение с помощью unsafeBitCast . (Я предполагаю, что это более или менее то же самое, что у Брайана Чена reinterpretCast , которого больше не существует.)

Итак, в моем собственном коде:

 typealias MyDownloaderCompletionHandler = @objc_block (NSURL!) -> ()
  

Примечание: в Swift 2 это было бы:

 typealias MyDownloaderCompletionHandler = @convention(block) (NSURL!) -> ()
  

Вот приведение в одном направлении:

 // ... cast from block to AnyObject
let ch : MyDownloaderCompletionHandler = // a completion handler closure
let ch2 : AnyObject = unsafeBitCast(ch, AnyObject.self)
  

Вот приведение обратно в другом направлении:

 // ... cast from AnyObject to block
let ch = // the AnyObject
let ch2 = unsafeBitCast(ch, MyDownloaderCompletionHandler.self)
// and now we can call it
ch2(url)
  

Вот еще одно решение, позволяющее нам выполнять приведение для обмена значениями с Objective-C. Он основан на идее Гозонера о том, чтобы обернуть функцию в класс; разница в том, что наш класс является подклассом NSObject и, таким образом, может предоставить функции Objective-C управление блочной памятью без каких-либо взломов и может быть непосредственно использован как AnyObject и передан Objective-C:

 typealias MyStringExpecter = (String) -> ()
class StringExpecterHolder : NSObject {
    var f : MyStringExpecter! = nil
}
  

Вот как использовать это для переноса функции и передачи туда, где ожидается AnyObject:

 func f (s:String) {println(s)}
let holder = StringExpecterHolder()
holder.f = f

let lay = CALayer()
lay.setValue(holder, forKey:"myFunction")
  

И вот как извлечь функцию позже и вызвать ее:

 let holder2 = lay.valueForKey("myFunction") as StringExpecterHolder
holder2.f("testing")
  

Все, что вам нужно сделать, это использовать reinterpretCast для выполнения принудительного приведения.

 (reinterpretCast(completion) as (@objc_block Void -> Void))()
  

из REPL

   1> import Foundation
  2> var block : @objc_block Void -> Void = { println("test")}
block: @objc_block Void -> Void =
  3> var obj = reinterpretCast(block) as AnyObject // this is how to cast block to AnyObject given it have @objc_block attribute
obj: __NSMallocBlock__ = {}
  4> var block2 = reinterpretCast(obj) as (@objc_block Void -> Void)
block2: (@objc_block Void -> Void) =
  5> block2()
test
  6>