DataObjects.Net 5.0 Beta 2

This is the next step in our road to the upcoming major version of DataObjects.Net.

Changes in Beta 2:

• Added support for VB.NET model assemblies
  
• Increased compilation performance
  
• Fixed problem with automatic license activation
  
• Improved logging API
  
• Removed obsolete Transaction.OpenAuto() methods
  
• Session closes connection as soon as the last transaction completes
  
• New Session option NonTransactionalReads.
  
• Added support for Contains operation over keys collection
  
• Added support for persistent fields of DateTimeOffset type
• Key.TypeInfo no longer relies on implicit session
  

Also you may be interested in changes in DataObjects.Net 5.0 Beta 1.

Download

Just as always, releases are available from NuGet gallery.

DataObjects.Net 4.6.5

Changes in DataObjects.Net 4.6.5:

[main] Fixed version validation for entities without explicit version columns
[main] Fixed version validation for decimal version fields
[main] Optimized aggregate translation in complex scenarios
[main] Fixed problem with access to nullable enum columns in final projection
[main] Fixed problem with missing calculated columns in final projection
[main] Fixed materialization of delayed queries with parameters in final projection
[main] Implemented merging of duplicated query parameters
[main] Improved handling of unique index conflicts during persist
[main] Implemented query batching when ValidateEntityVersions option is enabled
[sqlserver] Optimized queries that are executed during driver initialization
[sqlserver] Added support for full text data type columns
[sqlserver] Added ignoring of filetable objects during upgrade and schema validation
[sqlserverce] Fixed translation of DateTime operations in LINQ
[sqlite] Fixed translation of DateTime operations in LINQ
[mysql] Fixed translation of DateTime operations in LINQ

Download

Just as always releases are available at our site and NuGet gallery.

Winter sale

This year we're starting our winter sale right on December 27. Just use the coupon code DO2014 on checkout and get 50% off all editions of DataObjects.Net. If you want to renew your subscription use DO2014RENEWAL to get 70% discount.

This special on our products is valid until Wednesday 15 January 2014.

Should you have any questions, please email to sales@x-tensive.com.

Enhancement in optimistic concurrency mode

Starting from DataObjects.Net 4.6.4 we are introducing an update to optimistic concurrency feature — server-side version check.

The present API of optimistic concurrency feature in DataObjects.Net with all these VersionSet, VersionCapturer, VersionValidator, whatever is kind of tricky, over-complicated and mind-blowing, so eventually we started moving towards more simple and transparent solution. The server-side version check is the first step in this direction.

The whole idea of server-side version check is obvious: each time an entity is fetched from database, it is associated with a version. On each successful update version is incremented. Each UPDATE command contains additional check for the specific version. Here is an example:

Say, we operate an online book store and use the following simplified Book model with Version field for optimistic concurrency check:

[HierarchyRoot]
public class Book : Entity
{
    [Field, Key]
    public int Id { get; set; }

    [Field(Length = 128)]
    public string Title { get; set; }

    [Field, Version]
    public int Version { get; set; }

    public Book(Session session) : base(session)
    {}
}

As the field is marked with VersionAttribute, DataObjects.Net detects and uses it to store the Book version which is automatically incremented after each successfully committed transaction. Now we want that every update command to include the additional check for version, e.g.:

UPDATE [dbo].[Book]  
SET [Title] = 'DataObjects.Net 4 unleashed' 
WHERE (([Book].[Id] = 123) AND ([Book].[Version] = 2)); 

If this check fails, the Xtensive.Orm.VersionConflictException is thrown with message "Version of entity with key 'Book, (123)' differs from the expected one", so it can be easily detected and handled.

By default, this mode in DataObjects.Net 4.6.4. is switched off to provide compatibility with the older versions. To switch it on we should change SessionConfiguration like this:

var sessionConfig = new SessionConfiguration(
    SessionOptions.ServerProfile | SessionOptions.ValidateEntityVersions);

using (var session = domain.OpenSession(sessionConfig)) {
    // do some stuff 
}

Alternatively, this can be done in configuration file so it is automatically applied to all sessions, like this:

<Xtensive.Orm>
    <domains>
      <domain name="Default"
              upgradeMode="Recreate"
              connectionUrl="sqlserver://localhost/AmazonBookStore">
        ...
        <sessions>
          <session name="Default" options="ServerProfile, ValidateEntityVersions" />
        </sessions>
      </domain>
    </domains>
  </Xtensive.Orm>

