代表们在迅速？
如何做一个委托，即NSUserNotificationCenterDelegate在NSUserNotificationCenterDelegate ？
这与obj-c没有什么不同。 首先，你必须在类声明中指定协议，如下所示：
class MyClass: NSUserNotificationCenterDelegate
实现将如下所示：
// NSUserNotificationCenterDelegate implementation func userNotificationCenter(center: NSUserNotificationCenter, didDeliverNotification notification: NSUserNotification) { //implementation } func userNotificationCenter(center: NSUserNotificationCenter, didActivateNotification notification: NSUserNotification) { //implementation } func userNotificationCenter(center: NSUserNotificationCenter, shouldPresentNotification notification: NSUserNotification) -> Bool { //implementation return true }
当然，你必须设置委托。 例如：
NSUserNotificationCenter.defaultUserNotificationCenter().delegate = self;
这里有两个视图控制器之间的代表一些帮助：
第1步：在UIViewController中创建一个协议，您将要删除/将要发送的数据。
protocol FooTwoViewControllerDelegate { func myVCDidFinish(_ controller: FooTwoViewController, text: String) }
第二步：在发送类中声明委托（即UIViewcontroller）
class FooTwoViewController: UIViewController { weak var delegate: FooTwoViewControllerDelegate? [snip...] }
第三步：在类方法中使用委托将数据发送到接收方法，这是任何采用协议的方法。
@IBAction func saveColor(_ sender: UIBarButtonItem) { delegate?.myVCDidFinish(self, text: colorLabel.text) //assuming the delegate is assigned otherwise error }
步骤4：采用接收类中的协议
class ViewController: UIViewController, FooTwoViewControllerDelegate {
第5步：实现委托方法
func myVCDidFinish(_ controller: FooTwoViewController, text: String) { colorLabel.text = "The Color is " + text controller.navigationController.popViewController(animated: true) }
第6步：在prepareForSegue中设置委托：
override func prepare(for segue: UIStoryboardSegue, sender: Any?) { if segue.identifier == "mySegue" { let vc = segue.destination as! FooTwoViewController vc.colorString = colorLabel.text vc.delegate = self } }
这应该工作。 这当然只是代码片段，但应该给你的想法。 对于这个代码的一个长的解释，你可以在这里去我的博客条目：
塞格和代表
如果你对我在这里写下的代表感兴趣，
与代表引擎盖下
代表们总是困惑我，直到我意识到一个代表只是一个班级，为另一个班级做一些工作 。 这就像在别人那里为你做所有你不想做的肮脏工作。
我写了一个小故事来说明这一点。 如果你喜欢，请在操场上阅读。
很久以前…
// MARK: Background to the story // A protocol is like a list of rules that need to be followed. protocol OlderSiblingDelegate: class { // The following command (ie, method) must be obeyed by any // underling (ie, delegate) of the older sibling. func getYourNiceOlderSiblingAGlassOfWater() } // MARK: Characters in the story class BossyBigBrother { // I can make whichever little sibling is around at // the time be my delegate (ie, slave) weak var delegate: OlderSiblingDelegate? func tellSomebodyToGetMeSomeWater() { // The delegate is optional because even though // I'm thirsty, there might not be anyone nearby // that I can boss around. delegate?.getYourNiceOlderSiblingAGlassOfWater() } } // Poor little sisters have to follow (or at least acknowledge) // their older sibling's rules (ie, protocol) class PoorLittleSister: OlderSiblingDelegate { func getYourNiceOlderSiblingAGlassOfWater() { // Little sis follows the letter of the law (ie, protocol), // but no one said exactly how she had to respond. print("Go get it yourself!") } } // MARK: The Story // Big bro is laying on the couch watching basketball on TV. let bigBro = BossyBigBrother() // He has a little sister named Sally. let sally = PoorLittleSister() // Sally walks into the room. How convenient! Now big bro // has someone there to boss around. bigBro.delegate = sally // So he tells her to get him some water. bigBro.tellSomebodyToGetMeSomeWater() // Unfortunately no one lived happily ever after... // The end.
回顾一下，制作和使用委托模式有三个关键部分。
- 该协议定义了工作人员需要做的事情
- 老板类有一个委托变量，它用来告诉工人类做什么
- 采用该协议的工作人员类别进行所需的工作
现实生活
与上面的Bossy Big Brother故事相比，代表经常用于以下实际应用：
- 沟通 ：一个班级需要发送一些信息给另一个班级。
- 代码示例1： 将数据从一个视图控制器发送到另一个
- 代码示例2： 将自定义键盘的文本输入发送到文本字段
- 定制 ：一个类想要让另一个类来定制它。
最重要的是，这些类不需要事先知道任何关于对方的事情，除非委托类符合所需的协议。
我强烈建议阅读以下两篇文章。 他们帮助我更好地了解代表们，甚至比文件更好。
- 什么是授权？ – 一个Swift开发人员指南
- 代表如何工作 – Swift开发指南
再一个注意
引用其他不属于自己的类的代表应该使用weak关键字来避免强引用周期。 看到这个答案的更多细节。
我没有更正@MakeAppPie的帖子
首先，当你创建委托协议时，它应该符合Class协议。 就像下面的例子。
protocol ProtocolDelegate: class { func myMethod(controller:ViewController, text:String) }
其次，你的代表应该很弱，以避免保留周期。
class ViewController: UIViewController { weak var delegate: ProtocolDelegate? }
最后，你是安全的，因为你的协议是一个可选的值。 这意味着它的“无”消息将不会发送到这个属性。 它与objC中的respondToselector条件语句类似，但是在这里您将所有内容放在一行中：
if ([self.delegate respondsToSelector:@selector(myMethod:text:)]) { [self.delegate myMethod:self text:@"you Text"]; }
上面你有一个obj-C的例子，下面你有Swift的例子。
delegate?.myMethod(self, text:"your Text")
这是我放在一起的要点 。 我想知道这一点，这有助于提高我的理解。 在Xcode Playground中打开它，看看发生了什么。
protocol YelpRequestDelegate { func getYelpData() -> AnyObject func processYelpData(data: NSData) -> NSData } class YelpAPI { var delegate: YelpRequestDelegate? func getData() { println("data being retrieved...") let data: AnyObject? = delegate?.getYelpData() } func processYelpData(data: NSData) { println("data being processed...") let data = delegate?.processYelpData(data) } } class Controller: YelpRequestDelegate { init() { var yelpAPI = YelpAPI() yelpAPI.delegate = self yelpAPI.getData() } func getYelpData() -> AnyObject { println("getYelpData called") return NSData() } func processYelpData(data: NSData) -> NSData { println("processYelpData called") return NSData() } } var controller = Controller()
代表在SWIFT 2
我用带有两个viewControllers的Delegate的例子来解释。在这种情况下，SecondVC Object将数据发送回第一个View Controller。
具有协议声明的类
protocol getDataDelegate { func getDataFromAnotherVC(temp: String) } import UIKit class SecondVC: UIViewController { var delegateCustom : getDataDelegate? override func viewDidLoad() { super.viewDidLoad() } override func didReceiveMemoryWarning() { super.didReceiveMemoryWarning() // Dispose of any resources that can be recreated. } @IBAction func backToMainVC(sender: AnyObject) { //calling method defined in first View Controller with Object self.delegateCustom?.getDataFromAnotherVC("I am sending data from second controller to first view controller.Its my first delegate example. I am done with custom delegates.") self.navigationController?.popViewControllerAnimated(true) } }
在第一个ViewController协议符合在这里完成：
class ViewController: UIViewController, getDataDelegate
First View Controller（ViewController）中的协议方法定义
func getDataFromAnotherVC(dataString : String) { // dataString from SecondVC lblForData.text = dataString }
在从第一视图控制器（ViewController）
let objectPush = SecondVC() objectPush.delegateCustom = self self.navigationController.pushViewController(objectPush, animated: true)
头等舱：
protocol NetworkServiceDelegate: class { func didCompleteRequest(result: String) } class NetworkService: NSObject { weak var delegate: NetworkServiceDelegate? func fetchDataFromURL(url : String) { delegate?.didCompleteRequest(url) } }
第二课：
class ViewController: UIViewController, NetworkServiceDelegate { let network = NetworkService() override func viewDidLoad() { super.viewDidLoad() network.delegate = self network.fetchDataFromURL("Success!") } func didCompleteRequest(result: String) { print(result) } }
上面的解决方案似乎有点耦合，同时避免在其他控制器中重复使用相同的协议，这就是为什么我使用通用类型擦除更强大的解决方案。
@noreturn public func notImplemented(){ fatalError("not implemented yet") } public protocol DataChangedProtocol: class{ typealias DataType func onChange(t:DataType) } class AbstractDataChangedWrapper<DataType> : DataChangedProtocol{ func onChange(t: DataType) { notImplemented() } } class AnyDataChangedWrapper<T: DataChangedProtocol> : AbstractDataChangedWrapper<T.DataType>{ var base: T init(_ base: T ){ self.base = base } override func onChange(t: T.DataType) { base.onChange(t) } } class AnyDataChangedProtocol<DataType> : DataChangedProtocol{ var base: AbstractDataChangedWrapper<DataType> init<S: DataChangedProtocol where S.DataType == DataType>(_ s: S){ self.base = AnyDataChangedWrapper(s) } func onChange(t: DataType) { base.onChange(t) } } class Source : DataChangedProtocol { func onChange(data: String) { print( "got new value \(data)" ) } } class Target { var delegate: AnyDataChangedProtocol<String>? func reportChange(data:String ){ delegate?.onChange(data) } } var source = Source() var target = Target() target.delegate = AnyDataChangedProtocol(source) target.reportChange("newValue")
输出 ： 获得了新值newValue
简单的例子：
protocol Work: class { func doSomething() } class Manager { weak var delegate: Work? func passAlong() { delegate?.doSomething() } } class Employee: Work { func doSomething() { print("Working on it") } } let manager = Manager() let developer = Employee() manager.delegate = developer manager.passAlong() // PRINTS: Working on it
在迅速4.0
在需要发送一些数据或向其他类提供某些功能的类上创建一个委托
喜欢
protocol GetGameStatus { var score: score { get } func getPlayerDetails() }
之后在向该代表确认的课上
class SnakesAndLadders: GetGameStatus { func getPlayerDetails() { } }
代表是一种设计模式，它允许一个对象在发生特定事件时将消息发送给另一个对象。 设想一个对象A调用一个对象B来执行一个动作。 一旦行动完成，对象A应该知道B已经完成了任务并采取了必要的行动，这可以在代表的帮助下实现！ 这是一个在swift 3中逐步实现代理的教程
教程链接
