Question

We have a project that uses an Interceptor object to tell NHibernate to do some general works before saving an entity.This interceptor has a single task to do.Now there’s another task that should be added to this interceptor (NHibernate doesn’t support multiple interceptors) but I don’t want to make this interceptor complicated instead I would like to use composition pattern that will manage all registered interceptors.something like this :

public bool Onload(object entity,object id,object[] state,string propertyNames,IType[] types_
{
var result=false;
foreach(var interceptor in _registeredInterceptors)
result=result || interceptor.OnLoad(entity,id,state,propertyNames,types);
return result;
}

public bool OnFlushDirty(object entity,object id,object[] state,string propertyNames,IType[] types_
{
var result=false;
foreach(var interceptor in _registeredInterceptors)
result=result || interceptor.OnFlushDirty(entity,id,state,propertyNames,types);
return result;
}

by looking at this code I realized that there might be a better way preventing me from repeating myself.
the question is can I make this code more simpler and abstract using Lambda expressions and yield keyword?

Answer 1

One way of doing it could look like this:

public bool Execute(IList<IInterceptor> interceptors, Func<IInterceptor, bool> func)
{
    bool result = false;
    foreach (IInterceptor interceptor in interceptors)
    {
        result = result || func(interceptor);
    }

    return result;
}

And in the parent interceptor:

public bool Onload(object entity, object id, object[] state, string propertyNames, IType[] types_
{
    return Execute(_registeredInterceptors, x => x.OnLoad(entity, id, state, propertyNames, types);
}

public bool OnFlushDirty(object entity, object id, object[] state, string propertyNames, IType[] types_
{
    return Execute(_registeredInterceptors, x => x.OnFlushDirty(entity, id, state, propertyNames, types);
}

Update

If you want the result type to be generic you could do it like this:

public static T Execute<T>(IList<IInterceptor> interceptors, Func<IInterceptor, T> func)
{   
    T result = default(T);
    foreach (IInterceptor interceptor in interceptors)
    {
        // your logic based on type T
    }

    return T;
}

Execution of the generic version would look exactly the same as of the bool one because of Type inference.

Is this what you had in mind?