DataObjects.Net 4.5.8 and 4.6.4

Finally, the new version of DataObjects.Net is out. Traditionally, we are releasing both major versions: 4.5.x & 4.6.x,

Changes in both DataObjects.Net 4.5.8 and 4.6.4:

[main] Added QueryEndpoint.Items() method for querying EntitySets within compiled queries
[main] Added support for DateTime.AddXxx() methods in LINQ translator
[main] Added support for System.Linq.EnumerableQuery in LINQ translator
[main] Fixed invalid key comparison under certain conditions
[main] Fixed EntitySet caching invalid state within DisableSaveChanges() scope
[main] Fixed incorrect column references in generated SQL for certain queries
[main] Fixed querying for types with enum type discriminators
[main] Fixed querying for types with enum key fields
[main] Fixed locking of entity that could not be persisted at the moment for some reason
[main] Fixed handling of temporary tables query with zero columns
[main] Fixed translation of GroupJoin() with temporary tables
[main] Fixed translation of Distinct() after Select()
[main] Fixed translation of ThenBy() that implicitly adds joins
[main] Fixed support for LINQ member compilers that return nullable values
[main] Fixed translation of as with subquery operand
[main] Fixed concurrent access issues with NameBuilder.GetHash method
[main] Fixed incorrect result of FirstOrDefault/SingleOrDefault in certain subqueries
[main] Optimized translation of String.IsNullOrEmpty() method
[main] Reduced number of casts in generated SQL when accessing enum fields
[main] Automatically handle namespace-only renames during upgrade
[main] PostSharp is upgraded to version 2.1.7.30
[postgresql] Npgsql is upgraded to version 2.0.12.1
[mysql] MySQL library is upgraded to version 6.7.4
[mysql] Fixed translation of bitwise operations
[mysql] Fixed translation of DateTime.DayOfWeek and DateTime.DayOfYear
[firebird] Firebird library is upgraded to version 3.0.2.1
[sqlserver] Fixed reading of large SqlDecimal values

Changes specific to DataObjects.Net 4.6.4:

[main] Added version validation on persist via SessionOptions.ValidateEntityVersions
[main] Added DomainConfiguration.ConnectionInitializationSql option
[main] Added support for Enum.HasFlags method in LINQ
[sqlite] Added support for :memory: data source
[main] Fixed regression in Session.Query.ExecuteDelayed introduced in 4.6.4 RC
[main] Fixed redundant delete queries when clearing key generator tables during upgrade
[main] Fixed NRE in StorageMappingBuilder when persistent type does not have a namespace
[main] Store partial index filter definitions in Metadata.Extension table instead of relying on information schema
[main] Improved diagnostic messages for multimapping configurations when database/schema is not found
[main] Improved diagnostic message when non-LINQ method is called within Session.Query.ExecuteDelayed
[sqlite] Fixed extraction of multi-column primary keys
[sqlite] SQLite library is upgraded to version 1.0.87.0
[sqlserver] Fixed incorrect SQL for table rename in non-default database

Download

Just as always releases are available at our site and NuGet gallery.

DataObjects.Net in 2013 roadmap

This post will cover our plans for DataObjects.Net in year 2013.

Feature update for DataObjects.Net 4.6

Unlike typical bug-fix-only minor releases. DataObjects.Net 4.6.4 will include
several new features.

Support for ignoring certain tables and columns during upgrade

This is essential feature for using technologies such as SQL Server Replication that require special columns to be present in each table.

Support for external 'recycled' definitions

As you know, it's possible to mark certain types and/or fields as recycled to keep corresponding data (tables, columns) available during upgrade. However, this requires keeping some legacy items in your code. External recycled definition will solve this problem by providing an API to add recycled definitions via UpgradeHandlers.

Support for :memory: data source in SQLite provider

SQLite provides special :memory: data source that could be used to operate against in-memory database. This is extremely useful for instance, for testing purposes as the database disappears once connection is closed. Currently, DataObjects.Net requires separate connections for building domain and regular CRUD operations which makes :memory: data source inapplicable. DataObjects.Net 4.6.4 will include support for this data source, limiting one active session per domain.

