যখন NSOperationQueue সমস্ত কাজ শেষ করে বিজ্ঞপ্তি পান

Question 1

NSOperationQueueআছে waitUntilAllOperationsAreFinished, তবে আমি এর জন্য একযোগে অপেক্ষা করতে চাই না। সারি শেষ হওয়ার পরে আমি কেবলমাত্র ইউআইতে অগ্রগতি সূচকটি আড়াল করতে চাই।

এটি সম্পাদন করার সর্বোত্তম উপায় কী?

আমি আমার NSOperationএস থেকে বিজ্ঞপ্তিগুলি পাঠাতে পারি না , কারণ কোনটি শেষ হতে চলেছে তা আমি জানি না এবং বিজ্ঞপ্তি পাওয়ার পরে [queue operations]খালি (বা আরও খারাপ - পুনর্নির্মাণ) হতে পারে না।

Question 2

operationsআপনার সারির সম্পত্তিটি পর্যবেক্ষণ করতে কেভিও ব্যবহার করুন , তারপরে আপনার সারির পরীক্ষাটি শেষ করে শেষ হয়েছে কিনা তা আপনি বলতে পারবেন [queue.operations count] == 0।

যে ফাইলটিতে আপনি কেভিও করছেন সেখানে কোথাও কেভিওর জন্য একটি প্রসঙ্গ ঘোষণা করুন ( আরও তথ্য ):

static NSString *kQueueOperationsChanged = @"kQueueOperationsChanged";

আপনি যখন আপনার সারি সেটআপ করবেন, তখন এটি করুন:

[self.queue addObserver:self forKeyPath:@"operations" options:0 context:&kQueueOperationsChanged];

তারপরে এটি আপনার করুন observeValueForKeyPath:

- (void) observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object 
                         change:(NSDictionary *)change context:(void *)context
{
    if (object == self.queue && [keyPath isEqualToString:@"operations"] && context == &kQueueOperationsChanged) {
        if ([self.queue.operations count] == 0) {
            // Do something here when your queue has completed
            NSLog(@"queue has completed");
        }
    }
    else {
        [super observeValueForKeyPath:keyPath ofObject:object 
                               change:change context:context];
    }
}

(এটি ধরে নেওয়া হচ্ছে যে আপনার NSOperationQueueনামের কোনও সম্পত্তিতে রয়েছে queue)

আপনার অবজেক্টটি পুরোপুরি deallocs করার আগে (বা যখন এটি সারি অবস্থার বিষয়ে যত্ন নেওয়া বন্ধ করে), আপনাকে কেভিও থেকে এইভাবে নিবন্ধন করতে হবে:

[self.queue removeObserver:self forKeyPath:@"operations" context:&kQueueOperationsChanged];

সংযোজন: আইওএস ৪.০ এর একটি NSOperationQueue.operationCountসম্পত্তি রয়েছে, যা ডক্স অনুসারে কেভিও অনুগত। এই উত্তরটি এখনও আইওএস ৪.০ এ কাজ করবে, সুতরাং এটি পিছনের সামঞ্জস্যের জন্য এখনও কার্যকর।

Question 3

যদি আপনি এমন আচরণের সাথে মেলে এমন কিছু প্রত্যাশা (বা আকাঙ্ক্ষা) করছেন:

t=0 add an operation to the queue.  queueucount increments to 1
t=1 add an operation to the queue.  queueucount increments to 2
t=2 add an operation to the queue.  queueucount increments to 3
t=3 operation completes, queuecount decrements to 2
t=4 operation completes, queuecount decrements to 1
t=5 operation completes, queuecount decrements to 0
<your program gets notified that all operations are completed>

আপনার সচেতন হওয়া উচিত যে যদি "শর্ট" ক্রিয়াকলাপগুলিকে একটি কাতারে যুক্ত করা হয় তবে আপনি পরিবর্তে এই আচরণটি দেখতে পাবেন (কারণ কাতারে যুক্ত হওয়ার অংশ হিসাবে অপারেশনগুলি শুরু হয়েছে):

t=0  add an operation to the queue.  queuecount == 1
t=1  operation completes, queuecount decrements to 0
<your program gets notified that all operations are completed>
t=2  add an operation to the queue.  queuecount == 1
t=3  operation completes, queuecount decrements to 0
<your program gets notified that all operations are completed>
t=4  add an operation to the queue.  queuecount == 1
t=5  operation completes, queuecount decrements to 0
<your program gets notified that all operations are completed>

