OnPropertyChan

OnPropertyChan is a design pattern used to notify observers about changes to a property through a channel-based mechanism. It is applicable in programming environments that provide asynchronous channels or queues for inter-component communication, and it is agnostic to a specific language or framework.

The core idea is that an object exposes a property along with a channel that streams updates whenever the property's value changes. When the property's setter detects a change, the internal state is updated and the new value is published to the channel. Subscribers read from the channel to react to updates. The channel can be buffered or unbuffered, affecting decoupling and backpressure between the producer of updates and the consumers.

Key design considerations include ensuring thread-safety for concurrent access, choosing between buffered and unbuffered channels, and handling the lifecycle of the channel (for example, closing or disposing it when the object is destroyed). It is common to perform equality checks to avoid emitting redundant updates, and to provide scheduling or cancellation mechanisms so that subscribers can manage their own resources.

OnPropertyChan is closely related to the observer pattern and to event-based notifications, but it uses channels to convey property changes as an asynchronous data stream. This can enable composition with other reactive streams, filtering, transformations, and backpressure-aware processing.

Common use cases include user interface binding where UI components react to data changes, real-time dashboards, and model-layer updates in asynchronous architectures. It is important to document ownership and lifecycle boundaries to prevent memory leaks and to clarify how cancellations and channel closures affect subscribers.

Example (pseudo-code):

class ObservableValue<T> {

private var _value: T

let chan: Channel<T> // provides a stream of updates

init(_ initial: T) { _value = initial; chan = Channel<T>(buffered: true) }

func set(_ newValue: T) {

if _value != newValue {

_value = newValue

chan.send(_value)

}

}

func get() -> T { return _value }

}