As far as I know, this is not configurable. Instead of subclassing, I would probably intercept the default resolver:

Edit: Updated to override GetVirtualPath method instead of GetUrl.

[ModuleDependency(typeof(EPiServer.Web.InitializationModule))]
public class UrlResolverInitializer : IConfigurableModule
{
    public void ConfigureContainer(ServiceConfigurationContext context)
    {
        context.Services.Intercept<UrlResolver>(
            (locator, defaultResolover) => new CustomUrlResolver(defaultResolver));
    }

    public void Initialize(InitializationEngine context) { }
    public void Uninitialize(InitializationEngine context) { }
}

public class CustomUrlResolver : UrlResolver
{
    public CustomUrlResolver(UrlResolver defaultUrlResolver)
    {
        _defaultUrlResolver = defaultUrlResolver;
    }

    public override VirtualPathData GetVirtualPath(ContentReference contentLink, string language, VirtualPathArguments virtualPathArguments)
    {
        var virtualPathData = MyGetVirtualPathFromCacheMethod(contentLink, language, virtualPathArguments);

        if (virtualPathData == null)
        {
            virtualPathData = _defaultUrlResolver.GetVirtualPath(contentLink, language, virtualPathArguments);
            // Add data to cache here
        }

        return virtualPathData;
    }
}

Thanks, Mattias.

Nice and simple solution, and somewhat like I had imagined it, myself. I will try to squeeze it in before the default Commerce and CMS resolvers.

I guess I just hoped for a built-in solution.

Hello again!

I tested this a bit and it seems that the GetVirtualPath method is what should be overridden and cached. The GetUrl method doesn't seem to be called that often internally.

Beware of that VirtualPathArguments parameter. I would probably let the default resolver take care of more advanced arguments with route values, other actions than Index etc. Maybe something like this:

private bool ShouldCacheVirtualPath(VirtualPathArguments virtualPathArguments)
{
    return virtualPathArguments == null
           || (virtualPathArguments.Action == null
           || virtualPathArguments.Action.Equals("index", StringComparison.OrdinalIgnoreCase))
           && virtualPathArguments.RouteValues == null
           && (virtualPathArguments.ContextMode == ContextMode.Default || virtualPathArguments.ContextMode == ContextMode.Undefined);
}

I ended up overriding the abstract UrlResolver class, for now only intercepting the main method, GetVirtualPath.

In that method, I:

1. Make up a cache key, including the VirtualPathArguments parameters (if not null).
2. Look up the URL from cache, or call the default URL resolver through interception.

I also found that calling Url.ContentLink with a LinkItem does not invoke the stack of URL resolvers.