DataObjects.NET - .NET - V3.9.5

de X-tensive.com - Tipo de producto: Componente / .NET Class / 100% Managed Code

Por favor note que la información sobre este producto no está disponible en español.
 Captura de pantalla DataObjects.NET - .NET - V3.9.5Object-relational mapping (ORM) framework for .NET with built-in access control system. DataObjects.NET lets you decrease development time by providing transparent persistence for your business entities (.NET objects). DataObjects.NET is more than just an ORM API - it transparently handles all types of relations, has an extendable NTFS-like access control system, automatically manages transactions, updates the database schema, supports OQL-like queries, multilingual properties, full-text indexing, versioning, .NET Remoting and more.

Opinión media:  Opinión Media para DataObjects.NET - .NET - V3.9.5 basada en: 1 opinión.

What's new in X-Tensive DataObjects.NET V3.9.5?

  • Query Profiler and query profiling API (IDbCommandEventWatcher, DbCommandEventWatcherService, etc.)
  • DataSource control and BindingSource components are added. Both of them are used in a data binding scenarios, but the first one is intended for the Web environment, and the second one - for Windows Forms
  • BindingManager component is re-implemented according with user requirements
  • DataContext class (lightweight version) is added to the DataObjects.NET.UI namespace
  • ValidationService code is added to DataObjects.Net.
  • Access validators are implemented.
  • Generators (table-based) are now used to provide new ID values instead of autoincrement columns

X-tensive.com DataObjects.NET is a .NET library that simplifies development of the data and business tiers of database applications. It provides:

A methodology that standardizes and simplifies development of persistent classes and services. It provides very clear separation of your business and data tiers from other parts of your 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.

A persistence framework that handles all object persistence related tasks transparently. Moreover, this framework allows you 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 parts of your data tier automatically compatible with Microsoft SQL Server 2005 \ 2000, MDSE 2000, Microsoft Access, Oracle, Firebird (formerly - Interbase), MaxDB (formerly - SAP DB) without any additional code.

Transactional services allowing to you to almost forget that your business and data objects operate in the concurrent transactional environment. The transactional services intercept calls from your business tier methods and wrap 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 calls on deadlock exceptions (and similar). This behavior is provided completely transparently for developers, but nevertheless it's highly configurable.

A 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.

Everything 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).

X-tensive.com DataObjects.NET allows you to focus on the code of business tier and application data model - it completely solves a set of problems that could take up to 80% of development time. Just imagine to find and fix an error (e.g. thread deadlock or "the latest update wins"­-like problem) that appears only under high concurrency conditions. Sometimes it's not so easy to even imagine that such a problem exists.

X-tensive.com DataObjects.NET can be used in virtually any application that accesses a relational database. You simply add a reference to DataObjects.NET.dll to your project to start using it.

