दिलचस्प पोस्ट
ऑटोबॉक्ज़िंग जावा में कुछ कॉल को अस्पष्ट क्यों करता है? VBA में स्ट्रिंग अर्रे की घोषणा और आरंभ करें क्यों तरीकों का संदर्भ समानता नहीं है? जावा विभाजन () विधि अंत में खाली तार स्ट्रिप्स? डायरेक्टएक्स का उपयोग कर स्क्रीन कैप्चर करें क्रोम ब्राउज़र के साथ वेबड्राइवर चलाने पर, संदेश प्राप्त हो रहा है, हालांकि ब्राउज़र ठीक से लॉन्च करता है, "केवल स्थानीय कनेक्शन की अनुमति है" एंड्रॉइड में Res / raw फ़ोल्डर में संग्रहीत। एमपी 3 फाइल के यूआरआर प्राप्त करें आवेदनविशेषतया बनाम बनाम एप्लिकेशनडिडबैकअक्टिव, एप्लिकेशनवालेरेसाइनएक्टिव बनाम एप्लिकेशनडेडएन्टरबैकग्राउंड कैसे शैली UITextview गोल राइट पाठ क्षेत्र की तरह करने के लिए? मैं जावास्क्रिप्ट में एक तिथि तुलना कैसे करूं? क्या <i> <i> <span> के बजाय आइकन के लिए टैग का उपयोग करना चाहिए? कैसे jQuery का उपयोग कर एक "टैग बॉक्स" बनाने के लिए (पाठ इनपुट फ़ील्ड + टैग कॉमा द्वारा अलग किए गए) पायथन में पुनरावर्ती की मूल बातें गतिशील रूप से अंगुलर 2 में ईवेंट श्रोता जोड़ें ऑब्जेक्ट मूल्यों को फ़ंक्शन कॉल्स के अंदर क्यों पकड़ा गया?

प्रेषण के बाद – जीसीडी स्विफ्ट में?

मैं एप्पल से आईबुक के माध्यम से चले गए हैं, और इसके बारे में कोई परिभाषा नहीं मिली:

