Configuring newly created entities by overriding its OnSaving method

Hello,

Consider an entity with numerous relationships, including security, preferences and those lovely things. When the entity is created for the very first time, default values need to be populated. In principal something similar to this

public class MyEntity : Entity<long> 
{
    public EntityCollection<Permission> Permission { get; set; }
    public EntityCollection<Preference> Preferences { get; set; }

    protected override void OnSaving(CancelEventArgs e)
    {
        if (EntityState.New == EntityState)
        {
            // Add permissions
            // Add preferences 
            // and other stuff    
        }
        base.OnSaving(e);
    }
}

However doing so by overriding the OnSaving method of the entity doesn't work, nothing gets added. Since I'm working against a IUnitOfWork to improve the reuse of the entity across projects, doing so in the SaveChanges method of an IUnitOfWork is less than ideal.

Thanks, Werner

OnSaving is fired when we are actually in the process of saving the entity, so this is too late to commit any further changes to the UnitOfWork as we have already built up the change-set. If you called SaveChanges twice I suspect this would work.

I will have a look at adding in a new event which is hooked earlier in the lifecycle which would allow you the control you are looking for here - this does seem like a reasonable scenario. Hopefully I should have this in tomorrow for you, will keep you posted.

Jeremy

I have added a new event on Entity called Enlisted which will be fired for every entity in the UnitOfWork when SaveChanges is called, so this will allow you to perform any pre-save logic as were hoping to do in the saving event. As this fires just before we decide what entities to persist you can make further modifications to the UnitOfWork at this point.

To use this you will need to grab the next nightly build and then set the following compatibility flag to enable the functionality - e.g.

UnitOfWork.Context.CompatibilityOptions |= LightSpeedCompatibilityOptions.EnableCandidateFixes;

You can then wire up to the event - e.g.

entity.Enlisted += delegate(object sender, EventArgs e)
{
  // logic here
};

I would be keen to get your feedback to understand if this caters appropriately for your scenario before I look at making this more generally available.

Jeremy

Thanks Jeremy. It seems to work for my original problem.

Feedback

1. Using intelligence, the event name doesn't tell me much about its purpose and when it will be fired.
2. The event requires to be initialized whenever I create an entity instance (be it new or a result from a query) but before it can be saved. It can become rather complex when you have a large number of entities and data access code spread over several projects. Alternatives to this may include to actually overwrite a method (similiar to OnSaving) in the entity itself.
3. The requirement I have is specific to types of entities, or to be more precise, any entity that implements an interface ISecurable (which uses the feature discussed in the post "Injecting expressions into UnitOfWork Query"). It may be beneficial if one could register the event as a class attribute on ISecurable (similiar to Hibernate annotations), or register an listener/interceptor per unit of work or globally (like with NHibernate or Hibernate).

Background:

Consider a solution with several applications that use a single data access assembly. The applications may have their own entities which may extend entities in the data access assembly. The data access assembly contains entities common to many applications, including entities related to security and auditing which uses features described in posts LightSpeed and Generics and Injecting expressions into UnitOfWork Query.

Lets consider entities that require security. In the data access assembly an interface ISecurable is defined that has the following:

1. a query filter such that unauthorized users cannot access the data
2. many permissions to define who can have access to the ISecurable entity and who can't
3. one principal object to define who "owns" the ISecurable entity

For any entity that requires security, the following additional logic is required.

1. unauthorized users may not update or delete the entity
2. default permissions are added when entity is first saved
3. validation prevents an ISecurable entity from being modified which may result in no owner and no permissions.

I have other interfaces to represent a wealth of requirements:

1. IAuditable, requires entities to keep track of what was changed by whom and when
2. INotifiable, requires entities to notify others when it was created, deleted or modified

The challenge is to handle these requirements transparently while minimizing configuration, boilerplate code and minimizing dependent code scattered across classes, projects and configuration. The feature "Injecting expressions into UnitOfWork Query" has helped a great deal to reuse queries. I'd like to see LightSpeed expand that feature to inject logic when entities that implement an interface are being created, updated and deleted.