I don't remember what it was, and I don't think there was a good reason for it. Addendum added : Under ARC, you should use weak instead of assign. Weak references get set to nil automatically when the object dies, eliminating the possibility that the delegating object will end up sending messages to the dead delegate. Note that when you have a delegate that's assign, it makes it very important to always set that delegate value to nil whenever the object is going to be deallocated - so an object should always be careful to nil out delegate references in dealloc if it has not done so elsewhere.
One of the reason behind that is to avoid retain cycles. Just to avoid the scenario where A and B both object reference each other and none of them is released from memory. Acutally assign is best for primitive types like NSInteger and CGFloat, or objects you don't directly own, such as delegates.
Why are Objective-C delegates usually given the property assign instead of retain? Reply 2. As someone that's new to Objective-C can someone give me an overview of the retain, assign, copy and any others I'm missing, that follow the property Preface: I'm not a java developer. Where are sessions session data Thanks all!
What's the standard relational database idiom for setting permissions for items? Answers should be general; however, they should be able to be applied to I'm not a Java developer, but my client has hired one to update some JAR files on their site. Prior to doing so, we audited the existing code and Login using GitHub. Related questions ios - Delegates - retain or assign - release? Powered by Question2Answer.
This is analogous to an interface or abstract base class, as it creates a special type for your delegate, UIWebViewDelegate in this case. Delegate implementors would have to adopt this protocol:.
And then implement the methods in the protocol. For methods declared in the protocol as optional like most delegate methods , you need to check with -respondsToSelector: before calling a particular method on it. Delegate methods are typically named starting with the delegating class name, and take the delegating object as the first parameter.
They also often use a will-, should-, or did- form. So, webViewDidStartLoad: first parameter is the web view rather than loadStarted taking no parameters for example. Instead of checking whether a delegate responds to a selector every time we want to message it, you can cache that information when delegates are set. One very clean way to do this is to use a bitfield, as follows:. Then, in the body, we can check that our delegate handles messages by accessing our delegateRespondsTo struct, rather than by sending -respondsToSelector: over and over again.
Before protocols existed, it was common to use a category on NSObject to declare the methods a delegate could implement. For example, CALayer still does this:. You would then use the same -respondsToSelector: approach as described above to call this method. Delegates implement this method and assign the delegate property, and that's it there's no declaring you conform to a protocol. This method is common in Apple's libraries, but new code should use the more modern protocol approach above, since this approach pollutes NSObject which makes autocomplete less useful and makes it hard for the compiler to warn you about typos and similar errors.
When using the formal protocol method for creating delegate support, I've found that you can ensure proper type checking albeit, runtime, not compile time by adding something like:. The way it works is that you set some object that you wrote as the delegate to NSWindow, but your object only has implementations methods for one or a few of the many possible delegate methods. So something happens, and NSWindow wants to call your object - it just uses Objective-c's respondsToSelector method to determine if your object wants that method called, and then calls it.
This is how objective-c works - methods are looked up on demand. It is totally trivial to do this with your own objects, there is nothing special going on, you could for instance have an NSArray of 27 objects, all different kinds of objects, only 18 some of them having the method - void setToBue; The other 9 don't. So to call setToBlue on all of 18 that need it done, something like this:. The other thing about delegates is that they are not retained, so you always have to set the delegate to nil in your MyClass dealloc method.
Delegate in iOS. As a good practice recommended by Apple, it's good for the delegate which is a protocol, by definition , to conform to NSObject protocol.
So when using methods that you have specified as optional, you need to in your class check with respondsToSelector if the view that is conforming to your delegate has actually implemented your optional method s or not. I think all these answers make a lot of sense once you understand delegates.
What are delegates? These are static pointers to classes within another class. What are protocols? Conceptually it serves as similar purpose as to the header file of the class you are assigning as a delegate class.
A protocol is a explicit way of defining what methods needs to be implemented in the class who's pointer was set as a delegate within a class. But this wiring needs to be maitained within the code and will be clumsy and error prone. Objective C just assumes that programmers are not best at maintaining this decipline and provides compiler restrictions to enforce a clean implementation. A delegate is just a class that does some work for another class. Read the following code for a somewhat silly but hopefully enlightening Playground example that shows how this is done in Swift.
0コメント