Q: DependencyInjection with a Cache and a Repository that both implement the same interface So I've encountered a minor conundrum while using Dependency Injection today (using Unity) - I have both a repository and a cache that is backed by that repository.  
Here is a very basic demonstration:
public interface IStuffRepo {
  Stuff GetStuff();
}

public class Repo : IStuffRepo {
  public Stuff GetStuff() {
    return get_stuff_from_the_database();  // or something
  }
}

public class StuffCache : IStuffRepo {
  private Stuff _cached;      
  private IStuffRepo _actualRepo;     
  public StuffCache([Dependency] IStuffRepo actualRepo) { _actualRepo = actualRepo; }
  public Stuff GetStuff() {
    if (_cached != null) return cached_stuff;
    _cached = _actualRepo.GetStuff(); return _cached;
  }
}

I was hoping my consumer could then just inject IStuffRepo, and let my DI framework and composition root handle building it up.  I've picked this pattern so that to the consumer the cache and the repo are identical.
I am now trying to figure how to setup the composition root to build this all up.  The only way that I can think of to do this would be:
var cache = new StuffCache(container.Resolve<StuffRepository>());
container.RegisterInstance<IStuffRepository>(cache);

But I usually try to avoid new-ing anything and prefer to use my DI framework to do construction and lifetime management. 
Is this the "accepted" way of doing this?  Is there something in Unity that is geared towards doing this?

A: According to this MSDN doc, If you have a named mapping for the particular instance of the type, the [Dependency] annotation can take a parameter to specify the particular mapping it will use.
