# NotificationCenter.AsyncMessage A protocol for creating types that you can post to a notification center, which posts them to an arbitrary isolation. ``` protocol AsyncMessage : Sendable ``` ## Overview You post types conforming to `AsyncMessage` to a notification center using `post(_:subject:)` and observe them with `addObserver(of:for:using:)`. The notification center delivers `AsyncMessage` types asynchronously when posted. Asynchronous delivery isn’t suitable for messages with time-critical deliveries, such as a message that must have its observers called before a certain action takes place. For types that post on the main actor, use [`NotificationCenter.MainActorMessage`](/documentation/Foundation/NotificationCenter/MainActorMessage). Each `AsyncMessage` is associated with a specific `Subject` type. For example, an `AsyncMessage` associated with the type `Event` could use the following declaration: ```swift struct EventDidStart: NotificationCenter.AsyncMessage { typealias Subject = Event } ``` `AsyncMessage` can use an optional [`NotificationCenter.MessageIdentifier`](/documentation/Foundation/NotificationCenter/MessageIdentifier) type for context-aware observer registration: ```swift extension NotificationCenter.MessageIdentifier where Self == NotificationCenter.BaseMessageIdentifier { static var didStart: Self { .init() } } ``` With this identifier, observers can receive information about a specific instance by registering for this message with a [`NotificationCenter`](/documentation/Foundation/NotificationCenter): ```swift let observerToken = NotificationCenter.default.addObserver(of: importantEvent, for: .didStart) ``` Or an observer can receive information about any instance with: ```swift let observerToken = NotificationCenter.default.addObserver(of: Event.self, for: .didStart) ``` The notification center ties observation the lifetime of the returned [`NotificationCenter.ObservationToken`](/documentation/Foundation/NotificationCenter/ObservationToken) and automatically de-registers the observer if the token goes out of scope. You can also remove observation explicitly: ```swift NotificationCenter.default.removeObserver(observerToken) ``` ### Notification Interoperability `AsyncMessage` includes optional interoperability with [`Notification`](/documentation/Foundation/Notification), enabling posters and observers of both types to pass information. It does this by offering a [`makeMessage(_:)`](/documentation/Foundation/NotificationCenter/AsyncMessage/makeMessage(_:)) method that collects values from a [`Notification`](/documentation/Foundation/Notification)‘s [`userInfo`](/documentation/Foundation/Notification/userInfo) and populates properties on a new message. In the other direction, a [`makeNotification(_:)`](/documentation/Foundation/NotificationCenter/AsyncMessage/makeNotification(_:)) method collects the message’s defined properties and loads them into a new notification’s [`userInfo`](/documentation/Foundation/Notification/userInfo) dictionary. For example, if there exists a [`Notification`](/documentation/Foundation/Notification) posted on an arbitrary isolation identified by the [`Notification.Name`](/documentation/Foundation/Notification/Name-swift.typealias) `"eventDidFinish"` with a [`userInfo`](/documentation/Foundation/Notification/userInfo) dictionary containing the key `"duration"` as an [`NSNumber`](/documentation/Foundation/NSNumber), an app could post and observe the notification with the following [`NotificationCenter.AsyncMessage`](/documentation/Foundation/NotificationCenter/AsyncMessage): ```swift struct EventDidFinish: NotificationCenter.AsyncMessage { typealias Subject = Event static var name: Notification.Name { Notification.Name("eventDidFinish") } var duration: Int static func makeNotification(_ message: Self) -> Notification { return Notification(name: Self.name, userInfo: ["duration": NSNumber(message.duration)]) } static func makeMessage(_ notification: Notification) -> Self? { guard let userInfo = notification.userInfo, let duration = userInfo["duration"] as? Int else { return nil } return Self(duration: duration) } } ``` With this definition, an observer for this `AsyncMessage` type receives information even if the poster used the [`Notification`](/documentation/Foundation/Notification) equivalent, and vice versa. ## Topics ### Declaring the message name and subject [`name`](/documentation/Foundation/NotificationCenter/AsyncMessage/name) A optional name corresponding to this type, used to interoperate with notification posters and observers. [`Subject`](/documentation/Foundation/NotificationCenter/AsyncMessage/Subject) A type which you can optionally post and observe along with this `AsyncMessage`. ### Converting between messages and notifications [`makeMessage(_:)`](/documentation/Foundation/NotificationCenter/AsyncMessage/makeMessage(_:)) Converts a posted notification into this asynchronous message type for any observers. [`makeNotification(_:)`](/documentation/Foundation/NotificationCenter/AsyncMessage/makeNotification(_:)) Converts a posted asynchronous message into a notification for any observers. --- Copyright © 2026 Apple Inc. All rights reserved. | [Terms of Use](https://www.apple.com/legal/internet-services/terms/site.html) | [Privacy Policy](https://www.apple.com/privacy/privacy-policy)