Direct Object Persistence for .NET

FastObjects .NET 10.0 fully conforms to the Microsoft.NET 2.0 framework. Tightly integrated with Visual Studio 2005, it offers a developer-friendly, object-oriented alternative to a relational database for .NET persistence.

FastObjects .NET delivers both transparent persistence and state management to the .NET developer. With FastObjects .NET, a developer can stop worrying about data, and instead focus on the problem domain being addressed by the application.

FastObjects .NET works with the .NET Intermediate Language (IL), therefore it supports applications written in C#, Managed C++, J#, VB.NET or any other IL-capable programming language. Similar to ADO.NET, FastObjects .NET works in either a connected or disconnected mode. It does not place any restrictions on your object model, and fully supports the concepts of inheritance, interfaces and .NET Framework collections. And finally, FastObjects .NET is tightly integrated into Visual Studio .NET, thereby allowing automatic updates to your application's database upon each new compilation of your code.

FastObjects .NET is a high performance, transactional database that is configurable to meet your deployment needs. If you require a scalable, multi-user database server, FastObjects .NET offers relevant options such as multi-processor support, encryption, replication, and fail-over/reconnect. If you require a truly embedded database, FastObjects .NET offers features specifically designed for mass deployment such as object/schema versioning and zero maintenance.

Irrespective of your deployment requirements, FastObjects .NET ensures data consistency and integrity through the use of ACID transactions, concurrency controls and administrative functionality. In addition, because FastObjects .NET uses your object model as its database schema, it delivers high performance through easy navigation and a robust query engine.

Architecture

FastObjects .NET consists of a core database server system that provides the essential database functionality, and a set of client-side application libraries.

With FastObjects .NET, the database schema and all access code are generated directly from the object model. This allows for a direct mapping from objects and their relationships to the database representation, thereby eliminating any need for schema mapping code.
The FastObjects .NET Server listens for and maintains client connections over a collection of TCP/IP sockets. Designed for two-tier and three-tier applications, the Server manages all of the transactions running against the database by providing concurrency control through a sophisticated object level locking. Objects are stored on the FastObjects .NET Server's local file system for fast, efficient storage. Internal caching is used to improve the Server's runtime performance.

^{FastObjects .NET Runtime Architecture}

FastObjects .NET is designed to be transparently embedded into an application, and to provide the application with the ability to manage complex data without added deployment difficulties. The end user of the application has no reason to be aware of the presence of the FastObjects .NET database. The FastObjects .NET runtime system simply needs to be linked to the application, thereby creating a complete application without a complex installation process. The FastObjects .NET administration API gives the developer the ability to fully automate administrative procedures normally done by a DBA, such as online database backup.

Key Features

Transparent Persistence and State Management through Code Enhancement

FastObjects .NET is a persistence framework that offers transparent persistence through post-compilation code enhancement. As such, adding persistence functionality is non-intrusive to the object model. Custom attributes are used to assign attributes to classes. With custom attributes classes can be declared as persistent, and for example indexes can be defined for class fields. With FastObjects, classes do not have to inherit from a specific base class or implement a specific interface to be persistent. FastObjects .NET does not put any restrictions on the object model and supports inheritance, interfaces and .NET Framework collections.

Post-compilation code enhancement also allows FastObjects .NET to handle all state management. Objects are loaded from the database transparently and our internal change tracking ensures that only changed and new objects are written to the database.

Concurrent Access by Multiple Users or Processes

FastObjects .NET is designed for large-scale concurrent access to the databases controlled by the database Server. FastObjects .NET offers both optimistic and pessimistic locking strategies, both of which guarantee object consistency when working with multiple users or processes.

For multithreaded access to the database, FastObjects .NET allows the developer to use multiple transactions with different threads, thereby allowing each application thread to use its own transaction. A flexible object level locking strategy ensures that objects are not modified by multiple transactions at the same time, thereby ensuring object consistency.

Full Object Orientation

FastObjects .NET fully supports the object oriented paradigm for interfaces, inheritance, polymorphism and encapsulation for objects and sets of objects. The concept of code reuse is finally delivered as envisioned.

For example, inheritance is one of the most complex and powerful features of object-oriented languages. It is difficult to do an effective object oriented design without inheritance. FastObjects .NET understands a class' inheritance hierarchy, allowing for efficient polymorphic application design that is inclusive of the database. With FastObjects .NET, data models of all levels of complexity are possible. There is no need to "dumb down" an application's design to fit a non-object-oriented database.

Efficient Direct Mapping

FastObjects .NET provides the developer with extreme efficiency in making objects of user-defined classes persistent. With FastObjects .NET, the in-memory representation of an object is transferred as is to a disk representation, in which memory references are converted into internal object identifiers. This mechanism allows developers to store complex object relationships in an easy, simple manner. The complicated and costly object-to-relational mapping problems inherent in working with a relational database are eliminated in their entirety.

Streamlined Management of Complex Data