Major features of DataObjects.NET:

  • Transparent persistence: you don't need to write data access code for insert\update\delete operations - DataObjects.NET persists instances transparently for you. This means that you should never have to think about invoking a Save\Load-like method. DataObjects.NET handles such tasks completely transparently making you feel like you're working with ordinary object instances. Transparent persistence has similar benefits as automatic garbage collection - you shouldn't worry about persisting your changes. Note that this doesn't mean all changes are persisted immediately - DataObjects.NET optimizes the update sequence (see delayed updates feature description)
  • Automatic database schema building\upgrading (database schema includes tables, views, columns, indexes, etc.): on each startup of the Domain its database can be upgraded to support s new persistent model (persistent model changes e.g. when you modify, add or delete some persistent classes). The upgrade process doesn't destroy existing data.
  • Instance identification: DataObjects.NET uses unique 64-bit integers in the database scope to identify instances
  • Querying: use the DataObjects.NET query language (see Query description) or perform a direct SQL query (see SqlQuery description) to select the instances you're 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: 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: you can mark any property with a translatable attribute to specify that it should store independent versions of its value for each Culture registered in your Domain. This and a set of other features dramatically simplifies development of multilingual database applications
    • References: don't worry about loading referenced objects, as well as persisting them properly - just write a code like cat.Parent = grandCat. Note that if you'll 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 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 cat's 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 - they're stored as byte streams (BLOBs). X-tensive.com 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 an indexed attribute to a persistent property to tell DataObjects.NET that an index should be created on it, or use an index attribute to describe a compound index
  • Full-text indexing & search: DataObjects.NET supports full-text indexing and searching. Microsoft Search (available for SQL Server 2005\2000 only) and DotLucene (free, RDBMS-independent) full-text indexing and search drivers are shipped with DataObjects.NET. A built-in managed wrapper for Microsoft Index Service filters helps to index almost any document\file 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 : DataObjects.NET has a security system allowing you 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.
    • Performance: the security system is extremely fast - all permission demands are cached and effective permission sets for any cached DataObject instance are cached too. The 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.
    • Immediate effect: all security restrictions take effect immediately on any security-related changes in the session - so it's not necessary to reopen the session or invoke some method to apply new security restrictions. When you add a User to some Role, granting permissions for him this immediately affects its security restrictions in the current session - so it 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.
    • An adapter component exports persistent instances to DataSet and imports back the changes
    • Offline layer provides advanced implementation of well-known DTO (Data Transfer Object) patterns. It allows you 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 establishes two-way bindings between ASP.NET\WindowsForms controls and object properties. It brings Property-PropertyEditor bindings in contrast to common Property-ControlProperty bindings
    • All import\export tools support VersionID\VersionCode validation
  • Versionizing provides an ability to "see" the database at any previous state (point in time). This feature works only if it's turned on for the whole Domain. Currently Versionizing is supported by SQL Server 2005 \ 2000 driver only
  • Automatic transactions: 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 save points are also supported
  • Transparent deadlock handling: 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 allows you 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. It's 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 are data services of a special type (RuntimeService descendants) that can be periodically executed in a special Thread and Session inside the 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.

Supported technologies\platforms:

  • 6 RDBMS platforms: DataObjects.NET makes most part of your business tier automatically compatible with Microsoft SQL Server 2005\2000, MDSE 2000, Microsoft Access, Oracle, Firebird (formerly - Interbase), MaxDB (formerly - SAP DB) without any additional code
  • 2 full-text search engines: Microsoft Search (supports SQL Server 2005\2000 only) and DotLucene (free, RDBMS-independent)
  • .NET Framework 2.0: DataObjects.NET supports all essential features of .NET 2.0 (generics, nullable types)
  • Mono: core part of DataObjects.NET runs on Mono
  • .NET Framework 1.1/2.0 languages: C# and VisualBasic.NET are supported. DataObjects.NET also should support almost any programming language available for .NET - JScript.NET, J#, Managed C++
  • .NET Remoting: any persistent instance or DataService 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 these objects from a completely different network or across the Internet with almost no additional code; moreover, you can use offline layer - it's an implementation of DTO (data transfer object) pattern for DataObjects.NET.
  • Distributed transactions: you can enlist any Session instance in the MS DTC\COM+ distributed transaction.

DataObjects.NET is available in four editions:

Standard Edition, includes: 1 year month E-mail and forum support subscription with a goal of resolving major issues within 24 hours; Free upgrades for 1 year (all upgrade types including major upgrades). Global Cache size limited to 10mb. Includes a 1 Developer License.

Advanced Edition includes Unlimited Global Cache size. 1 year month E-mail and forum support subscription with a goal of resolving major issues within 24 hours; Free upgrades for 1 year (all upgrade types including major upgrades). Includes a 1 Developer License.

Professional Edition, includes: Complete source code of the product. Unlimited Global Cache size. 1 year month E-mail and forum support subscription with a goal of resolving major issues within 24 hours; Free upgrades for 1 year (all upgrade types including major upgrades). Includes a 1 Developer License.

Enterprise Edition, includes: a 4 Developer Team license. Complete source code of the product. Unlimited Global Cache size. 1 year month E-mail and forum support subscription with a goal of resolving major issues within 12 hours; Free upgrades for 1 year (all upgrade types including major upgrades).


Búsqueda de productos

Escriba palabras de búsqueda: