David Hayden is talking about AOP, and he mentioned Caching declaratively, which sturk a chord, and I had to write a post about it. I want to talk about a completely different aspect of declerative coding, how far you should go with it. Just to be clear, this is fake code, and it has little to do with David's post other than using the scenario to make a point.

Let us take the code example that David has:

public class NewsController { private INewsService _service; public NewsController(INewsService service) { _service = service; } [CachingCallHandler] public NewsHeadlineCollection GetLatestNewsHeadlines() { return _service.GetLatestNews(); } }

Now, assume that you want to specify an expiration time? No problem, just put it in the attribute:

What if I want to add a bit of smarts to the caching and only cache costly calls?

Now I want to handle dependencies:

But wait, I have a bit of business logic here as well, if there is a developing story, I want to skip caching altogether:

And now I have a different case, I want to call the GetLatestNewsHeadlines() and get the uncached results, maybe I am building a ticker, and it really need to be up to date. Now I need:

This is a fake scenario, obviously, but just note how each additional business requirements make declerative more complex. I am not showing the code for the CachingCallHanlder, but you can be that somewhere its developer would be groaning for each such new requirement.

For myself, the minute that I put the connection string name hard coded SQL, that went way over the line. Even if I could skip it and use just the table name directly, that would be too much. And what happens if I need expiration from sources that do not support cache dependecies natively?

In short, I really love declerative coding, and I tend to overuse it at times, but it is really important to understand that you probably shouldn't try declerative coding for everything. If the scenario is simple and straightforward, that is a good candidate for ocde reduction and simplification. If it isn't, imperative coding (you know, if and else, as well as a while or two) are going to be more intent revealing, and would be easier to maintain.

/// <summary>
/// Inspect the model and add a caching interceptor if appropriate
/// </summary>
public class CachingInterceptorContributer : IContributeComponentModelConstruction
{
    /// <summary>
    /// Inspect the model and add a caching interceptor if appropriate
    /// </summary>
    public void ProcessModel(IKernel kernel, ComponentModel model)
    {
        bool isRepository = model.Service.IsGenericType &&
            model.Service.GetGenericTypeDefinition() == typeof(IRepository<>);
        if (isRepository == false)
            return;
        Type entityType = model.Service.GetGenericArguments()[0];
        bool cacheable = entityType
              .GetCustomAttributes(typeof(CacheableAttribute),true).Length != 0;

        if(cacheable==false)
            return;
        model.Interceptors.Add(new InterceptorReference(typeof(CachingInterceptor)));
    }
}

/// <summary>
/// Add query caching capabilities
/// </summary>
public class CachingInterceptor : IInterceptor, IOnBehalfAware
{
    private string typeName;
 

    /// <summary>
    /// Intercepts the specified invocation and adds query caching capabilities
    /// </summary>
    /// <param name="invocation">The invocation.</param>
    public void Intercept(IInvocation invocation)
    {
        using(With.QueryCache(typeName))
        {
            invocation.Proceed();
        }
    }
 

    /// <summary>
    /// Sets the intercepted component model.
    /// </summary>
    /// <param name="target">The target.</param>
    public void SetInterceptedComponentModel(ComponentModel target)
    {
        typeName = target.Service.GetGenericArguments()[0].FullName;
    }

}

/// <summary>
/// Registers various add-ons to the container
/// </summary>
public class AdditionalFunctionalityFacility : AbstractFacility
{

      /// <summary>
      /// The actual addition of resolvers
      /// </summary>
      protected override void Init()
      {
        Kernel.AddComponent("caching.interceptor", typeof(CachingInterceptor));
        Kernel.ComponentModelBuilder.AddContributor(new CachingInterceptorContributer()); 
      }
}

I am searching for a tool to help with code reviews. This is something that is done after the fact, not before commits, by the way. Specifically, what I am thinking about is a tool that let me browse checkins into the source control, select one for review, add comments to it, etc.

I wrote the above sentence, and then went to Trac, and took a look at the Timeline view. It seems to be that this may be a way to do it, while handling the code reviews as tickets in Trac as well.

At any rate, I would like to be able to get a tool that says what has changed and needs reviews, or able to give me a diff over more than a single commit. I just thought of a new thing that I would like, something along the line of getting all the changes in this directory from last time that I reviewed it. I can get a diff from subversion, but attempting to understand something with just a diff is non trivial.

Any recommendatiosn about tools for doing this?