Auto-transactions API

Which auto-transactions API I'd like to have in ideal ORM?

In a typical business application we have a set of session-bound classes, for example our business classes, services, etc... Each method, property or constructor in these classes can be either transactional or not transactional. We should decide which of them will be transactional and inform ORM about this, using a set of attribute-based rules. I'd like these attributes to allow me to specify following rules:
  • All members of this class are not transactional by default
  • All public methods of this class and all its inheritors are transactional by default
  • This method requires new nested transaction even if some transaction is already open
  • This member doesn't require transaction
  • This method requires transaction with "ReadCommited" isolation level
Moreover I'd like API to be very simple and intuitive. It should allow to define default behavior and manage transactional behavior in flexible way.

When I starting to implement my model and business logic layer, I decide which policy to use. I can make all public members in all classes of my model transactional by marking base class as "Transactional", and then mark some members as not transactional by appropriate attribute. On other hand I can make everything not transactional, except public methods in some service classes, and open transactions manually each time I need them. I can use third approach, for example make methods transactional, but properties not. It depends on my solution architecture, and it's impossible to find universal right way.

So I think we need something like this:

[Transactional] attribute that can be applied to a session-bound class or its member. Attribute should have following options:
  • Should this attribute be applied to inheritors or not
  • Which members it should be applied to (methods, properties, constructors)
  • Visibility of members this attribute should be applied to (public, internal, protected)
  • Are members this attribute applied to transactional or not. Another alternative is to mark not transactional members by special [NotTransactional] attribute
  • Required isolation level for transaction
  • Whether new transaction is required or any existing one is enough.
There is a small example that illustrates how I'd like it to work. In this example I've made all entities not transactional and all public methods of DocumentService - transactional by default.

  1. [NotTransactional(InheritBehavior = true)]
  2. public class MyEntityBase : Entity
  3. {
  4. }
  6. public class Document : Entity
  7. {
  8.   [Transactional]
  9.   public void BusinessMethod()
  10.   {      
  11.   }
  13.   [Transactional(Options = TransactionOptions.New,
  14.     IsolationLevel = IsolationLevel.Serializable)]
  15.   public void AnotherBusinessMethod()
  16.   {      
  17.   }
  18. }
  20. [Transactional(
  21.   MembersType = MemberTypes.Method,
  22.   MembersVisibility = Visibility.Public)]
  23. public class DocumentService : SessionBound
  24. {
  25.   public Document FindLastDocument()
  26.   {
  27.   }
  29.   public void RemoveAllDocuments()
  30.   {
  31.   }
  33.   [NotTransactional]
  34.   public override string ToString()
  35.   {
  36.   }
  37. }

As you can see MyEntityBase class marked by [NotTransactional] attribute, but if we assume that all classes are not transactional by default we must not mark it by this attribute.


    Xtensive company and DataObjects.Net

    First thing I'd like to do now is to introduce myself, especially explain what do I do now. You have definitely read this post title, yes, I work at Xtensive company on DataObjects.Net project.

    Xtensive is small, but very ambitious company, there are about 20 developers working on several interesting projects. I can mention DataObjects.Net, MEScontrol, LiveUI and HelpServer. There is no need to introduce each of them in details, you can found detailed information on our nice-looking website www.x-tensive.com. But really important thing here is that at least two projects DataObjects.Net and LiveUI are frameworks designed to make software development easier. That is why I am here, it's cool to develop software, but it's more cooler to develop software for software developers. Though I should say I also like to develop end-user business applications very much, I did it before I came to Xtensive and I hope I'll do it in future.

    So I work on DataObjects.Net project now. What is it? You can think of it as of Object Relational Mapper, ORM. Yes, yet another ORM. Yet another ORM with great history and some unique features. It was started in 2003 by Alex Yakunin, first version had a great success, it was realy outstanding product for that time. Now DataObjects.Net team contains of eight skilful and experienced developers, headed by Alex Yakunin. A year ago product was fully reimplemented and now we have almost new DataObjects.Net with such new features as: The best LINQ to SQL translator among existing ORMs, really good performance, great support of "model-first" development practice, including unique "model-first" way of database schema upgrade.

    However there are still so many things to do, first of all we need to make all its features as easy to use as possible, we also try to make it more extensible and offer ready to use patterns and practices for frictionless developing different kinds of applications. For example my personal goal for this month is to complete DataObjects.Net manual, that is not completed yet. Yes, we still don't have technical writer position in our team, partly because of product specificity (it's not easy to understand all peculiarities if you are not software developer).

    Hello World!

    I've finally decided to start my blog on software development and I hope it will be a good place for my thoughts and ides.