Architecture and Technologies
Technology Foundation
The RecroGrid Framework is built on an integrated technology environment optimized for developing professional business applications. Its architecture is based on the .NET ecosystem and provides a unified, efficient, and stable development platform through .NET, C#, ASP.NET Core, Entity Framework, Blazor, Bootstrap, and Visual Studio.
These technologies work together across the complete solution. ASP.NET Core provides the server-side application and API foundation, Blazor provides the interactive user interface environment, Entity Framework integrates the domain model with relational data access, and Bootstrap provides the default presentation foundation. C# provides a consistent language environment across client-side and server-side development, while Visual Studio supports building, debugging, extending, and maintaining the complete solution within a familiar professional .NET development environment.
The RecroGrid Framework uses this technology stack with minimal external dependencies, supporting straightforward integration, long-term maintainability, predictable upgrades, and stable development projects.
The framework supports multiple application models on the same integrated technology foundation. For new applications, the recommended model is the Server-side Application, where a browser-facing Blazor host application works together with a separate backend API application. A standalone Blazor WebAssembly Application is also supported for solutions that use direct browser-to-API communication. See Application Models for the detailed deployment, development, and request-flow views.
Domain Model-Based Component Structure
The RecroGrid Framework uses a domain model-based component structure where business entities defined by the developer determine the application's data structures and provide a shared foundation across multiple application layers. The domain model forms the unified basis for database integration, business logic, server-side services, the client runtime, and the interactive user interface.
Entity Framework maps these models to the relational database layer and integrates them with querying, persistence, transactions, and standard schema management. Based on the same domain definitions and framework metadata, the RecroGrid Framework assembles integrated application capabilities at runtime, including grids, forms, API services, validation, data handling, and client-server communication.
These runtime-provided capabilities are immediately usable as a professional application foundation and remain deeply customizable at code level. Developers can extend or replace application-specific behavior through standard C#, .NET, ASP.NET Core, Blazor, and Entity Framework techniques while preserving the shared framework architecture.
Integrated Framework Services
The RecroGrid Framework provides a broad set of integrated services for professional business applications. These services operate as coordinated parts of the same runtime and can be configured or extended according to application requirements.
The integrated service layer includes:
- Authentication integration, including OpenID Connect based application flows.
- Authorization and permission handling.
- Detailed auditing and change tracking capabilities.
- Domain-aligned API services and endpoints used by the RecroGrid Framework communication layer.
- Validation, request handling, serialization, and framework-level error processing.
- Client and server runtime services that coordinate data operations and user-interface behavior.
The framework publishes the API services required by its client-server communication and integrates them with the same domain model, authorization rules, validation, and business operations used by the server runtime. Authentication and API access are connected to the selected application model; see Application Models and the Authentication configuration for the corresponding flows.
Unified Client-Server Architecture
One of the central architectural characteristics of the RecroGrid Framework is the tight integration of client-side and server-side application behavior. The client runtime, communication layer, server runtime, business logic, and Entity Framework integration are designed to operate together on shared domain definitions and framework contracts.
The general runtime architecture can be represented as follows:
flowchart TD
ui[Blazor UI]
client[RecroGrid Framework client runtime]
communication[Integrated API communication]
server[RecroGrid Framework server runtime]
business[Business logic and Entity Framework]
database[(Database)]
ui --> client
client --> communication
communication --> server
server --> business
business --> database
Shared domain types and framework contracts keep data structures and behavior aligned across the application and provide strongly typed communication between client and server layers. Business rules, validations, authorization-aware processing, serialization, communication, and framework error handling participate in the same integrated operation model.
The main RecroGrid Framework server runtime, most business logic, Entity Framework integration, and database operations are hosted in the backend application of the modern Blazor-based models. Where application design benefits from it, selected .NET logic such as validation rules, calculations, shared domain types, or framework contracts can also be used across client-side and server-side code.
The browser-facing boundary can be implemented through different application models while the underlying RecroGrid Framework client-server integration remains based on the same framework concepts.
Recommended Server-side Application
For new applications, the recommended model uses a browser-facing Blazor host application together with a separate backend API application. During development, the Blazor application contains a host/server part and an interactive client part that together form the browser-facing application and are deployed as one application unit.
flowchart TD
browser[Browser]
host[Blazor host application]
api[Backend API application]
database[(Database)]
browser --> host
host --> api
api --> database
The host/server part owns the application origin, OpenID Connect sign-in, the authenticated session, SessionAuth endpoints, and the API proxy. The interactive Blazor client provides the UI, route structure, and RecroGrid Framework client integration. SessionAuth keeps the interactive client aligned with the host-managed authenticated session, while client API requests return to the host origin and are forwarded through the API proxy.
The separate backend API application hosts the RecroGrid Framework server runtime, most business logic, entity operations, Entity Framework integration, and database access. This provides an integrated browser-facing application with centralized authentication and API access while preserving a clear backend application boundary.
See Server-side Application for the detailed responsibilities of each application part.
Standalone Blazor WebAssembly Application
The RecroGrid Framework also supports a standalone Blazor WebAssembly application model. In this model, the browser-hosted Blazor WebAssembly client contains the UI, OpenID Connect client behavior, bearer-token handling, and direct API client integration, while the RecroGrid Framework server runtime remains in a separate backend API application.
flowchart TD
browser[Browser / Blazor WebAssembly application]
api[Backend API application]
database[(Database)]
browser --> api
api --> database
This model provides a direct browser-to-API application structure and is suitable for standalone and existing Blazor WebAssembly solutions.
For the detailed comparison of the supported application models, see Application Models.
Client Architecture and UI Abstraction
The RecroGrid Framework client architecture uses multiple abstraction layers so that the client runtime, Blazor integration, and concrete presentation technology remain clearly separated while operating as one integrated client-side framework.
The client-side architecture is composed of three interdependent layers:
- Client Logic and Communication Layer: Technology-agnostic base services, framework contracts, state handling, and API communication.
- Blazor Abstraction Layer: Blazor-specific components and services required by the RecroGrid Framework client runtime.
- Presentation Layer: The concrete UI implementation using the default Bootstrap integration or other supported component libraries.
This client architecture is shared by the modern Blazor-based application models. The application model determines how the browser-facing application is hosted, authenticated, and connected to the backend API, while the RecroGrid Framework client runtime continues to use the same layered abstractions.
The RecroGrid Framework provides integration packages for third-party component libraries including DevExpress, Radzen, Syncfusion, and Telerik. These packages connect the corresponding presentation components to the common RecroGrid Framework client abstraction so they participate in the same framework behavior and client-server integration.
The same abstraction architecture supports fully custom presentation implementations. Application-specific Blazor components and UI layers can be integrated while preserving the framework's client runtime, communication model, domain metadata, and server-side services. This provides long-term adaptability for enterprise-specific presentation requirements while keeping the RecroGrid Framework's integrated operation intact.
Extensibility and Maintainability
The RecroGrid Framework combines runtime automation, configuration, and deep code-level extensibility within the same architecture. Runtime-provided grids, forms, API services, validation, data operations, and client-server communication establish a professional working foundation, while application-specific requirements can be implemented through standard .NET code and framework extension points.
The use of widely supported .NET technologies and minimal external dependencies supports maintainable application architecture, straightforward integration into existing .NET environments, and long-term project stability. Solutions can evolve over time while preserving both the integrated RecroGrid Framework runtime and the flexibility of standard C#, ASP.NET Core, Entity Framework, and Blazor development.