DataObjects.Net 4.6.4 is expected to be released in March 2013.

Plans for DataObjects.Net 4.7

This is not final roadmap for DataObjects.Net 4.7. Things might change, but here is our current plans.

New faster tuple implementation

DataObjects.Net internally uses special data structure to store Entity fields called Tuple (not to be confused with .NET Framework 4 tuples). Versions prior to 4.7 used set of generic types to store and access tuple fields. Due to the startup slowness of generics and additional memory consumption we switched to non-generic approach that provides more efficient data storage as well as fast typed access. This feature is already implemented and will be included in DataObjects.Net 4.7

Support for reading entities after session has been disposed

This feature would simplify passing entities in ASP.NET MVC and other similar applications.

Automatic caching of generated SQL queries

LINQ translation might take considerable time. DataObjects.Net provides compiled queries to address this. However sometimes it's desirable to cache translation result of each LINQ query. This would be available as an option. By default generated SQL queries will not be cached.

Query result caching API

This is one of the most wanted DataObjects.Net features. We will provide an API to maintain cache of LINQ query results as well as examples how to integrate DataObjects.Net with memcached and other caching facilities.

Change of a default Transactional aspect application

At the moment all your persistent types (i.e. entities, services derived from SessionBound) are powered with our Transactional aspect. This means they automatically provide transaction and activate session upon calling any of their methods. This adds some overhead and most of the users like to manage transactions manually. Thus we decided to remove automatic application of  Transactional aspect in DataObjects.Net 4.7. For those who will need current behavior it would be possible to enable it again by adding special attribute on each assembly with persistent types.

Improved support for native SQL data types

Currently DataObjects.Net supports persistence of standard .NET primitive types and spatial types of SQL Server. We are going to improve this and add support for spatial types in PostgreSQL as well as XML data types for servers that support them. Also operations on such types would be supported by LINQ translator.

Improved logging API

At the moment DataObjects.Net logging is complex to configure.
We're going to change this and provide new more simple interface for it. Also it would be possible to plug your own log consumers.

Reworked validation framework

We're going to improve our validation framework to make it more easy to use and extend with your own validators.

Support for SQL Server Compact 4

SQL Server Compact 4.0 will supported in addition to 3.5

DataObjects 4.7 is scheduled for release in September 2013.
 

Product lifetime policy update

There was no clear policy on DataObjects.Net product lifetime in the past. Now we define such policy. Each major DataObjects.Net release is supported for 18 months. Within this period we will accept bug reports and make bug-fix releases. After product lifetime expires you might still use it "as is". Certain versions might have this period expanded with proper announcement.

Currently we support 3 major DataObjects.Net releases: 4.4, 4.5 and 4.6.

The following table shows when they would go out of support:

• 4.4    April 2013
• 4.5    October 2013
• 4.6    April 2014

As a special exception we extended 4.4 lifetime to make it easy to migrate to newer versions.
The last 4.4 release will be available in April 2013.

DataObjects.Net 4.5.7 and 4.6.3 are released

This is a huge bug-fix release. Everybody is encouraged to upgrade.

DataObjects.Net 4.5.7 and 4.6.3:

• Fixed translation of GroupBy() over columns with same name
• Improved diagnostic message when more than one upgrade handler is provided
• Fixed error after changing case of a persistent field
• Wrap exceptions occured within user code with TargetInvocationException
• Fixed handling of validation aspects on generic types
• Fixed translation of In/Contains over field obtained with `as` operator
• Fixed translation of In/Contains over arbitrary expressions
• Fixed projection to DTO with inheritance
• Fixed translation of DateTime properties access on certain expressions
• Fixed accessing of IGrouping.Key in subqueries
• Fixed implementation of "truncate" operation on DateTime expressions (SQL Server)

DataObjects.Net 4.6.3 only:

• Fixed incorrect column order in queries after certain schema upgrades
• Added DomainConfiguration.NativeLibraryCacheFolder setting
• Significantly improved initialization time for Xtensive.Tuples infrastructure

DataObjects.Net Extensions 4.6.3 and 4.5.7:

Bulk operations extension

•  Remove extra command execution under certain scenarios

Reprocessing extension

• Improve compatibility with DisconnectedState
• Don't use nullable types in ReprocessAttribute properties

