Overview

The Beep Data Management Engine is a comprehensive, multi-target framework that provides powerful data access patterns, unit of work implementations, change tracking, and enterprise-level data management capabilities for modern .NET applications.

Built with extensibility in mind, the engine supports a wide variety of data sources from traditional relational databases to modern vector databases, file formats, and custom data providers through its plugin-based architecture.

πŸš€ Quick Start

Get started with the Beep Data Management Engine in just a few minutes

Key Features

πŸ—„οΈ Multi-DataSource Support

Connect to SQL Server, SQLite, MySQL, PostgreSQL, Excel, CSV, and vector databases

πŸ”„ Unit of Work Pattern

Advanced implementation with change tracking, validation, and transaction management

πŸ“Š Change Tracking

Automatic monitoring of entity changes with undo/redo capabilities and audit trails

⚑ Async Operations

Full async/await support for all CRUD operations with progress reporting

πŸ”’ Enterprise Security

Built-in security features, connection pooling, and enterprise authentication

πŸ”— Relationship Management

Sophisticated parent-child relationship handling with cascade operations

Engine Statistics

4 .NET Versions Supported
39 Data Sources
50+ Core Classes
15+ Manager Classes

Installation

Install the package using one of the following methods:

Package Manager Console

Install-Package TheTechIdea.Beep.DataManagementEngine

.NET CLI

dotnet add package TheTechIdea.Beep.DataManagementEngine

Package Reference

<PackageReference Include="TheTechIdea.Beep.DataManagementEngine" Version="2.0.32" />

Basic Usage

Here's a simple example to get you started:

Creating Your First UnitOfWork

using Autofac;
using TheTechIdea.Beep;
using TheTechIdea.Beep.ConfigUtil;
using TheTechIdea.Beep.Logger;
using TheTechIdea.Util;

// Initialize DME Editor using Autofac
var builder = new ContainerBuilder();
builder.RegisterType<DMEEditor>().As<IDMEEditor>().SingleInstance();
builder.RegisterType<ConfigEditor>().As<IConfigEditor>().SingleInstance();
builder.RegisterType<DMLogger>().As<IDMLogger>().SingleInstance();
builder.RegisterType<Util>().As<IUtil>().SingleInstance();
builder.RegisterType<ErrorsInfo>().As<IErrorsInfo>().SingleInstance();
builder.RegisterType<JsonLoader>().As<IJsonLoader>().SingleInstance();
builder.RegisterType<AssemblyHandler>().As<IAssemblyHandler>().SingleInstance();

var container = builder.Build();
var dmeEditor = container.Resolve<IDMEEditor>();

// Initialize required configurations for IDataSource support
InitializeBeepDefaults(dmeEditor);

// Create a data connection
ConnectionProperties connectionProps = new ConnectionProperties
{
    ConnectionName = "MyDatabase",
    DatabaseType = DataSourceType.SqlServer,
    ConnectionString = "Server=localhost;Database=MyDB;Integrated Security=true;"
};

// Add connection to configuration
dmeEditor.ConfigEditor.AddDataConnection(connectionProps);

// Get data source and open connection
IDataSource dataSource = dmeEditor.GetDataSource("MyDatabase");
dataSource.Openconnection();

// Create UnitOfWork for your entity
var unitOfWork = new UnitofWork<Customer>(
    dmeEditor, 
    "MyDatabase", 
    "Customers", 
    "CustomerId"
);

// Load data
await unitOfWork.Get();

// Work with your data
unitOfWork.New(); // Create new customer
var newCustomer = unitOfWork.CurrentItem;
newCustomer.Name = "John Doe";
newCustomer.Email = "john@example.com";

// Save changes
await unitOfWork.Commit();

Supported Data Sources

The Beep Data Management Engine supports a wide variety of data sources:

🏒 Enterprise Databases

SQL Server, PostgreSQL, MySQL, DB2, Firebird

πŸ“± Embedded Databases

SQLite, LiteDB, DuckDB

πŸ“„ File Formats

Excel, CSV, JSON, XML

🧠 Vector Databases

ChromaDB, Pinecone, Milvus

🌐 Web APIs

REST APIs, GraphQL, OAuth2, and custom web services

