How do you create custom notifications in Swift 3?

10 Solutions Collect From Internet About “How do you create custom notifications in Swift 3?”

You could also use a protocol for this

protocol NotificationName {
    var name: Notification.Name { get }

extension RawRepresentable where RawValue == String, Self: NotificationName {
    var name: Notification.Name {
        get {
            return Notification.Name(self.rawValue)

And then define your notification names as an enum anywhere you want. For example:

class MyClass {
    enum Notifications: String, NotificationName {
        case myNotification

And use it like, object: nil)

This way the notification names will be decoupled from the Foundation Notification.Name. And you will only have to modify your protocol in case the implementation for Notification.Name changes.

There is a cleaner (I think) way to achieve it

extension Notification.Name {

    static let onSelectedSkin = Notification.Name("on-sekected-skin")

And then you can use it like this .onSelectedSkin, object: selectedSkin) is defined as:

public func post(name aName: NSNotification.Name, object anObject: AnyObject?)

In Objective-C, the notification name is a plain NSString. In Swift, it’s defined as NSNotification.Name.

NSNotification.Name is defined as:

public struct Name : RawRepresentable, Equatable, Hashable, Comparable {
    public init(_ rawValue: String)
    public init(rawValue: String)

This is kind of weird, since I would expect it to be an Enum, and not some custom struct with seemingly no more benefit.

There is a typealias in Notification for NSNotification.Name:

public typealias Name = NSNotification.Name

The confusing part is that both Notification and NSNotification exist in Swift

So in order to define your own custom notification, do somethine like:

public class MyClass {
    static let myNotification = Notification.Name("myNotification")

Then to call it:

NotificationCenter.default().post(name: MyClass.myNotification, object: self)

Easier way:

let name:NSNotification.Name = NSNotification.Name("notificationName") name, object: nil)

You can add a custom initializer to NSNotification.Name

extension NSNotification.Name {
    enum Notifications: String {
        case foo, bar
    init(_ value: Notifications) {
        self = NSNotification.Name(value.rawValue)

Usage: Notification.Name(.foo), object: nil)
NSNotification.Name(rawValue: "myNotificationName")

This is just reference

// Add observer:
    selector: #selector(notificationCallback),
    name: MyClass.myNotification,
    object: nil)

    // Post notification:
    let userInfo = ["foo": 1, "bar": "baz"] as [String: Any] MyClass.myNotification,
        object: nil,
        userInfo: userInfo)

I did my own implementation mixing things from there and there, and find this as the most convenient. Sharing for who any that might be interested:

public extension Notification {
    public class MyApp {
        public static let Something = Notification.Name("Notification.MyApp.Something")

class ViewController: UIViewController {
    override func viewDidLoad() {
                                               selector: #selector(self.onSomethingChange(notification:)),
                                               name: Notification.MyApp.Something,
                                               object: nil)

    deinit {

    @IBAction func btnTapped(_ sender: UIButton) { Notification.MyApp.Something,
                                      object: self,
                                    userInfo: [Notification.MyApp.Something:"foo"])

    func onSomethingChange(notification:NSNotification) {
        print("notification received")
        let userInfo = notification.userInfo!
        let key = Notification.MyApp.Something 
        let something = userInfo[key]! as! String //Yes, this works :)

The advantage of using enums is that we get the compiler to check that the name is correct. Reduces potential issues and makes refactoring easier.

For those who like using enums instead of quoted strings for notification names, this code does the trick:

enum MyNotification: String {
    case somethingHappened
    case somethingElseHappened
    case anotherNotification
    case oneMore

extension NotificationCenter {
    func add(observer: Any, selector: Selector, 
             notification: MyNotification, object: Any? = nil) {
        addObserver(observer, selector: selector, 
                    name: Notification.Name(notification.rawValue),
                    object: object)
    func post(notification: MyNotification, 
              object: Any? = nil, userInfo: [AnyHashable: Any]? = nil) {
        post(name: NSNotification.Name(rawValue: notification.rawValue), 
             object: object, userInfo: userInfo)

Then you can use it like this:

Though unrelated to the question, the same can be done with storyboard segues, to avoid typing quoted strings:

enum StoryboardSegue: String {
    case toHere
    case toThere
    case unwindToX

extension UIViewController {
    func perform(segue: StoryboardSegue) {
        performSegue(withIdentifier: segue.rawValue, sender: self)

Then, on your view controller, call it like:

perform(segue: .unwindToX)

if you use string-only custom notifications, there’s no reason to extend any classes but String

    extension String {
        var notificationName : Notification.Name{
            return Notification.Name.init(self)