DataObjects.Net Extensions 4.6.3 only:

Localization extension

• Improved examples in readme.txt

Tracking extension

• Fixed incorrect handling of partially loaded entities

DataObjects.Net LinqPad driver 4.6:

• Support for DataObjects.Net 4.6 is added

Download

Just as always releases are available at our site and NuGet gallery.

DataObjects.Net 4.5 and 4.6 are updated

Bug fixing updates for DataObjects.Net 4.5 and 4.6 are available.

Here is the list of changes for both versions:

• Fix translation of predicates similar to (object) NullableBool == (object) null
• Fix translation of Union() over boolean columns under certain conditions
• Don't enforce implicit non-nullable/length constraints in inconsistent sessions
• Import DataObjects.Net.targets conditionally when using NuGet package
• Make UpgradeHandler.IsFieldAvailable virtual
• Treat SQL Server errors 3966 and 3971 as serialization failure

The following fixes apply to 4.6.1 only:

• Fix loading/storing of the domain model when multi-database mode is enabled
• Fix assignment of MappingSchema/MappingDatabase for persistent interfaces
• Improve exception message for missing default schema in domain configuration

Just as always you can get new releases at our download site or NuGet gallery.

DataObjects.Net extensions are not updated yet. You could use previous versions of them which are fully compatible with this release.

DataObjects.Net Extensions update

DataObjects.Net Extensions for DataObjects.Net 4.5.5 and 4.6.0 are available.

Changes

•     Added missing xmldocs for BulkOperations extension
•     New Tracking extension (DataObjects.Net Extensions 4.6.0 only)

Tracking extension

Tracking extension provides tracking/auditing functionality on Session/Domain level.

To use it:

1. Add reference to Xtensive.Orm.Tracking assembly

2. Include types from Xtensive.Orm.Tracking assembly into the domain:

<Xtensive.Orm>
  <domains>
    <domain ... >
      <types>
        <add assembly="your assembly"/>
        <add assembly="Xtensive.Orm.Tracking"/>
      </types>
    </domain>
  </domains>
</Xtensive.Orm>

3. To track changes on Session level obtain an instance of ISessionTrackingMonitor through Session.Services.Get<ISessionTrackingMonitor>() method To track changes on Domain level (from all sessions) obtain an instance of IDomainTrackingMonitor through Domain.Services.Get<IDomainTrackingMonitor>() method

4. Subscribe to TrackingCompleted event. After each tracked transaction is committed you receive the TrackingCompletedEventArgs object.

5. TrackingCompletedEventArgs.Changes contains a collection of ITrackingItem objects, each of them represents a set of changes that occured to an Entity within the transaction committed.

Example

1. Subscribe to ISessionTrackingMonitor/IDomainTrackingMonitor TrackingCompleted event

var monitor = Domain.Services.Get<IDomainTrackingMonitor>();
monitor.TrackingCompleted += TrackingCompletedListener;

2. Do some changes to persistent entities

using (var session = Domain.OpenSession()) {
  using (var t = session.OpenTransaction()) {
    var e = new MyEntity(session);
    e.Text = "some text";
    t.Complete();
  }
}

3. Handle TrackingCompleted event call and do whatever you want with tracked changes.

private void TrackingCompleted(object sender, TrackingCompletedEventArgs e)
{
  foreach (var change in e.Changes) {
    Console.WriteLine(change.Key);
    Console.WriteLine(change.State);

    foreach (var value in change.ChangedValues) {
      Console.WriteLine(value.Field.Name);
      Console.WriteLine(value.OriginalValue);

      Console.WriteLine(value.NewValue);
    }
  }
}

Sync extension

Sync extension was planned for 4.6 release. We decided that it is not production ready and postponed it until 4.7.

Download

• From our site.
• From NuGet gallery.

DataObjects.Net 4.6 goes final

I'm glad to announce that DataObjects.Net 4.6.0 is released. This post provides an overview of changes and improvements in 4.6 version. They would be explained with more details in future posts.

SQLite provider

SQLite has joined the list of supported databases.

Quick domain configuration example:

    <domain name="mySqliteDomain"
            providerName="sqlite"
            connectionString="Data Source=mydatabase.db" />

You'll also need to add reference to Xtensive.Orm.Sqlite.dll assembly in your project.