☁️ Cloud Services

Azure SQL, AWS RDS, Google Cloud SQL

πŸ”§ Custom Sources

Extensible architecture for any data source

Documentation Sections

πŸš€ Getting Started

Registration, setup, and your first data operations

Get Started

πŸ”„ Unit of Work

Master the powerful Unit of Work pattern implementation

Learn UoW

πŸ—„οΈ Multi-DataSource

Handle complex scenarios with multiple data sources

Multi-Source

WebAPIDataSource

Complete REST API integration with authentication, caching, and circuit breaker

Web API Guide

FileManager Reader Host

Discover available file readers, switch by type/implementation/reader ID, and support multiple CSV readers safely.

File Reader Guide

DataViewDataSource

Federated view datasource reference with current DataView signatures and execution modes.

DataView Guide

Caching API

Current ICacheProvider contract and CacheManager patterns (including stale-while-revalidate APIs).

Caching Guide

Proxy DataSource

Current proxy failover, policy, and cluster interfaces: IProxyDataSource and IProxyCluster.

Proxy Guide

DistributedDataSource

Shard-aware distributed routing, replicated/scatter execution, and Phase 14 capacity controls with backpressure examples.

Distributed Guide

Rules Engine & Parsers

One-page reference for rule runtime execution and parser contracts with verified signatures.

Rules Guide

Services Registration

Registration API and lifetime patterns for desktop, web, and blazor startup flows.

Services Guide

Helpers Runtime

One-page reference for connection helpers, RDBMS helpers, and universal datasource helper factory/delegation surfaces.

Helpers Guide

AssemblyHandler Loading & NuGet

Signature-verified guide for DLL loading, NuGet package management, driver tracking, and loader extension authoring.

AssemblyHandler Guide

ETL Engine: Pipeline

Pipeline execution internals including run/resume, checkpoints, lineage flush, and manager-level run persistence.

Pipeline Internals

ETL Engine: Scheduling

Scheduler host internals for queue isolation, dispatch governance, dependency handling, watermark windows, and backfills.

Scheduling Internals

ETL Engine: Observability

Run logs, lineage, metrics, alert evaluation, dashboard query APIs, and audit-integrity flow.

Observability Internals

Technical Folder Guides

Hand-written module guides for Editor, Helpers, ConfigUtil, WebAPI, Caching, and JSON internals

View Guides

βš™οΈ Editor Classes

Core engine components: DMEEditor, ETL Editor, Import/Sync Managers, and mapping utilities

Editor Classes

πŸ“š Code Examples

Practical samples plus section-split pages for editor classes and runtime surfaces

Examples

⭐ Best Practices

Expert tips, performance optimization, and guidelines

Best Practices

πŸ“‹ API Reference

Complete API documentation for all components

API Reference

Latest Updates

May 2026

Documentation Expansion: 55 comprehensive HTML pages covering all 59 component skills. New: RDBMS Helpers Reference, Datasource Types Reference, ProxyCluster, BeepService, EnvironmentsService, Workflow Engine, Connections & Properties, ObservableBindingList, InMemory & LocalDB DataSources, Composite & Distributed DataSources, and Setup Framework documentation.

πŸ“… December 2024 - v2.0.32

.NET 9 Support: Full compatibility with .NET 9 and latest performance optimizations

Complete Documentation Index

Getting Started

PageDescription
BeepServiceCentral bootstrap service for all BeepDM components
Service RegistrationDesktop, Web API, and Blazor DI setup
Services LifetimesDI scoping and lifetime patterns
Environment ServiceCross-platform folder management
Setup FrameworkWizard-based automated initialization

Core Concepts

PageDescription
Connections & PropertiesIDataConnection, ConnectionProperties, drivers
ObservableBindingListEnhanced binding list with change tracking
UnitOfWork PatternCRUD, tracking, validation, transactions
UnitOfWork Deep DiveAdvanced UoW features
Multi-DataSource UoWCross-datasource operations
UnitOfWork FactoryRuntime type creation
UnitOfWork WrapperLate-bound access wrapper

Data Management