क्या कोई dispatch_after की संरचना की व्याख्या कर सकता है?

 dispatch_after(<#when: dispatch_time_t#>, <#queue: dispatch_queue_t?#>, <#block: dispatch_block_t?#>) 

Solutions Collecting From Web of "प्रेषण के बाद – जीसीडी स्विफ्ट में?"

संरचना का एक स्पष्ट विचार:

 dispatch_after(when: dispatch_time_t, queue: dispatch_queue_t, block: dispatch_block_t?) 

dispatch_time_t एक UInt64 डिस्पैच_क्यूई_टी वास्तव में एक NSObject लिए NSObject प्रकार है, लेकिन आपको क्यूई प्राप्त करने के लिए अपने परिचित जीसीडी पद्धतियों का उपयोग करना चाहिए। ब्लॉक एक स्विफ्ट बंद है विशेष रूप से, dispatch_block_t को () -> Void रूप में परिभाषित किया गया है, जो () -> () बराबर है।

उदाहरण उपयोग:

 let delayTime = dispatch_time(DISPATCH_TIME_NOW, Int64(1 * Double(NSEC_PER_SEC))) dispatch_after(delayTime, dispatch_get_main_queue()) { print("test") } 

संपादित करें:

मैं मैट का वास्तव में अच्छा delay समारोह का उपयोग करने की सलाह देता हूं।

2 संपादित करें:

स्विफ्ट 3 में, जीसीडी के लिए नए रैपर होंगे। यहां देखें: https://github.com/apple/swift-evolution/blob/master/proposals/0088-libdispatch-for-swift3.md

मूल उदाहरण को लिफ्ट के रूप में स्विफ्ट 3 में लिखा जाएगा:

 let deadlineTime = DispatchTime.now() + .seconds(1) DispatchQueue.main.asyncAfter(deadline: deadlineTime) { print("test") } 

नोट करें कि आप DispatchTime.now() + 1.0 रूप में deadlineTime टाइम DispatchTime.now() + 1.0 लिख सकते हैं और उसी परिणाम प्राप्त कर सकते हैं क्योंकि + ऑपरेटर को ओवरराइड किया गया है (इसी प्रकार के लिए - ):

  • func +(time: DispatchTime, seconds: Double) -> DispatchTime
  • func +(time: DispatchWalltime, interval: DispatchTimeInterval) -> DispatchWalltime

इसका मतलब यह है कि यदि आप DispatchTimeInterval enum DispatchTimeInterval enum उपयोग नहीं करते हैं और सिर्फ एक संख्या लिखते हैं, तो यह माना जाता है कि आप सेकेंड का उपयोग कर रहे हैं।

मैं अक्सर इतनी बार dispatch_after उपयोग करता हूं कि मैंने सिंटैक्स सरल बनाने के लिए एक शीर्ष-स्तरीय उपयोगिता फ़ंक्शन लिखा था:

 func delay(delay:Double, closure:()->()) { dispatch_after( dispatch_time( DISPATCH_TIME_NOW, Int64(delay * Double(NSEC_PER_SEC)) ), dispatch_get_main_queue(), closure) } 

और अब आप इस तरह से बात कर सकते हैं:

 delay(0.4) { // do stuff } 

वाह, एक भाषा है जहां आप भाषा को बेहतर बना सकते हैं। इससे अच्छा क्या हो सकता है?


स्विफ्ट 3, एक्सकोड 8 बीज 6 के लिए अद्यतन

लगता है लगभग साथ परेशान करने के लायक नहीं है, अब वे फोन वाक्यविन्यास में सुधार हुआ है:

 func delay(_ delay:Double, closure:@escaping ()->()) { let when = DispatchTime.now() + delay DispatchQueue.main.asyncAfter(deadline: when, execute: closure) } 

मैट का वाक्यविन्यास बहुत अच्छा है और अगर आपको ब्लॉक को अमान्य करना है, तो आप इसका उपयोग करना चाह सकते हैं:

 typealias dispatch_cancelable_closure = (cancel : Bool) -> Void func delay(time:NSTimeInterval, closure:()->Void) -> dispatch_cancelable_closure? { func dispatch_later(clsr:()->Void) { dispatch_after( dispatch_time( DISPATCH_TIME_NOW, Int64(time * Double(NSEC_PER_SEC)) ), dispatch_get_main_queue(), clsr) } var closure:dispatch_block_t? = closure var cancelableClosure:dispatch_cancelable_closure? let delayedClosure:dispatch_cancelable_closure = { cancel in if closure != nil { if (cancel == false) { dispatch_async(dispatch_get_main_queue(), closure!); } } closure = nil cancelableClosure = nil } cancelableClosure = delayedClosure dispatch_later { if let delayedClosure = cancelableClosure { delayedClosure(cancel: false) } } return cancelableClosure; } func cancel_delay(closure:dispatch_cancelable_closure?) { if closure != nil { closure!(cancel: true) } } 

का पालन करें के रूप में उपयोग करें

 let retVal = delay(2.0) { println("Later") } delay(1.0) { cancel_delay(retVal) } 

क्रेडिट

ऊपर लिंक नीचे लगता है गिथूब से मूल Objc कोड

सेज़री के जवाब पर विस्तार करने के लिए, जो 1 नैनोसेकंड के बाद निष्पादित होगा, मुझे 4 और एक आधे सेकंड के बाद निष्पादित करने के लिए निम्नलिखित करना पड़ा।

  let delay = 4.5 * Double(NSEC_PER_SEC) let time = dispatch_time(DISPATCH_TIME_NOW, Int64(delay)) dispatch_after(time, dispatch_get_main_queue(), block) 

संपादित करें: मुझे पता चला कि मेरा मूल कोड थोड़ा गलत था। यदि आप एनएसईसी_PER_SEC को एक डबल में नहीं डाले तो इम्प्लास्टिक टाइपिंग एक कंपाइल त्रुटि का कारण बनता है

यदि कोई अधिक इष्टतम समाधान सुझा सकता है तो मैं इसे सुनना चाहता हूं।

== स्विफ्ट 3 == के लिए अद्यतन

स्विफ्ट 3 में यह सुपर-आसान और सुरुचिपूर्ण है:

  DispatchQueue.main.asyncAfter(deadline: .now() + 4.5) { // ... } 

ऐप्पल के पास उद्देश्य-सी के लिए एक प्रेषण- स्निपेट है I

 dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(<#delayInSeconds#> * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{ <#code to be executed after a specified delay#> }); 

स्विफ्ट 3 में एक ही स्निपेट रखा गया है:

 DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + <#delayInSeconds#>) { <#code to be executed after a specified delay#> } 

एक और तरीका है कि इस तरह डबल का विस्तार करना है:

 extension Double { var dispatchTime: dispatch_time_t { get { return dispatch_time(DISPATCH_TIME_NOW,Int64(self * Double(NSEC_PER_SEC))) } } } 

तो आप इसे इस तरह से उपयोग कर सकते हैं:

 dispatch_after(Double(2.0).dispatchTime, dispatch_get_main_queue(), { () -> Void in self.dismissViewControllerAnimated(true, completion: nil) }) 

मुझे मैट की देरी का काम पसंद है, लेकिन वरीयता से बाहर ही मैं पास के करीब रहने वाले कमरे को सीमित करना चाहता हूं।

स्विफ्ट 3.0 और स्विफ्ट 4.0 में सरल समाधान

 func delayWithSeconds(_ seconds: Double, completion: @escaping () -> ()) { DispatchQueue.main.asyncAfter(deadline: .now() + seconds) { completion() } } 

प्रयोग

 delayWithSeconds(1) { //Do something } 

स्विफ्ट 3.0 में

डिस्पैच कतार

  DispatchQueue(label: "test").async { //long running Background Task for obj in 0...1000 { print("async \(obj)") } // UI update in main queue DispatchQueue.main.async(execute: { print("UI update on main queue") }) } DispatchQueue(label: "m").sync { //long running Background Task for obj in 0...1000 { print("sync \(obj)") } // UI update in main queue DispatchQueue.main.sync(execute: { print("UI update on main queue") }) } 

5 सेकंड के बाद डिस्पैच

  DispatchQueue.main.after(when: DispatchTime.now() + 5) { print("Dispatch after 5 sec") } 

1) इस विधि को UIViewController एक्सटेंशन के एक भाग के रूप में जोड़ें।

 extension UIViewController{ func runAfterDelay(delay: NSTimeInterval, block: dispatch_block_t) { let time = dispatch_time(DISPATCH_TIME_NOW, Int64(delay * Double(NSEC_PER_SEC))) dispatch_after(time, dispatch_get_main_queue(), block) } } 

इस विधि को वीसी पर कॉल करें:

  self.runAfterDelay(5.0, block: { //Add code to this block print("run After Delay Success") }) 

2) प्रदर्शन करनेवाला ("yourMethod नाम", ऑब्जेक्ट के साथ: शून्य, बाद में: 1)

3)

 override func viewWillAppear(animated: Bool) { dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 2), dispatch_get_main_queue(), { () -> () in //Code Here }) 

// कॉम्पैक्ट फॉर्म

 dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 2), dispatch_get_main_queue()) { //Code here } 

}

स्विफ्ट 3.0 संस्करण

मुख्य थ्रेड पर विलंब के बाद बंद करने की फ़ंक्शन कुछ कार्य निष्पादित करता है।

 func performAfterDelay(delay : Double, onCompletion: @escaping() -> Void){ DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + delay, execute: { onCompletion() }) } 

इस फ़ंक्शन को इस तरह कॉल करें:

 performAfterDelay(delay: 4.0) { print("test") } 

हालांकि, ओपी द्वारा मूल प्रश्न नहीं, कुछ NSTimer से संबंधित प्रश्न इस प्रश्न के डुप्लिकेट के रूप में चिह्नित किए गए हैं, इसलिए यहां NSTimer उत्तर भी शामिल है।

NSTimer बनाम dispatch_after

  • NSTimer अधिक उच्च स्तर है, जबकि dispatch_after अधिक निम्न स्तर है।
  • NSTimer रद्द करना आसान है dispatch_after रद्द करना अधिक कोड लिखना आवश्यक है।

NSTimer साथ कार्य करने में देरी

एक NSTimer उदाहरण बनाएँ

 var timer = NSTimer() 

टाइमर को उस देरी के साथ प्रारंभ करें, जिसकी आपको ज़रूरत है।

 // invalidate the timer if there is any chance that it could have been called before timer.invalidate() // delay of 2 seconds timer = NSTimer.scheduledTimerWithTimeInterval(2.0, target: self, selector: #selector(delayedAction), userInfo: nil, repeats: false) 

विलंब के बाद कहा जाने वाला फ़ंक्शन जोड़ें (जो भी नाम आप ऊपर selector पैरामीटर के लिए उपयोग किया गया था)।

 func delayedAction() { print("Delayed action has now started." } 

टिप्पणियाँ

  • यदि आपको ऐसा करने से पहले कार्रवाई रद्द करने की आवश्यकता है, तो बस timer.invalidate() कॉल करें timer.invalidate()
  • दोहराए जाने वाले कार्यों के लिए repeats: true
  • यदि आपके पास एक समय का ईवेंट है जिसमें रद्द करने की कोई आवश्यकता नहीं है, तो timer इंस्टेंस चर बनाने की कोई आवश्यकता नहीं है। निम्न पर्याप्त होगा:

     NSTimer.scheduledTimerWithTimeInterval(2.0, target: self, selector: #selector(delayedAction), userInfo: nil, repeats: false) 
  • मेरा पूरा जवाब यहाँ देखें

अपने कोड को देरी करने के लिए एक और सहायक जो उपयोग में 100% स्विफ्ट है और वैकल्पिक रूप से आपके विलंबित कोड को चलाने के लिए एक अलग थ्रेड को चुनने की अनुमति देता है:

 public func delay(bySeconds seconds: Double, dispatchLevel: DispatchLevel = .main, closure: @escaping () -> Void) { let dispatchTime = DispatchTime.now() + seconds dispatchLevel.dispatchQueue.asyncAfter(deadline: dispatchTime, execute: closure) } public enum DispatchLevel { case main, userInteractive, userInitiated, utility, background var dispatchQueue: DispatchQueue { switch self { case .main: return DispatchQueue.main case .userInteractive: return DispatchQueue.global(qos: .userInteractive) case .userInitiated: return DispatchQueue.global(qos: .userInitiated) case .utility: return DispatchQueue.global(qos: .utility) case .background: return DispatchQueue.global(qos: .background) } } } 

अब आप इस तरह मुख्य थैली पर अपने कोड को देरी कर सकते हैं :

 delay(bySeconds: 1.5) { // delayed code } 

यदि आप अपने कोड को किसी अलग थ्रेड पर देरी करना चाहते हैं:

 delay(bySeconds: 1.5, dispatchLevel: .background) { // delayed code that will run on background thread } 

यदि आप किसी फ्रेमवर्क को पसंद करते हैं जिसमें कुछ और आसान सुविधाएं भी हैं तो हैण्डस्विफ्ट चेकआउट करें आप इसे अपनी परियोजना के माध्यम से कार्थेज के माध्यम से जोड़ सकते हैं तो इसका इस्तेमाल ऊपर के उदाहरणों में ठीक तरह से करें, जैसे:

 import HandySwift delay(bySeconds: 1.5) { // delayed code } 

यह मेरे लिए काम किया

स्विफ्ट 3:

 let time1 = 8.23 let time2 = 3.42 // Delay 2 seconds DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) { print("Sum of times: \(time1 + time2)") } 

उद्देश्य सी:

 CGFloat time1 = 3.49; CGFloat time2 = 8.13; // Delay 2 seconds dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{ CGFloat newTime = time1 + time2; NSLog(@"New time: %f", newTime); }); 

2.0 सेकंड के बाद कुछ यूआई से संबंधित कार्य करने के लिए इस कोड का उपयोग करें।

  let delay = 2.0 let delayInNanoSeconds = dispatch_time(DISPATCH_TIME_NOW, Int64(delay * Double(NSEC_PER_SEC))) let mainQueue = dispatch_get_main_queue() dispatch_after(delayInNanoSeconds, mainQueue, { print("Some UI related task after delay") }) 

स्विफ्ट 3.0 संस्करण

मुख्य थ्रेड पर विलंब के बाद बंद करने की फ़ंक्शन कुछ कार्य निष्पादित करता है।

 func performAfterDelay(delay : Double, onCompletion: @escaping() -> Void){ DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + delay, execute: { onCompletion() }) } 

इस फ़ंक्शन को इस तरह कॉल करें:

 performAfterDelay(delay: 4.0) { print("test") }