Observable DataSet Integration

ObservableDataSet is an extension layer on top of POCO DataSet that adds change notification and event-driven behavior. It allows user interfaces (for example, Blazor components) to react automatically when data changes, without manual refresh calls scattered throughout the code.

Why ObservableDataSet exists

The POCO DataSet core model is intentionally simple and predictable. It represents tables, rows, columns, and metadata without introducing UI concerns, event pipelines, or framework-specific behavior. This keeps the core reusable across service layers, serialization, persistence, and non-UI workflows.

ObservableDataSet exists to bridge the gap between a neutral data model and reactive user interfaces. It adds notifications around changes while preserving the core behavior and keeping architectural responsibilities explicit.

Role of ObservableDataSet

• Wraps IDataSet and exposes observable counterparts for tables and rows.
• Raises events when tables or rows are added, removed, or modified.
• Enables reactive patterns where UI updates in response to changes.
• Acts as an integration layer between the POCO DataSet model and UI frameworks (without coupling the core model to any UI technology).

Separation from the core model

Observable integration is additive. The core data model remains event-free and UI-agnostic, and observable components wrap the core rather than replacing it.

• Core (POCO DataSet): data + metadata representation with explicit behavior.
• Observable layer: change notification and eventing for consumers that need reactivity.
• UI: chooses how to subscribe and render; the observable layer does not dictate UI structure.

This separation matters because it keeps POCO DataSet suitable for non-UI scenarios (services, testing, import/export, background processing) while still supporting modern reactive UI workflows when needed.

What becomes observable

The observable layer is concerned with changes that affect user-facing state and UI rendering. Typical observable changes include:

• Row value changes (a cell value changes for a row).
• Row state changes (for example, a row becomes Modified or is marked Deleted).
• Row additions and removals within a table.
• Table additions and removals within a dataset.
• Schema evolution events that affect metadata-driven UI rendering (for example, new columns added).

What the observable layer does not do

To keep responsibilities explicit, ObservableDataSet does not attempt to become a business rules engine, a persistence layer, or an implicit constraint system.

• It does not automatically validate business rules or enforce types at assignment time.
• It does not automatically persist changes or decide when saving should occur.
• It does not introduce implicit relationship propagation between tables.
• It does not hide merge behavior; merges follow the same policy as non-observable merges.

Typical UI scenarios

ObservableDataSet is most valuable when multiple UI components must stay consistent while the user edits data. Common scenarios include:

• Dynamic forms generated from ColumnMetadata (inputs reflect schema and nullability).
• Grids and detail panels bound to the same table and row selection.
• Multiple views of the same data (for example, a list view and a card view) that must update together.
• Client-side editing where changes are later persisted through a changeset roundtrip.
• Merge and refresh workflows where server values arrive and UI updates without manual refresh calls.

Observable merge behavior

The observable layer follows the same merge semantics as the core model. The difference is in mechanics: observable merges must raise change notifications correctly so that UI views remain consistent. This is especially important for merges that add or remove rows, update values, or reconcile post-save results.

Summary

ObservableDataSet adds reactivity on top of POCO DataSet without changing the core model or coupling it to UI technology. The result is a clean separation: the core provides a predictable data model, and the observable layer provides the notifications needed for reactive UIs.

 

Table of Content POCO DataSet Concepts

 

---

Business Process Programming in .Net
© 2004–2026 Laskarzhevsky Software Inc.
Unless otherwise noted, the content of this website is licensed under the Creative Commons Attribution 4.0 International License (CC BY 4.0).
Code examples are provided under the MIT License.
You are free to share and adapt the material provided that appropriate credit is given and any modifications are clearly indicated.
The information provided on this website is for educational purposes only.
The author and publisher make no warranties regarding the completeness or suitability of the information and are not responsible for any damages resulting from its use.