আমার প্রকল্পে আমাকে জানতে হবে শেষ অপারেশনটি কখন শেষ হয়েছিল, প্রচুর ক্রিয়াকলাপটি সিরিয়াল NSOperationQueue (অর্থাত্, ম্যাকসকন্ট্রোরঅপারেশনকন্ট = 1) এ যুক্ত হওয়ার পরে এবং যখন তারা সমস্ত সম্পন্ন করেছিল তখনই।

গুগলিং আমি এই প্রশ্নের জবাবে একজন অ্যাপল বিকাশকারীর কাছ থেকে এই বিবৃতিটি খুঁজে পেয়েছি "সিরিয়াল এনএস্পেরেশনকিউ ফিফো?" -

যদি সমস্ত ক্রিয়াকলাপের একই অগ্রাধিকার থাকে (যা অপারেশনটিকে একটি সারি যুক্ত করার পরে পরিবর্তন করা হয় না) এবং সমস্ত ক্রিয়াকলাপ সর্বদা হয় - isReady == হ্যাঁ অপারেশন কাতারে উপস্থিত হওয়ার পরে, তবে একটি সিরিয়াল NSOperationQueue ফিফো।

ক্রিস কেন কোকো ফ্রেমওয়ার্কস, অ্যাপল

আমার ক্ষেত্রে এটি শেষের অপারেশনটি কাতারে কখন যুক্ত হয়েছিল তা জানা সম্ভব। সুতরাং শেষ অপারেশন যুক্ত হওয়ার পরে, আমি কাতারে আরও অপারেশন যুক্ত করছি, নিম্ন অগ্রাধিকারের, যা সারিটি খালি করা হয়েছে বলে বিজ্ঞপ্তি পাঠানো ছাড়া কিছুই করে না। অ্যাপলের বিবৃতি দেওয়া, এটি নিশ্চিত করে যে সমস্ত ক্রিয়াকলাপ সম্পন্ন হওয়ার পরে কেবলমাত্র একটি নোটিশ পাঠানো হবে।

যদি অপারেশনগুলি এমনভাবে যুক্ত করা হয় যা শেষটিকে সনাক্ত করতে দেয় না, (উদাহরণস্বরূপ, অ-সংজ্ঞাবাদী) তবে আমি মনে করি যে আপনাকে উপরে উল্লিখিত কেভিও পদ্ধতির সাথে যেতে হবে, অতিরিক্ত গার্ড যুক্তি যুক্ত করে আরও চিহ্নিত করার চেষ্টা করার চেষ্টা করা হয়েছে অপারেশন যোগ করা যেতে পারে।

:)

Question 4

কীভাবে এমন এনএসওপ্রেশন যুক্ত করবেন যা অন্য সকলের উপর নির্ভরশীল যাতে এটি শেষ পর্যন্ত চলে?

Question 5

এর একটি বিকল্প হ'ল জিসিডি ব্যবহার করা। পড়ুন এই রেফারেন্স হিসেবে।

dispatch_queue_t queue = dispatch_get_global_queue(0,0);
dispatch_group_t group = dispatch_group_create();

dispatch_group_async(group,queue,^{
 NSLog(@"Block 1");
 //run first NSOperation here
});

dispatch_group_async(group,queue,^{
 NSLog(@"Block 2");
 //run second NSOperation here
});

//or from for loop
for (NSOperation *operation in operations)
{
   dispatch_group_async(group,queue,^{
      [operation start];
   });
}

dispatch_group_notify(group,queue,^{
 NSLog(@"Final block");
 //hide progress indicator here
});

Question 6

এইভাবেই আমি এটি করি।

সারিটি সেট আপ করুন, এবং ক্রিয়াকলাপ সংস্থার পরিবর্তনের জন্য নিবন্ধন করুন:

myQueue = [[NSOperationQueue alloc] init];
[myQueue addObserver: self forKeyPath: @"operations" options: NSKeyValueObservingOptionNew context: NULL];

... এবং পর্যবেক্ষক (এই ক্ষেত্রে self) প্রয়োগগুলি:

- (void) observeValueForKeyPath:(NSString *) keyPath ofObject:(id) object change:(NSDictionary *) change context:(void *) context {

    if (
        object == myQueue
        &&
        [@"operations" isEqual: keyPath]
    ) {

        NSArray *operations = [change objectForKey:NSKeyValueChangeNewKey];

        if ( [self hasActiveOperations: operations] ) {
            [spinner startAnimating];
        } else {
            [spinner stopAnimating];
        }
    }
}

- (BOOL) hasActiveOperations:(NSArray *) operations {
    for ( id operation in operations ) {
        if ( [operation isExecuting] && ! [operation isCancelled] ) {
            return YES;
        }
    }

    return NO;
}