Mapping to multiple schemas and even databases

Since 4.6 it's possible to map persistent model to multiple schemas and databases.

The following examples maps model to two schemas based on entity namespaces:

    <domain name="myDomainWithTwoSchemas" defaultSchema="dbo">
        <mappingRules>
            <rule namespace="MyApp.Model.Foo" schema="foo" />
            <rule namespace="MyApp.Model.Bar" schema="bar" />
        </mappingRules>
    </domain>

I'll cover multi-mapping configurations in future posts.

Upgrade improvements

In this version we heavily reworked upgrade to be more fast and reliable. First major improvement is extensive usage of parallel computations, so now DataObjects.Net will perform some actions in parallel to build domain faster. Second major improvement is wrapping all upgrade actions in a single transaction if database supports transactional DDL. Previous versions of DataObjects.Net used two transactions in Perform and PerformSafely modes because additional upgrade domain was created.

Simplified key generator API

In DataObjects.Net 4.6 we changed API for key generators (both standard and user-written) to be more simple and intuitive. For example for creating custom key generator table or sequence you no longer need to write domain service. Simple [KeyGenerator(Name = "Foo")] will work just well. I'll explain new key generator API in details in future posts.

Final words

Just as always you can download packages from our site or NuGet gallery.

DataObjects.Net 4.5.5 released

DataObjects.Net 4.5.5 is made available. This is bug-fixing release for 4.5 branch. List of resolved problems could be found here. Just as always you can download packages from our site or NuGet gallery.

DataObjects.Net 4.5.5 RC and 4.6.0 RC

Two release candidates for 4.5 and 4.6 branches are made available.

Here is short list of changes:

DataObjects.Net 4.6.0 RC

Added NamingRules.RemoveDots and NamingRules.RemoveHyphens

New options work similar to existing UnderscoreDots and UnderscoreHyphens except that dots and hyphens are completely removed from table or column name instead of replacing with underscore.

Added Connection and Transaction properties to UpgradeContext

DataObjects.Net provides single transaction for upgrade process. Those properties allows to execute custom actions at any stage.

Added Session property to UpgradeContext

This is new recommended approach for getting current session in upgrade handlers.

UpgradeStage.Initializing is marked obsolete

This stage no longer occurs in DataObjects.Net 4.6 so corresponding warning would be emitted when it is used.

Added OnPrepare and OnComplete methods to UpgradeHandler which are executed before and after any upgrade

OnPrepare partially replaces old Initializing stage. It is executed are very early stage so you can apply fixes to the database schema before any upgrade actions are performed.
OnComplete is executed at the very last stage and could be used for configuring domain before it is returned from Domain.Build() method.

Added advanced version of domain builder module

New method OnAutoGenericBuilt() allows to change created automatic generic instances.

Correctly clean up key generator tables if entities are created in OnUpgrade() method

If entities are created in OnUpgrade() method key generator tables (i.e. Int64-Generator) might be not empty after the upgrade. This is fixed now.

Several methods that implicitly use Session are marked as obsolete

Since DataObjects.Net 4.4 we are recommending explicitly pass session everywhere.
Some old methods that implicilty use Session.Current has been marked as obsolete.
Examples of such methods InvokeTransactionally() extension method overloads that don't take session and GetTypeInfo() extenstion method.

DataObjects.Net 4.5.5 RC

Omit redundant parentheses in generated SQL for chains of set operations

This allows to write rather large chains of .Union() calls.
See this bug report for details.

Correctly handle hierarchy split when doing upgrade

This fixes error about TypeId removals when hierarchy has been split to hierarchies with single type.

Fixed translation of Contains/Any/All under certain scenarios

See this bug report for details.

Correctly parse pre-release versions of MySQL (e.g. 5.5.25a)

See this bug report for details.

Other changes

Debug symbols (.pdb) are available for this and all future release. They require source code license
just like source code package.

Final words

Just as always distribution packages are available on our download site and NuGet gallery.

DataObjects.Net 4.6 Beta 3 is available

I'm glad to announce that DataObjects.Net 4.6 Beta 3 is made available. It includes important fixes and improvements:

Advanced version of LINQ query preprocessor

Instead of implementing IQueryPreprocessor interface you can inherit from QueryPreprocessor class. The only difference is Apply(Session, Expression) method which allows you to get current session and take it into account when processing Expression.

