Extension method to auto update an entity?

Hey there, I'm currently doing some refactoring and have decided to come up with a generic repository pattern for all of my LightSpeed entities, I'm having not problem with handling Save/Get/Delete ops in a generic way, but when it comes to Update, things are a bit tricky. The below code illustrates my approach to the problem of performing Update in a generic way. Please consider my extension method. Will it suffice? or am I missing something?

Cheers!

public class Repository
{
 private bool ExecuteSafely(Action action)
        {
            bool result = true;

            try
            {
                action();
            }
            catch (Exception ex)
            {
                _Logger.Error("Error while executing a repository operation. {0}", ex.Message);
                result = false;
            }

            return result;
        }

 public bool Update(TUnitOfWork uow, T obj, Func<T, object> idSelector)
        {
            return ExecuteSafely(() =>
            {
                var entity = uow.FindById<T>(idSelector(obj));

                entity.UpdateEntityFrom(obj);

                uow.SaveChanges();
            });
        }
}

public static class LightspeedExtensions
    {
        public static T UpdateEntityFrom<T>(this T entity, T other)
            where T : Entity
        {
            foreach (var fieldInfo in typeof(T).GetFields(BindingFlags.NonPublic | BindingFlags.Instance))
            {
                if (fieldInfo.GetCustomAttributes(typeof(TransientAttribute), true).Length == 0)
                {
                    if (!fieldInfo.GetValue(entity).Equals(fieldInfo.GetValue(other)))
                    {
                        fieldInfo.SetValue(entity, fieldInfo.GetValue(other));
                    }
                }
            }

            return entity;
        }
    }
}

A couple of comments:

• You should use the Metadata extensions rather than reflection to fetch the details about what fields are set on an entity as this will be more precise - see http://www.mindscapehq.com/documentation/lightspeed/Working-with-Metadata/Getting-Class-Information for more detail. This will also safeguard you against the situation where you changing association FK fields directly which bypasses the code for maintaining consistency within the UnitOfWork - this could lead to unexpected/bad behavior.

• Be careful with generically catching Exception, while this is a quick and dirty way of wrapping crashes this isn't a great way of setting up your exception blocks as you should be actually handling expected exception types. Expected exception types which will be thrown out of LightSpeed are LightSpeedException and then the base exception type surfaced by the ADO.NET provider for your database type e.g. SqlException for Sql Server.

Jeremy

Thanks :)

Would you be so kind as to elaborate on your 1st comment? How do I safeguard vs the FK fields scenario you've described?

If you use the Metadata libraries you will avoid this problem :) Basically you just need to avoid setting the FK fields directly. When using the Metadata libraries you will be setting the property values so this triggers the appropriate logic to handle wire-up between entities etc.

Jeremy

Just to clarify,

I need to avoid :

1. fields marked with ReverseAssociationAttribue
2. fields of generic type TrhoughAssociation
3. fields of generic type EntityCollection
4. fields of generic type EntityHolder

Am I correct? :)

Yes, that would be right :)

Jeremy