DataObjects.NET Express 3.8.8

DataObjects.NET is a useful and reliable .NET library which dramatically simplifies development of data and business tiers of the database application. It provides:


Methodology that standardizes and simplifies development of persistent classes and services operating with them providing very clear separation of your business and data tiers from other parts of an application. Essentially DataObjects.NET requires you to build a hierarchy of your persistent and business objects over two base classes: DataObject and DataService. It provides more then 20 attributes controlling almost any persistence or behavior-related aspect. Dont worry about this number - you can know nearly 5 of them to start using DataObjects.NET.

Persistence framework handling all object persistence related tasks transparently. Moreover, this framework allows to almost forget that the underlying database exists - it handles even database schema updates. This framework fully supports inheritance, persistent interfaces, relations and collections, object queries, full-text indexing and search, multilingual properties and a lot of other features. Use of this framework makes most part of your data tier automatically compatible with Microsoft SQL Server 2005 2000, MDSE 2000, Microsoft Access, Oracle, Firebird (formerly - Interbase), MaxDB (formerly - SAP DB) (free, but one of the most featured database servers) without any additional code.

Transactional services allowing to almost forget that your business and data objects operate in the concurrent transactional environment. Transactional services intercept calls of your business tier methods and wraps them into transactions (outermost or nested) providing that if exception or deadlock occurs, no data will be changed. These services are capable of re-processing method call on deadlock exceptions (and similar). This behavior is provided completely transparently for developers, but nevertheless its highly configurable.

Security system supporting per-instance access control lists (allow-deny lists), permissions (custom permissions), security principals (users and roles) and permission inheritance. Its primary goal is to make usage of business objects completely safe, even when these objects are publicly available - via .NET Remoting, for example.

All is initially remotable - any persistent object or business service can be marshaled to another application domain via .NET Remoting (as well as all other DataObjects.NET-related objects, e.g. Query). This means that you can access your data and business tier from a completely different network or across the Internet with almost no additional code. DataObjects.NET supports two marshalling scenarios: access-by-reference for regular DataObjects and by-value marshalling for so-called offline entities (data transfer objects).

Here are some key features of "DataObjects NET Express":