PageDescription
Datasource Types Reference30+ datasource types with capability matrix
WebAPI DataSourceREST API connectivity
DataView DataSourceFederated views across sources
Composite DataSourceLayered datasource stacking
InMemory DataSourceTransient in-memory storage
LocalDB DataSourceFile-based local database operations
Caching APICacheManager and providers
Proxy DataSourceFailover and circuit breaker
ProxyClusterClustered proxy with routing
Distributed DataSourceSharded distributed data
FileManager DataSourceFile-based data source management
JSON DataSourceJSON document management

Editor Classes

PageDescription
DMEEditorMain orchestrator
ConfigEditorConfiguration management
ETL EditorExtract, Transform, Load operations
DataImportManagerData import orchestration
DataSyncManagerData synchronization
MappingManagerField mapping (8 partials)
DefaultsManagerDefault value management
FormsManagerOracle Forms-style UI (30+ partials)
MigrationManagerSchema migration

Advanced Topics

PageDescription
Rules Engine & ParsersBusiness rules and parsers
Workflow EngineMulti-step process execution
BeepSync ManagerCDC and conflict resolution
ETL & Workflow EngineLegacy ETL integration
ETL Engine: PipelineModern pipeline execution
ETL Engine: SchedulingCron scheduling and backfills
ETL Engine: ObservabilityMetrics, alerts, lineage

Tools & Reference

PageDescription
AssemblyHandlerDLL loading, NuGet, driver tracking
Helpers Runtime ReferenceConnection and helper patterns
RDBMS Helpers ReferenceSQL generation, DDL, DML, features
Creating Custom DataSourcesPlugin development guide
Technical Folder GuidesModule-level structure reference
Advanced ToolsRoslyn, reporting, extensions

Examples & Best Practices

PageDescription
Code ExamplesOverview of all examples
Examples: Editor ClassesDMEEditor, ETL, Import, Sync, Forms
Examples: Runtime SurfacesUoW, DataView, Caching, Proxy, Rules
Best PracticesPerformance, security, patterns
API ReferenceComplete API documentation
πŸ“… November 2024

Enhanced Multi-DataSource UnitOfWork: Improved relationship management and cross-datasource operations

πŸ“… October 2024

Vector Database Support: Added support for ChromaDB, Pinecone, and Milvus vector databases

🛠️ Data Management Editor Classes

The Beep Data Management Engine includes a comprehensive suite of editor classes that provide specialized functionality for different aspects of data management:

πŸŽ›οΈ DMEEditor

The core orchestrator that manages all data operations, connections, and workflows

DMEEditor

πŸ”„ ETL Editor

Extract, Transform, Load operations with advanced data processing capabilities

ETL Editor

πŸ“₯ Data Import Manager

Sophisticated data import operations with validation and transformation

Import Manager

πŸ—ΊοΈ Mapping Manager

Field and entity mapping between different data sources and formats

Mapping Manager

βš™οΈ Defaults Manager

Configuration and default value management for data operations

Defaults Manager

πŸ”„ Data Sync Manager

Real-time data synchronization between multiple systems and databases

Sync Manager

βš™οΈ ConfigEditor

Centralized configuration management with specialized manager architecture

ConfigEditor
βœ… Editor Classes Features
  • Unified Architecture: All editors work seamlessly together
  • Extensible Design: Easy to extend and customize for specific needs
  • Enterprise Ready: Built for large-scale data operations
  • Event-Driven: Rich event system for monitoring and integration
  • Async Support: Full async/await support for all operations
  • Error Handling: Comprehensive error tracking and recovery

πŸ”§ Helper Classes & Utilities

BeepDM includes a comprehensive collection of helper classes that extend core functionality and simplify common data management tasks:

🔌 ConnectionHelper

39 predefined data source configurations including traditional databases, NoSQL, file formats, and vector databases

🧩 DataTypeFieldMappingHelper

Comprehensive data type mapping between .NET types and database-specific types

πŸ§ͺ TestConnectionHelper

Async connection testing and validation utilities for all supported data sources

🧠 VectorDatabaseHelper

Specialized support for vector databases like ChromaDB, Pinecone, Qdrant, and Milvus

πŸ“ FileHelper & FileConnectionHelper

File operations, path resolution, and file-based data source utilities

πŸ—οΈ RDBMSHelper