এই উদাহরণে "স্পিনার" UIActivityIndicatorViewএমন কিছু দেখাচ্ছে যা কিছু ঘটছে is অবশ্যই আপনি মামলা অনুসারে পরিবর্তন করতে পারেন ...

Question 7

এর মতো আইওএস 13.0 , operationCount এবং অপারেশন বৈশিষ্ট্য অবচিত করছে। আপনার কাতারে ক্রিয়াকলাপের সংখ্যাটি নিজের উপর নজর রাখা এবং সমস্ত কিছু শেষ হয়ে গেলে কোনও বিজ্ঞপ্তি বন্ধ করে দেওয়া ঠিক তত সহজ । এই উদাহরণটি অপারেশনের একটি অ্যাসিনক্রোনাস সাবক্লাসিংয়ের সাথেও কাজ করে।

class MyOperationQueue: OperationQueue {
            
    public var numberOfOperations: Int = 0 {
        didSet {
            if numberOfOperations == 0 {
                print("All operations completed.")
                
                NotificationCenter.default.post(name: .init("OperationsCompleted"), object: nil)
            }
        }
    }
    
    public var isEmpty: Bool {
        return numberOfOperations == 0
    }
    
    override func addOperation(_ op: Operation) {
        super.addOperation(op)
        
        numberOfOperations += 1
    }
    
    override func addOperations(_ ops: [Operation], waitUntilFinished wait: Bool) {
        super.addOperations(ops, waitUntilFinished: wait)
        
        numberOfOperations += ops.count
    }
    
    public func decrementOperationCount() {
        numberOfOperations -= 1
    }
}

নীচে সহজ অ্যাসিনক্রোনাস অপারেশনগুলির জন্য অপারেশনের একটি উপক্লাস রয়েছে

class AsyncOperation: Operation {
    
    let queue: MyOperationQueue

enum State: String {
    case Ready, Executing, Finished
    
    fileprivate var keyPath: String {
        return "is" + rawValue
    }
}

var state = State.Ready {
    willSet {
        willChangeValue(forKey: newValue.keyPath)
        willChangeValue(forKey: state.keyPath)
    }
    
    didSet {
        didChangeValue(forKey: oldValue.keyPath)
        didChangeValue(forKey: state.keyPath)
        
        if state == .Finished {
            queue.decrementOperationCount()
        }
    }
}

override var isReady: Bool {
    return super.isReady && state == .Ready
}

override var isExecuting: Bool {
    return state == .Executing
}

override var isFinished: Bool {
    return state == .Finished
}

override var isAsynchronous: Bool {
    return true
}

public init(queue: MyOperationQueue) {
    self.queue = queue
    super.init()
}

override func start() {
    if isCancelled {
        state = .Finished
        return
    }
    
    main()
    state = .Executing
}

override func cancel() {
    state = .Finished
}

override func main() {
    fatalError("Subclasses must override main without calling super.")
}

}

Question 8

আমি এটি করতে একটি বিভাগ ব্যবহার করছি।

NSOperationQueue + সমাপ্তি

//
//  NSOperationQueue+Completion.h
//  QueueTest
//
//  Created by Artem Stepanenko on 23.11.13.
//  Copyright (c) 2013 Artem Stepanenko. All rights reserved.
//

typedef void (^NSOperationQueueCompletion) (void);

@interface NSOperationQueue (Completion)

/**
 * Remarks:
 *
 * 1. Invokes completion handler just a single time when previously added operations are finished.
 * 2. Completion handler is called in a main thread.
 */

- (void)setCompletion:(NSOperationQueueCompletion)completion;

@end

NSOperationQueue + Completion.m

//
//  NSOperationQueue+Completion.m
//  QueueTest
//
//  Created by Artem Stepanenko on 23.11.13.
//  Copyright (c) 2013 Artem Stepanenko. All rights reserved.
//

#import "NSOperationQueue+Completion.h"

@implementation NSOperationQueue (Completion)

- (void)setCompletion:(NSOperationQueueCompletion)completion
{
    NSOperationQueueCompletion copiedCompletion = [completion copy];

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        [self waitUntilAllOperationsAreFinished];

        dispatch_async(dispatch_get_main_queue(), ^{
            copiedCompletion();
        });
    });
}

@end

ব্যবহার :

NSBlockOperation *operation1 = [NSBlockOperation blockOperationWithBlock:^{
    // ...
}];

NSBlockOperation *operation2 = [NSBlockOperation blockOperationWithBlock:^{
    // ...
}];

[operation2 addDependency:operation1];