For .NET applications, the FastObjects .NET intermediate language code enhancer automatically extracts all needed schema information from the declarations of your classes. Special class/member attribute declarations in the source code of classes indicate if a class is persistence-capable and define its various artifacts of persistence. The FastObjects .NET enhancer processes the .NET assembly files and modifies the intermediate language code to automatically support persistence.

^{FastObjects .NET intermediate language code enhancer and schema generator}

High Speed Navigation and Retrieval

Objects are stored with references so the application can quickly, efficiently retrieve and traverse the object graph. Direct navigation from object to object gives you the fastest possible access to your data. References are automatically translated to database identities when an object is stored. On object loading, the object ID is used to quickly locate the object in the database. FastObjects .NET database performance is further enhanced by an indexing engine that gives the developer full control over the indexes generated for each class in the schema. Indexes have long been used in the relational database industry to speed application response times and organize data presentation. FastObjects .NET uses indexing technology similar to that found in relational database systems, but instead of pointing to a row in a table, FastObjects .NET index entries point to a complete object.

Queries

Closely related to the indexing system is the sophisticated query engine found in FastObjects .NET. The query engine automatically takes advantage of the indexes defined for the class, improving your application's performance. To execute queries against the FastObjects .NET database, you use the industry-standard Object Query Language (OQL).

Data Integrity

FastObjects .NET fully supports all traditional data integrity features such as transactions, logging, and locking. Transactions ensure atomic execution of an operation, meaning all or nothing of the transaction is written to stable storage. This is achieved via a log file, which means that when a transaction is performed, the whole change set of the transaction is first written to the log file and then to the database file. If the logging fails, nothing is written to the database. If the database write fails due to an extraordinary event such as a system crash, FastObjects .NET repeats the writing to the database file from the log file (i.e., redo log).

In addition, every object written to the FastObjects .NET database is encoded with a checksum to protect against media failures. Should a disk block fail, any objects affected by the failure are caught by their checksum ensuring your application never uses faulty data.

FastObjects .NET gives the developer the choice of pessimistic or optimistic locking, depending on the situation in the application at any given time. Modern multi-user architectures increasingly work with a combination of optimistic and pessimistic locking, resulting in higher performance and optimum concurrency.

Transparency and Zero Maintenance

FastObjects .NET is designed to be an embedded, self-contained system that is deployed without the need for end user interaction. The application's end user is unaware of the database. FastObjects .NET databases are just files that are packaged and deployed with your .NET application. Once deployed, a FastObjects .NET database will work indefinitely without the external administration since it has integrated intelligence for free-space storage management, index maintenance, schema versioning, on-the-fly object versioning, and much more.

Schema Evolution

The schema evolution features of FastObjects .NET protect the developer from writing complicated update code when the application evolves. Subsequent application releases greatly benefit because objects in the database are automatically migrated to the new schema. FastObjects .NET benefits the application's life-cycle management from design to release.

Scalability

For large scale web-based applications, FastObjects .NET provides additional performance through its Read-only Replication feature. FastObjects .NET is able to employ a read-write 'master' server relationship with any number of read-only 'slave' servers to achieve a high performing, scalable architecture. Data on the 'slave' servers is synchronized automatically when transactions are committed on the 'master' server.

In addition, FastObjects .NET offers sophisticated caching on the client-side, thereby dramatically improving performance of read-heavy applications by reducing database server traffic for frequently read objects.

FastObjects .NET also offers an Incremental Backup feature that allows for a more pragmatic or practical approach to the regular backup of data contained in large-scale deployed databases. As database size grows, regular database backup becomes both more critical and more difficult to perform. The FastObjects .NET Incremental Backup feature allows you to store only the database changes that have occurred since the last full or incremental backup. The resulting smaller incremental backup files are then put to a permanent backup media and maintained until the next full backup is desired.

Replication and Failover

Highly available systems can be designed by using FastObjects .NET Replication features. Replicated databases have their changes written to both primary and secondary database server using a networked replication agent. Replicas may be set-up using a local or remote system thousands of miles away. Replication agents are configured to be either synchronous or asynchronous depending on the application's design needs.

Data Encryption

FastObjects .NET will protect physical data from theft or unauthorized access through the optional encryption of the information stored in the database.

Communication Encryption

FastObjects .NET will protect the communications between your application and the database Server through optional SSL-based encryption.

Additional Technical Information

Current Version		FastObjects .NET 10.0
Languages		C#, Managed C++, J#, VB.NET Any IL-capable language
Memory Footprint		5.5 MB
Storage		Networked FastObjects Server Local File System
Development Platform		Microsoft .NET
Compilers		Visual Studio 2005 .NET Framework 2.0
.NET Environments		.NET Framework 2.0
Client Deployment OS		Microsoft Windows

Free Trial Edition

Free Trial Edition of Versant FastObjects .NET 10.0 is available for download in the Versant Developer Center.