· Transparent persistence: you dont need to write data access code for insertupdatedelete operations - DataObjects.NET persists instances transparently for you. This means that you should never think about invoking a SaveLoad-like methods also - DataObjects.NET handles such tasks completely transparently making you fell youre working with ordinary object instances. Transparent persistence has similar benefits as automatic garbage collection - you shouldnt worry about persisting your changes. Note that this doesnt mean all changes are persisted immediately - DataObjects.NET optimizes the update sequence (see delayed updates feature description)
· Automatic database schema buildingupgrading (database schema includes tables, views, columns, indexes, etc.): on each startup of Domain its database can be upgraded to support new persistent model (persistent model changes e.g. when you modify, add or delete some persistent classes). Upgrade process doesnt destroy existing data.
· Instance identification: DataObjects.NET uses unique 64-bit integers in the database scope to identify instances; upcoming versions will support GUID and 32-bit integers also.
· Querying: use DataObjects.NET query language (see Query description) or perform a direct SQL query (see SqlQuery description) to select the instances youre interested in. An example of DataObjects.NET query: "Select Animal instances where {LegCount}=4 order by {Name}" - this query fetches all four-legged Animal instances, as well as instances of Animal descendants - e.g. Cats and Dogs). More difficult example selecting grandparents instances: "Select Animal instances where {Children[{Children.count}>0].count}>0". DataObjects.NET query language supports sub-queries, joins, distinct and full-text search part in criteria.
· Inheritance support: as it was mentioned, DataObjects.NET fully supports inheritance for persistent classes. But we went much further here: DataObjects.NET supports so-called persistent interfaces. This unique feature allows you to query for objects implementing some interface and refer to its persistent properties inside query criteria.
· Highly configurable persistence for instance properties:
· Multilingual properties (unique feature): you can mark any property with [Translatable] attribute to specify that it should store independent versions of its value for each Culture registered in you Domain. This and a set of other features dramatically simplifies development of multilingual database applications
· References: dont worry about loading referenced objects, as well as persisting them properly - just write a code like cat.Parent = grandCat. Note that if youll try to delete the grandCat instance after executing this code, cat will be notified (because it holds a reference to grandCat). Also after grandCat deletion cat.Parent will be automatically set to null
· Collections: cat.Children.Add(kittyCat). Paired collections and reference properties (unique feature) are supported (so kittyCat.Parent can be automatically set to cat for the code above). "Contained" collections and references are supported as well (if cat.Children is marked by [Contained] attribute, all instances referenced by Children collection will be deleted on cats deletion)
· Structs: any struct type can be used as type of persistent property or item of collection. DataObjects.NET persists such properties into multiple database columns according to the structure of struct type.
· [Serializable] properties: properties which type is marked by [Serializable] attribute are persisted without any additional coding - theyre stored as byte streams (BLOBs). DataObjects.NET handles references to other persistent entities inside such serialized graphs in a special way making them to point to appropriate instances on each deserialization (note that DataObjects.NET is transactional, so you can find different versions of the same persistent instance in different sessions)
· SQL-related attributes are available for almost any type of persistent properties ([SqlType], [Length] and similar ones)
· Indexing: you can apply [Indexed] attribute to a persistent property to tell DataObjects.NET that an index should be created on it, or use [Index] attribute to describe a compound index
· Full-text indexing & search (unique feature): DataObjects.NET supports full-text indexing and search. Microsoft Search (available for SQL Server 20052000 only) and DotLucene (free, RDBMS-independent) full-text indexing and search drivers are shipped with DataObjects.NET. Built-in managed wrapper for Microsoft Index Service filters helps to index almost any documentfile type stored in database or externally. In particular, you can index the following document types: Microsoft Office files (.doc, .dot, .rtf, .xls, .ppt, etc...), HTML files (.htm, .html), Adobe PDF files and so on.
· Built-in NTFS-like security system (unique feature): DataObjects.NET has extremely powerful security system allowing to define the permission for any action (e.g. method execution or property access), grant or deny it for a set of security principals (users and roles) on some persistent instances (like on folders in NTFS) and enforce its presence by demanding it inside methods or property assessors of persistent types or DataServices. It brings NTFS-like security into your business tier with almost zero additional coding!
· We want to underline two very important features of this subsystem:
· Performance: security system is extremely fast - all passed permission demands are cached, effective permission sets for any cached DataObject instance are cached too, internal security notification layer allows any cached DataObject instance to notify all dependent cached instances on changes in its effective permission set... Normally a subsequent permission demand on the same instance is quite fast. This allows DataObjects.NET to execute up to 4000000 permission demands per second on 2,8GHz P4! Its almost impossible to implement a security system having the similar features and performance without implementing all other caching features DataObjects.NET has. Just imagine the nightmare of implementing the similar part in your DAL!
· Immediate effect: all security restrictions take effect immediately on any security-related changes in Session - so its not necessary to reopen Session invoke some method to apply new security restrictions. When you adding a User to some Role, granting permission for him or for some role it belongs to, this immediately affects on its security restrictions in the current Session - so all is transparent even in this case. Even rollback of nested transaction (or rollback to savepoint) immediately affects on security restrictions.
· Rich data import and export capabilities:
· Serialization: DataObjects.NET completely supports .NET Serialization, so you can serialize or deserialize a graph with persistent instances using binary or SOAP formatters. Custom formatters are supported as well.
· Adapter component exports persistent instances to DataSet and imports back the changes
· Offline layer provides advanced implementation of well-known DTO (Data Transfer Object) pattern. It allows to export a set of DataObject instances to serializable, marshal-by-value ObjectSets, pass them to the client to operate with them locally and propagate the changes made to them back to the application server
· BindingManager component (unique feature) establishes two-way bindings between ASP.NETWindowsForms controls and object properties. It brings Property-PropertyEditor bindings in contrast to common Property-ControlProperty bindings - we think this approach is also interesting for developers
· All importexport tools support VersionIDVersionCode validation (optimistic updates)
· Versionizing provides an ability to "see" the database at any previous state (point in time). This feature works only if its turned on for the whole Domain. Currently Versionizing is supported by SQL Server 2005 2000 driver only.
· Automatic transactions (unique feature - it quite differs from standard COM+ automatic transactions, read more about it further): DataObjects.NET is completely transactional. It supports automatic transactions (started with a method call or property access and committed or rolled back based on result; transactional behavior is controlled by attributes) as well as manual transactions (you can also start/commit/rollback a transaction manually); nested transactions and savepoints are also supported.
· Transparent deadlock handling (unique feature): in a highly concurrent environment deadlocks are regular. In case of a deadlock one of the deadlocked transactions (deadlock victim) is aborted by the database server. Normally it should be re-executed later by the application - this situation is called "deadlock handling". DataObjects.NET is capable of handling deadlocks transparently - if a deadlock occurs during an automatic transaction, it can be transparently handled by re-processing of the outermost transaction (re-calling of corresponding method).
· Data services (unique feature) allows to use all DataObjects.NET transactional capabilities (automatic transactions, transparent deadlock handling) with non-persistent classes (DataService descendants). This feature greatly simplifies development of services operating with persistent instances. Its very convenient to use this conception to develop common services of an application, such as Logging Service. Data services are very close to ServicedComponents of .NET, the difference is that they are much faster (method calls are intercepted by the runtime proxies rather then .NET transparent proxies, no COM+ services are used) and easier to use.
· Runtime services (unique feature) are data services of special type (RuntimeService descendants) that can be periodically executed in a special Thread and Session inside Domain. The purpose of runtime services is to perform various maintenance tasks periodically. For example, all IFtIndexer implementors are runtime services that periodically update full-text indexes.