Fixed redundant query nesting under certain conditions

Less SELECT ... FROM (SELECT ...) clauses would be used from this version.
As the result, size of generated SQL for certain large queries with multiple joins significantly reduced (up to 50%). Generated SQL became less recursive that allowed certain queries to execute on SQLite while previously certain complex queries yielded "parser stack overflow" error.

Fixed redundant subqueries under certain conditions

Previous versions of DataObjects.Net might transform your subqueries into a non-optimal format.

For example the following query

  session.Query.All<Order>()

   .Select(o => new {

      Order = o,

      TotalPrice = o.Items.Sum(i =>  i.Price * i.Amount)

    })

might produce two subqueries for OrderItem instead one. Now such scalar subqueries will not be split.

Improved formatting of SQL when chains of AND/OR operators are used

Sequences of AND/OR operators are translated without additional braces now, so query is more readable.

Key.Create(Session) method has been renamed to Key.Generate(Session)

This method is used to generate new key. Since there are lots of other Key.Create() methods that create key from supplied values new name is more readable and reduces number of Key.Create() overloads. Old methods are kept for compatibility, but marked as obsolete.

Added Key.Create() overload that allows to specify TypeReferenceAccuracy

This is an advanced version of existing methods. It allows you to specify accuracy such as  TypeReferenceAccuracy.ExactType. All existing methods use TypeReferenceAccuracy.BaseType.

Added DirectSessionAccessor.GetChangedEntities() method

This is a long requested method that allows you to get entities (via thier EntityStates) which were changed in current session, but were not saved to the database yet.

Perform upgrade in single transaction when possible

This is a long requested feature too. Previous versions of DataObjects.Net use two transactions for Perform/PerformSafely upgrade modes. Since 4.6 Beta 3 single transaction is used for all upgrade modes.

Added support for using SQLite provider in 64-bit processes

Previous releases of DataObjects.Net 4.6 were compiled with 32-bit only SQLite provider.
This prevented them from using SQLite in 64-bit process. Now MSIL version is used.

As always new versions are available at download site and NuGet gallery.

Moving towards openness

Remember the days when every website wanted to maintain its own database of users and related data? To download some restricted content you have to register there, provide a password, successfully forget it after a couple of minutes and use "Restore password" feature every time you visit the website later.

The same kind of website was our corporate X-tensive.com website. Moreover, our support website was configured to work with users from x-tensive.com only. Until...

Until we rejected the model above and switched to OpenID authentication scheme and made all versions of DataObjects.Net available for download without registration. The same change was applied to support.x-tensive.com — now anyone who has OpenID may log in and post an issue/feedback.

Having that done, we closing user registration area on x-tensive.com as now it doesn't have any sense, however, all user accounts will be preserved and users may sign in in their x-tensive.com profile as usual.

Note for owners of DataObjects.Net licenses: we launched new customer area, don't miss it. All your license-related data is migrated from x-tensive.com to get.dataobjects.net website.

9-th anniversary, new prices, community edition and much more

Hello everybody!

Today we are celebrating the fact that 9 years ago the first version of the award-winning, revolutionary ORM named DataObjects.Net was released. Due to this we are launching our new edition & pricing policy, new customer area and we are hoping that you'll like it.

DataObjects.Net 4.5.4 final

The main change in this version in addition to all listed in RC 1 & RC 2 is Community edition support. Download it from official website or from NuGet repository.

Community edition

Many users requested Community Edition of DataObjects.Net with full set of features and with possible limitation of number of persistent types. Well, here it is, the Community edition is rolled out today. It has the following characteristics:

• The edition is absolutely free.
  
• Anyone can obtain it from our website.
  
• It contains 2 hardware licenses (means it can be installed onto 2 workstations at once).
  
• Number of persistent types is limited to 20.
  
• The license is issued for 1 year as regular licenses.
  

Obtain Community edition.

Professional edition

Professional edition is available for $150 and includes 2 hardware licenses. Comparing to the previous pricing scheme (500 euro), the price cutting is more than 65%. Moreover, 3 items are available for $120 each and 5 items - just for $100.

Get Professional edition.

Ultimate edition

