მომიყევი ოპერაციების გაუქმების მექანიზმზე.

iOS- ში ოპერაციების გაუქმების მექანიზმი დაფუძნებულია Cancellable პროტოკოლზე და დაკავშირებულ ტიპებზე.

ძირითადი კომპონენტები:

1. Cancellable პროტოკოლი: განსაზღვრავს მეთოდის cancel() მოთხოვნას, რომელიც ინიციირებს გაუქმებას.

   // პროტოკოლის განსაზღვრის ფრაგმენტი
   public protocol Cancellable {
       func cancel()
   }
   

2. AnyCancellable: ტიპის ობერტაიმი, რომელიც ინახავს ნებისმიერ Cancellable-ს შესაბამის ტიპს და ავტომატურად იძახის cancel() დეინიციალიზაციისას. სასარგებლოა გამოწვევების/ოპერაციების სიცოცხლის ციკლის მართვაში.

   // გამოყენების მაგალითი
   var cancellable = AnyCancellable {
       // გაუქმების მოქმედება
       print("ოპერაცია გაუქმებულია")
   }
   
   // scope-ის შიგნით, სადაც განსაზღვრულია cancellable, გამოსვლისას ის იძახის cancel()
   

3. Combine-ში გაუქმება: Combine-ის ფრემვორკში უმეტესობა გამომცემლების (Publisher) უზრუნველყოფს გამოწვევას (Subscription), რომელიც ახორციელებს Cancellable-ს. როდესაც იძახით cancel()-ს Subscription-ზე, მონაცემთა ნაკადი შეწყდება. ჩვეულებრივ, Subscription-ი იფუთება AnyCancellable-ში და ინახება.

   // მაგალითი Combine-ში
   import Combine
   
   let publisher = Timer.publish(every: 1, on: .main, in: .common).autoconnect()
   var cancellable: AnyCancellable? = publisher.sink { completion in
       print("შესრულება: \(completion)")
   } receiveValue: { date in
       print("მნიშვნელობა: \(date)")
   }
   
   // გაუქმება გარკვეული დროის შემდეგ
   DispatchQueue.main.asyncAfter(deadline: .now() + 3) {
       cancellable?.cancel() // cancel()-ს იძახის `AnyCancellable`-ზე
       cancellable = nil // ლინკის წაშლა
   }
   

4. Operation და OperationQueue: ძველ API-ებშიც არსებობს გაუქმების მექანიზმი. Operation კლასი აქვს მეთოდი cancel() და თვისება isCancelled. OperationQueue ამ თვისებას იძახის და არ გეგმავს გაუქმებული ოპერაციების შესრულებას.

   import Foundation
   
   class MyOperation: Operation {
       override func main() {
           if isCancelled { // გაუქმების სტატუსის შემოწმება
               print("ოპერაცია გაუქმებულია დაწყებამდე")
               return
           }
   
           // დავალების შესრულება
           for i in 0..<1000 {
               if isCancelled { // გაუქმების სტატუსის შემოწმება შიგნით
                   print("ოპერაცია გაუქმებულია შესრულების დროს")
                   return
               }
               // მძიმე სამუშაო ან API-ს მოწოდება
               print("საფეხური \(i)")
           }
   
           print("ოპერაცია დასრულდა")
       }
   }
   
   let queue = OperationQueue()
   let operation = MyOperation()
   
   queue.addOperation(operation)
   
   // გაუქმება გარკვეული დროის შემდეგ
   DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
      operation.cancel() // cancel()-ს იძახის
   }
   
   // დასრულების მოლოდინი (მაგალითად, რეალურ აპლიკაციაში ასე არ უნდა გაკეთდეს main-ზზე)
   // queue.waitUntilAllOperationsAreFinished()
   

iOS-ში გაუქმების მექანიზმი ასინქრონულია და კოოპერატიული. cancel()-ის იძახვა სიგნალია გაუქმების განზრახვის შესახებ, მაგრამ რეალური შეჩერება დამოკიდებულია იმაზე, როგორ ახორციელებს ოპერაცია ამ სიგნალის დამუშავებას (მაგ., isCancelled-ის შემოწმებით ან გაუქმების გამოწვევაზე რეაგირებით).

გაუქმებადი ობიექტების მართვა (განსაკუთრებით AnyCancellable) ხშირად ხორციელდება მათი შენახვით კოლექციებში (Set<AnyCancellable>) ან ობიექტების თვისებებში, რათა გარანტირებული იყოს cancel()-ის გამოძახება დეინიციალიზაციის დროს ან კოლექციიდან გამოთიშვისას.