我通常想知道如何让 swift 委托(delegate)在主线程以外的专用线程中运行。

更具体地说，我目前正在使用 HueSDK4EDK建立我的应用程序与 Hue 网桥的连接。该过程的一部分是定义状态观察者和连接观察者(作为委托(delegate))来处理传入的事件。

private func buildBridge(withBridge bridge : BridgeInfoModel) -> PHSBridge {
    return PHSBridge.init(block: { (builder) in
        ...

        builder?.bridgeConnectionObserver = self
        builder?.add(self)
    }, withAppName: AppBundleName, withDeviceName: DeviceName)
}

委托(delegate)在扩展中实现，例如连接观察者:

extension HueApiManager : PHSBridgeConnectionObserver  {
    func bridgeConnection(_ bridgeConnection: PHSBridgeConnection!, handle connectionEvent: PHSBridgeConnectionEvent) {
    ...
    }
}

由于连接观察器中的一些代码可能是时间密集型的，我想知道是否有比这更优雅的方法:

func bridgeConnection(_ bridgeConnection: PHSBridgeConnection!, handle connectionEvent: PHSBridgeConnectionEvent) {
    let apiThread = DispatchQueue.global(qos: .utility)

    apiThread.async {
        ...
    }
}

非常感谢!

最佳答案

是的:

let apiThread = DispatchQueue.global(qos: .utility)

func bridgeConnection(_ bridgeConnection: PHSBridgeConnection!, handle connectionEvent: PHSBridgeConnectionEvent) {

    apiQueue.async {
        ...
    }
}

没有理由每次都获取队列；您可以将其存储为属性。

我知道这不是您想要的，但这是最好的方法。只需在需要时执行调度。

可以使用 forwardInvocation: 构建您在 ObjC 中实际想到的东西，但它不能很好地转换为 Swift(底层机制无法在 Swift 中实现) )，我不推荐它。蹦床是一个对象(有时是 NSProxy 对象)，它可以接受任何消息，对它做一些事情(比如将它移动到另一个队列)，然后将它重新分发给另一个对象。问题是很难告诉编译器“相信我，这将在运行时实现你需要的每个方法”(因为你实际上不能 promise ，所以它可能会崩溃)。即使在 ObjC 中，这些问题往往比它们的值(value)更麻烦，而它们值得麻烦的唯一原因首先是 ObjC 并不总是有 GCD 或 block ，当添加 block 时，语法是头痛。在 Swift 中，它要简单得多。只需添加 .async 调用即可。

不过，为了展示蹦床的样子，下面是使用操作队列(与调度队列非常相似)的蹦床的样子。这是用 ARC 之前的 ObjC 编写的，不应作为现代 ObjC 的示例来阅读。

#import <Foundation/Foundation.h>

@interface OperationQueueInvocationTrampoline : NSObject
{
    @private
    NSOperationQueue *myQueue;
    id myTarget;
}

- (id)initWithQueue:(NSOperationQueue *)queue;
@end

#import "OperationQueueInvocationTrampoline.h"

@interface OperationQueueInvocationTrampoline ()
@property (nonatomic, readwrite, retain) NSOperationQueue *queue;
@property (nonatomic, readwrite, assign) id target;
@end

@implementation OperationQueueInvocationTrampoline

@synthesize queue = myQueue;
@synthesize target = myTarget;

- (id)initWithQueue:(NSOperationQueue *)queue
{
    self = [super init];
    if (self != nil)
    {
        self.queue = queue;
    }

    return self;
}

- (void)dealloc
{
    [myQueue release];
    myQueue = nil;

    myTarget = nil;

    [super dealloc];
}

- (NSMethodSignature *)methodSignatureForSelector:(SEL)selector
{
    return [self.target methodSignatureForSelector:selector];
}

- (void)forwardInvocation:(NSInvocation *)invocation
{
    [invocation setTarget:self.target];
    self.target = nil;

    NSOperation *operation = [[[NSInvocationOperation alloc] initWithInvocation:invocation] autorelease];

    [self.queue addOperation:operation];
}

- (id)prepareWithInvocationTarget:(id)target
{
    self.target = target;

    return self;
}

@end

你会像这样使用它:

id delegate = [[OperationQueueInvocationTrampoline alloc] initWithTarget:self];

[otherThing setDelegate:delegate];

当大多数协议(protocol)是非正式的(所以这里没有类型检查，你可以只传递 id)时，这工作得很好，但是在没有警告的情况下进行编译变得越来越困惑，这在今天的 Swift 中肯定会让人头疼。它必须省去很多麻烦，但事实并非如此。

(旁注:队列与线程不同。手头的问题是将事物分派(dispatch)到哪个队列，而不是它们在哪个线程上运行。)

关于swift - 让委托(delegate)在主线程以外的地方运行，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/54074245/