SQL generation and relational database-specific operation helpers

🔀 StringExtensions

Extended string manipulation and processing utilities

🔌 ConnectionHelper - Comprehensive Data Source Support

ConnectionHelper provides 39 pre-configured data source setups covering enterprise databases, NoSQL systems, file formats, and cutting-edge vector databases. Each configuration includes proper connection strings, driver mappings, and database-specific settings.

🏒 Enterprise RDBMS (8 systems)

SQL Server, PostgreSQL, MySQL, DB2, Firebird, VistaDB, SQL Compact, SQLite

Full ADO.NET support with connection pooling, transactions, and advanced features

πŸ“± Embedded & Lightweight (4 systems)

SQLite, LiteDB, DuckDB, Realm

Perfect for mobile apps, desktop applications, and edge computing scenarios

πŸ—„οΈ NoSQL & Document (8 systems)

MongoDB, CouchDB, Couchbase, Firebase, RavenDB, Cassandra, Elasticsearch

Modern document, graph, and wide-column databases for scalable applications

πŸ“„ File Formats (5 formats)

CSV, JSON, Excel (XLS/XLSX), Text Files, DataView

Direct file processing with intelligent schema detection and type mapping

🧠 Vector Databases (9 systems)

ChromaDB, Pinecone, Qdrant, Milvus, Weaviate, Redis Vector, Zilliz, Vespa, ShapVector

AI and machine learning ready vector storage with similarity search capabilities

🌐 Streaming & Cloud (5 systems)

Redis, Kafka, Hadoop, Snowflake, OPC

Real-time data streams, big data platforms, and cloud analytics solutions

Getting All Available Configurations
// Get all 39 predefined connection configurations
var allConfigs = ConnectionHelper.GetAllConnectionConfigs();

// Filter by category
var vectorDatabases = allConfigs.Where(c => c.DatasourceCategory == DatasourceCategory.VectorDB).ToList();
var rdbmsSystems = allConfigs.Where(c => c.DatasourceCategory == DatasourceCategory.RDBMS).ToList();
var fileSources = allConfigs.Where(c => c.DatasourceCategory == DatasourceCategory.FILE).ToList();

Console.WriteLine($"Found {vectorDatabases.Count} vector databases");
Console.WriteLine($"Found {rdbmsSystems.Count} RDBMS systems");
Console.WriteLine($"Found {fileSources.Count} file formats");

                        // Add all configurations to your DME setup
                        foreach (var config in allConfigs)
{
    if (!dmeEditor.ConfigEditor.DataDriversClasses.Any(d => d.GuidID == config.GuidID))
    {
        dmeEditor.ConfigEditor.DataDriversClasses.Add(config);
    }
}
βœ… ConnectionHelper Key Features
  • 39 Data Sources: Comprehensive coverage from traditional to cutting-edge systems
  • Production Ready: All configurations tested and optimized for enterprise use
  • Vector Database Support: 9 vector databases for AI/ML applications
  • Connection String Management: Parameterized templates with automatic substitution
  • Security Features: Built-in connection string masking and validation
  • File Format Intelligence: Automatic schema detection and type mapping
πŸ’‘ ConnectionHelper Utilities
  • LinkConnection2Drivers(): Automatically links connections to appropriate drivers
  • ReplaceValueFromConnectionString(): Dynamic parameter substitution in connection strings
  • IsConnectionStringValid(): Validates connection strings for different database types
  • SecureConnectionString(): Masks sensitive information like passwords and API keys

πŸ—οΈ Core Infrastructure Classes

Essential infrastructure components that provide foundational services across the engine:

πŸ”§ AssemblyHandler

Dynamic assembly loading, plugin management, and runtime type resolution

πŸ“ DMLogger

Comprehensive logging system with multiple output targets and log levels

πŸ“„ JsonLoader

High-performance JSON serialization and configuration file management

πŸ”§ Util

Common utility functions, string processing, and system operations

❌ ErrorsInfo

Centralized error tracking, exception handling, and diagnostic information

πŸ“Š ObservableBindingList

Enhanced data binding collections with change notification and tracking

πŸ”„ UnitOfWork Ecosystem

Complete suite of classes supporting the Unit of Work pattern implementation:

🏭 UnitOfWorkFactory

Dynamic creation of strongly-typed and generic UnitOfWork instances

API Details

πŸ“¦ UnitOfWorkWrapper

Simplified API wrapper for easier UnitOfWork integration

Deep Dive

πŸŽ›οΈ FormsManager

Runtime orchestration for multiple UnitOfWork blocks, cross-entity operations, navigation, validation, and messaging

Forms Runtime

πŸ—„οΈ MultiDataSourceUnitOfWork

Advanced UnitOfWork supporting operations across multiple data sources

Multi-Source

βœ… EntityDataMoveValidator

Validation engine for entity operations and data integrity

πŸ“‹ EntityTrackingData

Comprehensive change tracking and audit trail management

πŸ”„ ETL & Data Processing

Comprehensive Extract, Transform, Load capabilities and data processing tools:

βš™οΈ ETLEditor

Main ETL orchestration engine for data migration and transformation

ETL Editor

πŸ“‹ ETLScriptManager

ETL script generation, execution, and management

πŸ”„ ETLDataCopier

High-performance data copying between different data sources

🏭 ETLEntityProcessor

Entity-level processing for complex data transformations

βœ… ETLValidator

Data validation and quality checks during ETL operations

πŸ“Š BatchExtensions

Batch processing extensions for large-scale data operations

πŸ“ File Management System

Comprehensive file processing and data source capabilities:

πŸ“Š CSVDataSource

Full-featured CSV file data source with advanced parsing

πŸ” CSVAnalyser

Intelligent CSV structure analysis and schema detection

🧩 CSVTypeMapper

Automatic data type mapping and conversion for CSV data

πŸ“„ TextFieldParser

Advanced text field parsing with delimiter detection

πŸ“ˆ ExcelSheetDefinition

Excel worksheet structure definition and metadata

πŸ“ ProjectFolder

Project-based file organization and management

βš™οΈ Workflow & Rules Engine

Powerful workflow orchestration and business rules processing:

πŸ”§ WorkFlowEditor

Visual workflow design and execution engine

Workflow Engine

🏭 RuleParserFactory

Business rules parsing and expression evaluation

πŸ”„ SyncManager

Real-time data synchronization and conflict resolution

πŸ“Š ReportDataManager

Report data aggregation and processing engine

🏒 AppManager

Application lifecycle management and component coordination

πŸ“‹ AppTemplate

Application templates and scaffolding system

πŸŽ›οΈ Specialized Manager Classes

ConfigEditor's specialized managers providing focused functionality:

πŸ“ ConfigPathManager

Configuration path and directory structure management

πŸ”— DataConnectionManager

Data source connection lifecycle and configuration management

πŸ“ QueryManager

SQL query repository and database-specific query generation

πŸ—ΊοΈ EntityMappingManager

Entity structure and field mapping configuration management

🧩 ComponentConfigManager

Component, driver, and plugin configuration management

🏭 CantainerManager

Dependency injection container management and service registration

Overview

The Beep Data Management Engine follows a modular, layered architecture designed for scalability, maintainability, and extensibility:

πŸŽ›οΈ Core Layer

DMEEditor, ConfigEditor, UnitOfWork Ecosystem
Central orchestration and configuration management

πŸ”„ Processing Layer

ETL Engine, Workflow Engine, Sync Managers
Data transformation and business process automation

πŸ—„οΈ Data Access Layer

Data Sources, Connection Management, Query Engine
Unified access to diverse data storage systems

πŸ”§ Infrastructure Layer

Logging, Error Handling, Assembly Management
Cross-cutting concerns and system services

πŸ—οΈ Helper Layer

Utilities, Extensions, Type Mapping
Reusable components and development accelerators

πŸ“¦ Container Layer

Dependency Injection, Service Management
Service composition and lifecycle management

🎯 Design Principles
  • Separation of Concerns: Each layer has distinct responsibilities
  • Dependency Injection: Loose coupling through container management
  • Extensibility: Plugin architecture for custom components
  • Configuration-Driven: Behavior controlled through configuration
  • Multi-Target Support: .NET 6, 7, 8, and 9 compatibility
  • Enterprise Ready: Scalable for production workloads