Ultimate edition also gets its new shiny price, from now it is available only for $1500 instead of 2500 euros. The edition provides the unlimited number of hardware licenses. Ultimate edition contains access to the source code no more.

Get Ultimate edition.

Access to source code

We extracted 'Access to source code' feature to a separate package to make it available to all our customers, not only for Ultimate edition owners as it was earlier. So anyone, even an owner of Community edition has a chance to dive deep in DataObjects.Net white and black magic. The price for the package is set to $500. The source code is available in download area of our website.

Get access to source code.

New customer area

We are inviting you to the new customer area that we have built for you for better and easier license management. No more registration, we migrated to OpenID authentication scheme. We added license sharing feature, so your developers won't bother you with anything concerning licenses and hardware locks, you may share the license with all of them.

The area can be accesses by clicking on 'My Account' link in the main menu:

Soon you'll receive our invitation e-mail. We need you to log in the area to get your licenses associated with your account. Don't forget to periodically check your mailboxes!

Join the celebration! Thank you!

Links:

• Obtain community edition
  
• Get Professional/Ultimate edition
  
• Get access to source code
  
• Visit customer area
  

DataObjects.Net Extensions 4.5.3

DataObjects.Net Extensions are updated to the latest version.

What are these so-called extensions?
They are small projects that extend standard functionality of DataObjects.Net core. Version 4.5.3 contains of the following extensions:

• Bulk operations
  
• Localization
  
• Reprocessing
  
• Security
  
• Web
  

Each of them has a corresponding nuget package so they can be installed separately or in any combination. Using NuGet is a recommended way of installing the extensions.

DataObjects.Net Extensions are published on CodePlex with source code opened. You may also want to check the documentation before start using them. The extensions are maintained by Xtensive engineers and by volunteers from DataObjects.Net community.

Changes

• [Security] Fix threading issues with hashing services
  
• [Localization] LocalizationModule is added. It automatically calls TypeLocalizationMap.Initialize(Domain) during Domain build.
  
• [BulkOperations] Support for single insert operation is added
  
• [BulkOperations] Fix for drivers that don't support UpdateFrom and DeleteFrom constructs
  

Download

• From public DataObjects.Net Extensions repository.
• From NuGet repository.

Roadmap

There are several new extensions that are now being developed and tested:

• Xtensive.Orm.Sync - Microsoft Sync framework support (expected in 4.6 version)
  
• Xtensive.Orm.Tracking - a tracking monitor that tracks changes in entities and notify you about them. Good for auditing purposes and similar tasks. (expected in 4.6 version)
  
• Xtensive.Orm.Security.Web - ASP.NET Membership provider & Role provider (expected in 4.5.4 version, contribution of Carl Healy)
  
• Here could be your extension - Contribute! Obtain DataObjects.Net license for free!
  

Thank you!

DataObjects.Net 4.5.4 RC 2

Today we are publishing the next release candidate for the upcoming version of DataObjects.Net.

Changes

• [main] Exceptions on IoC container finalization (usually they appear because dependent objects are already finalized) are now suppressed
  
• [main] Fixed NullReferenceException in EnsureIsFetched method in SessionOptions.ReadRemovedObjects mode
  
• [main] Entity.IsMaterializing property wasn't handled properly
  
• [main] Transaction opening is fixed for SessionOptions.ClientProfile
  

Download

• From official website
• From NuGet repository. More on installing pre-release NuGet packages can be found here.

DataObjects.Net 4.5.4 RC

Today we are publishing the next release candidate for the upcoming version of DataObjects.Net.

Changes

Changes in 4.5.4 RC:

[main] Fixed comparion of Key fields in interaces in LINQ queries under certain scenarios
[main] Visual experience of License Manager has been improved
[main] Fixed incorrect handling of RemoveFieldHint under certain scenarios
[main] Fixed incorrect behavior in DisconnectedEntityState.UpdateOrigin method

Download

• From official website
• From NuGet repository. More on installing pre-release NuGet packages can be found here.

DataObjects.Net 4.5.3 is released

Today we are publishing the final version of DataObjects.Net 4.5.3.

Changes

Changes in 4.5.3 comparing to 4.5.3 RC 4:

[main] Fix NullReferenceException under certain validation scenarios
[main] Fixed memory leak in Domain.Build() process

Download

• From official website
• From NuGet repository.