Using Swift with Cocoa and Objective-C (Swift 2.1)

Adopting Cocoa Design Patterns

https://developer.apple.com/library/mac/documentation/Swift/Conceptual/BuildingCocoaApps/AdoptingCocoaDesignPatterns.html#//apple_ref/doc/uid/TP40014216-CH7-ID6

One aid in writing well-designed,resilient apps is to use Cocoa’s established design patterns. Many of these patterns rely on classes defined in Objective-C. Because of Swift’s interoperability with Objective-C,you can take advantage of these common patterns in your Swift code. In many cases,you can use Swift Language features to extend or simplify existing Cocoa patterns,making them more powerful and easier to use.

Delegation

In both Swift and Objective-C,delegation is often expressed with a protocol that defines the interaction and a conforming delegate property. Just as in Objective-C,before you send a message that a delegate may not respond to,you ask the delegate whether it responds to the selector. In Swift,you can use optional chaining to invoke an optional protocol method on a possiblynilobject and unwrap the possible result usingif–letSyntax. The code listing below illustrates the following process:

1. Check thatmyDelegateis notnil.

2. Check thatmyDelegateimplements the methodwindow:willUseFullScreenContentSize:.

3. If 1 and 2 hold true,invoke the method and assign the result of the method to the value namedfullScreenSize.

4. Print the return value of the method.

1. class MyDelegate: NSObject, NSWindowDelegate {
2. func window(window: NSWindow, willUseFullScreenContentSize proposedSize: NSSize) -> NSSize {
3. return proposedSize
4. }
5. var myDelegate: NSWindowDelegate? = MyDelegate()
6. if let fullScreenSize = myDelegate?.window?(myWindow,116)"> willUseFullScreenContentSize: mySize) {
7. print(NsstringFromSize(fullScreenSize))
8. }

Lazy Initialization

Alazy propertyis a property whose underlying value is only initialized when the property is first accessed. Lazy properties are useful when the initial value for a property either requires complex or computationally expensive setup,or cannot be determined until after an instance’s initialization is complete.

In Objective-C,a property may override its synthesized getter method such that the underlying instance variable is conditionally initialized if its value isnil:

1. @property NSXMLDocument *XMLDocument;
3. - (NSXMLDocument *)XMLDocument {
4. if (_XMLDocument == nil) {
5. _XMLDocument = [[NSXMLDocument alloc] initWithContentsOfURL:[[NSBundle mainBundle] URLForResource:@"/path/to/resource" withExtension:@"xml"] options:0 error:nil];
6. }
7. return _XMLDocument;
8. }

In Swift,a stored property with an initial value can be declared with thelazymodifier to have the expression calculating the initial value only evaluated when the property is first accessed:

1. lazy var XMLDocument: NSXMLDocument = try! NSXMLDocument(contentsOfURL: NSBundle.mainBundle().URLForResource("document",116)"> withExtension: "xml")!,116)"> options: 0)

Because a lazy property is only computed when accessed for a fully-initialized instance it may access constant or variable properties in its default value initialization expression:

pattern: String

regex: NSRegularExpression = NSRegularExpression(pattern: self.pattern,116)"> options: [])

For values that require additional setup beyond initialization,you can assign the default value of the property to a self-evaluating closure that returns a fully-initialized value:

ISO8601DateFormatter: NSDateFormatter = {

let formatter = NSDateFormatter()

formatter.locale = NSLocale(localeIdentifier: "en_US_POSIX")

dateFormat = "yyyy-MM-dd'T'HH:mm:ssZZZZZ"

formatter

}()

NOTE

If a lazy property has not yet been initialized and is accessed by more than one thread at the same time,there is no guarantee that the property will be initialized only once.

For more information,seeLazy Stored PropertiesinThe Swift Programming Language (Swift 2.1).

Error Handling

In Cocoa,methods that produce errors take anNSErrorpointer parameter as their last parameter,which populates its argument with anNSErrorobject if an error occurs. Swift automatically translates Objective-C methods that produce errors into methods that throw an error according to Swift’s native error handling functionality.

Methods thatconsumeerrors,such as delegate methods or methods that take a completion handler with anNSErrorobject argument,do not become methods that throw when imported by Swift.

For example,consider the following Objective-C method fromNSFileManager:

1. - (BOOL)removeItemAtURL:(NSURL *)URL
2. error:(NSError **)error;

removeItemAtURL(URL: NSURL) throws