下限与紧边之间的区别？(Difference between lower bound and tight bound?)

 Cocoa代表用于完成控制反转并减少对子类化的需求。 为单个对象拥有多个委托是完全可能的，但是当将不同类型的决策委托给不同的对象是有意义的。 一个很好的例子是WebKit的WebView ，其中有五名代表负责资源加载和导航政策的各种领域。 
 
 C＃的事件委托系统，允许对象注册另一个对象以在特定事件发生时通知，最接近Cocoa提供的几个通知API。 您可能会遇到的各种API，从最高级到最低级： 
 
 
 
 NSNotificationCenter 
 
 
 NSDistributedNotificationCenter 
 
 
 CFNotificationCenter 
 
 
 达尔文通知。 
 
 
 所有这些都是类似的，所以我只会考虑你在这种情况下使用的： NSNotificationCenter 。 
 
 观察员，如ClassA和ClassB，向NSNotificationCenter注册他们对通知的兴趣。 他们可以指定兴趣 
 
 
 
 来自特定对象的具有特定名称的通知 
 
 
 来自任何对象的具有特定名称的通知 
 
 
 来自特定对象的通知。 
 
 
 当通知中心发布匹配的通知时，通过调用他们在通知中心注册时提供的方法来通知观察员。 该方法始终具有相同的类型：它不返回任何东西，并接受单个参数， NSNotification对象。 
 
 通常情况下，ClassC会为其头文件中的通知名称声明一个常量，例如， 
 
extern NSString *const ClassCSomethingDidHappenNotification;
 
 有兴趣的观察员，如ClassA和ClassB，可以注册此通知的兴趣： 
 
[[NSNotificationCenter defaultCenter]
  addObserver:self
     selector:@selector(handleSomethingDidHappen:)
         name:ClassCSomethingDidHappenNotification                
       object:aClassCObject];
 
 当注册一个选择器并向观察者添加一个方法来处理回调时，您还可以注册一个运行队列和块，以便在发布匹配的通知时在该队列上执行。 
 
 当与通知相关的事件发生时，ClassC将通知发布到通知中心： 
 
[[NSNotificationCenter defaultCenter]
  postNotificationName:ClassCSomethingDidHappenNotification
                object:self];
 
 然后，通知中心将查看观察者列表，找到与该通知相符的列表，并调用适当的方法。 

Cocoa delegates are used to accomplish inversion of control and lessen the need for subclassing. It's entirely possible to have multiple delegates for a single object, but this is done when it makes sense to delegate different kinds of decisions to different objects. A great example of this is WebView from WebKit, which has five delegates responsible for areas as diverse as resource loading and navigation policy.
 
C#'s event–delegate system, which allows an object to register with another object to be notified when a particular event occurs, is closest to the several notification APIs available from Cocoa. The various APIs you might run across are, from highest level to lowest:
 
 
 
NSNotificationCenter
 
 
NSDistributedNotificationCenter
 
 
CFNotificationCenter
 
 
Darwin notifications.
 
 
All are similar in spirit, so I'll only consider the one you'd use in this case: NSNotificationCenter.
 
Observers, such as ClassA and ClassB, register their interest in notifications with NSNotificationCenter. They can specify an interest in
 
 
 
notifications with a specific name from a specific object
 
 
notifications with a specific name from any object
 
 
notifications from a particular object.
 
 
When a matching notification is posted to the notification center, observers are notified by invoking the method they supplied at registration time with the notification center. The method always has the same type: it returns nothing and accepts a single argument, an NSNotification object.
 
You would generally handle your situation by having ClassC declare a constant for the notification name in its header file, for example,
 
extern NSString *const ClassCSomethingDidHappenNotification;
 
Interested observers, such as ClassA and ClassB, can then register interest in this notification:
 
[[NSNotificationCenter defaultCenter]
  addObserver:self
     selector:@selector(handleSomethingDidHappen:)
         name:ClassCSomethingDidHappenNotification                
       object:aClassCObject];
 
Instead of registering a selector and adding a method to the observer to handle the callback, you can also now register an operation queue and a block to execute on that queue when a matching notification is posted.
 
When the event associated with the notification occurs, ClassC posts the notification to the notification center:
 
[[NSNotificationCenter defaultCenter]
  postNotificationName:ClassCSomethingDidHappenNotification
                object:self];
 
The notification center will then look through the list of observers, find those that match this notification, and invoke the appropriate method.