NSOperationQueue *queue = [[NSOperationQueue alloc] init];
[queue addOperations:@[operation1, operation2] waitUntilFinished:YES];

[queue setCompletion:^{
    // handle operation queue's completion here (launched in main thread!)
}];

সূত্র: https://gist.github.com/artemstepanenko/7620471

Question 9

কিউওর ব্যবহার সারির operationCountসম্পত্তি পর্যবেক্ষণ করতে হবে ? তারপরে আপনি সারিটি খালি হয়ে গেলে এবং এটি খালি হওয়া বন্ধ করে দেওয়ার বিষয়ে শুনতে পেতেন। অগ্রগতি সূচকটি নিয়ে কাজ করা ঠিক যেমন কিছু করা ঠিক তত সহজ হতে পারে:

[indicator setHidden:([queue operationCount]==0)]

Question 10

সর্বশেষ অপারেশনটি যুক্ত করুন:

NSInvocationOperation *callbackOperation = [[NSInvocationOperation alloc] initWithTarget:object selector:selector object:nil];

সুতরাং:

- (void)method:(id)object withSelector:(SEL)selector{
     NSInvocationOperation *callbackOperation = [[NSInvocationOperation alloc] initWithTarget:object selector:selector object:nil];
     [callbackOperation addDependency: ...];
     [operationQueue addOperation:callbackOperation]; 

}

Question 11

সঙ্গে ReactiveObjC আমি এই চমত্কারভাবে কাজ করে খুঁজে পেয়েছেন:

// skip 1 time here to ignore the very first call which occurs upon initialization of the RAC block
[[RACObserve(self.operationQueue, operationCount) skip:1] subscribeNext:^(NSNumber *operationCount) {
    if ([operationCount integerValue] == 0) {
         // operations are done processing
         NSLog(@"Finished!");
    }
}];

Question 12

এফওয়াইআই, আপনি জিসিডি ডিসপ্যাচ_গ্রুপের সাথে সুইফট 3 এ অর্জন করতে পারেন । সমস্ত কাজ শেষ হয়ে গেলে আপনি বিজ্ঞপ্তি পেতে পারেন।

let group = DispatchGroup()

    group.enter()
    run(after: 6) {
      print(" 6 seconds")
      group.leave()
    }

    group.enter()
    run(after: 4) {
      print(" 4 seconds")
      group.leave()
    }

    group.enter()
    run(after: 2) {
      print(" 2 seconds")
      group.leave()
    }

    group.enter()
    run(after: 1) {
      print(" 1 second")
      group.leave()
    }


    group.notify(queue: DispatchQueue.global(qos: .background)) {
      print("All async calls completed")
}

Question 13

আপনি একটি নতুন তৈরি করতে পারেন NSThread, বা পটভূমিতে কোনও নির্বাচককে কার্যকর করতে পারেন এবং সেখানে অপেক্ষা করতে পারেন। NSOperationQueueশেষ হয়ে গেলে আপনি নিজের একটি বিজ্ঞপ্তি পাঠাতে পারেন।

আমি এরকম কিছু নিয়ে ভাবছি:

- (void)someMethod {
    // Queue everything in your operationQueue (instance variable)
    [self performSelectorInBackground:@selector(waitForQueue)];
    // Continue as usual
}

...

- (void)waitForQueue {
    [operationQueue waitUntilAllOperationsAreFinished];
    [[NSNotificationCenter defaultCenter] postNotification:@"queueFinished"];
}

Question 14

আপনি এই ব্যবহার করেন তাহলে অপারেশন আপনার বেস শ্রেণী হিসেবে, আপনি পাস পারে whenEmpty {}অবরোধ OperationQueue :

let queue = OOperationQueue()
queue.addOperation(op)
queue.addOperation(delayOp)

queue.addExecution { finished in
    delay(0.5) { finished() }
}

queue.whenEmpty = {
    print("all operations finished")
}

Question 15

কেভিও ছাড়াই

private let queue = OperationQueue()

private func addOperations(_ operations: [Operation], completionHandler: @escaping () -> ()) {
    DispatchQueue.global().async { [unowned self] in
        self.queue.addOperations(operations, waitUntilFinished: true)
        DispatchQueue.main.async(execute: completionHandler)
    }
}

Question 16

আপনি যদি এখানে কম্বাইনের সাহায্যে সমাধান খুঁজছেন - আমি কেবল আমার নিজের রাষ্ট্রের অবজেক্ট শুনে এসেছি।

@Published var state: OperationState = .ready
var sub: Any?

sub = self.$state.sink(receiveValue: { (state) in
 print("state updated: \(state)")
})