Alex (Xtensive) wrote:

The main advice is: since current version of object is required in most of cases, I recommend you to duplicate the fields from TCompanyChangedData in TCompany. Getting additional query or join in almost any case is enough expensive, and this solution allows to avoid this.

Now - more interesting part: such things as TCompanyChangedData can be implemented in DO4 in very generic way: 1. There is Session.OperationCompleted event providing IOperation object describing the operation. All integrated operations, such as property setting, are already described there, + moreover, the operation logging framework is open, so you can create your own ones. Note that Operations framework is not fully finished yet (we plan to add more features there, e.g. undo support), but it is already used by DisconnectedState to maintain its operation log (in fact, DisconnectedState just subscribes to this event + few more related to transactions).

There is no part inManual covering Operations framework now. If you're interested, open Xtensive.Storage solution and look for SessionBound.OpenOperationContext method usage.

1. To make some generic handler always listening this even, implement IModule (e.g. AuditTrailModule). All IModules are notified of certain domain events - you need OnBuilt event, where you can sign up your handler to Domain.SessionOpen event, so it could subscribe to Session.OperationCompleted event. When it's done, it will be enough to register an assembly containing AuditTrailModule in DomainConfiguration.Types to get audit trail working for all the Sessions in the Domain.

2. You can create TChangeData<t> where T: Entity type containing T Changed object property to track changes related to any particular T. DO4 will automatically create & map all the instances of this generic type you need in your domain (although I recommend you to add more strict limitation like "where T: IAuditable").

See http://goo.gl/JYFo - there is a bit more comprehensive description. And see the first answer there - you avoid referential integrity constraints in audit tables. In DO4 this is achieved by applying [Association(OnTargetRemove = OnRemoveAction.None)] on reference property (= no FK will be created for it, and no reference fixup action will be performed on target removal).

1. If you still need this, IAuditable.GetLastChangeDataEntry<t>() can be implemented as an extension method operating nearly as you wrote. Moreover, you can add support for this method in LINQ - by nearly this way: viewtopic.php?f=29&t=5767

P.S. Most likely we'll provide a generic framework for audit trail (and, likely, even undo-redo) in future. But for now this isn't scheduled.

Alex (Xtensive) wrote:

Forgot to add: I recommend you to store change data inside audit record in non-relational structures (e.g. as IChangeSet TChangeData<t>.Changes storing the actual data in persistent private byte[] SerializedChanges field). Likely, you won't query for it, i.e. it's just for history & recovery, so it's much easier to store it inside regular .NET objects.

Alex Kofman wrote:

I'd suggest you to add persistent reference from Company to last (actual) DataChange. It will allow to operate with versioned data more effectively:

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

        [Field]
        [Association(OnOwnerRemove = OnRemoveAction.Cascade,
                     OnTargetRemove = OnRemoveAction.Deny)]
        private EntitySet<TCompanyChangedData> ChangedDataCollection { get; set; }

        [Field]
        public TCompanyChangedData DataChange { get; set; }

        public String CorporateName
        {
            get { return DataChange.CorporateName; }
            set
            {
                DataChange = new TCompanyChangedData
                    {
                        CorporateName = value,
                        LegalRepresentative = DataChange.LegalRepresentative
                    };
                ChangedDataCollection.Add(DataChange);                    
            }
        }
    }

Note, that by default you can not use CorporateName in LINQ queries, you can just do following:

from company in Query.All<TCompany>()
where company.DataChange.CorporateName == "My company"
select company

If you want to write such queries

from company in Query.All<TCompany>()
where company.CorporateName == "My company"
select company

you need to use some advanced method described here.