ASP.NET localization

When localizing an ASP.NET app (MVC or webforms, does't matter), how do you handle HTML strings in your resource file? In particular, how do you handle something like a paragraph with an embedded dynamic link? My strategy so far has been to use some sort of placeholder for the href attribute value and replace it at runtime with the actual URL, but this seems hokey at best.

As an example, suppose my copy is:

Thank you for registering. Click 
<a href="{prefs_url}">here</a> 
to update your preferences.
To login and begin using the app, click 
<a href="{login_url}">here</a>.

Using MVC (Razor), what could be a simple:

<p>@Resources.Strings.ThankYouMessage</p>

now turns into

<p>@Resources.Strings.ThankYouMessage
     .Replace("{prefs_url}", Url.Action("Preferences", "User"))
     .Replace("{login_url}", Url.Action("Login", "User"))</p>

It's not horribl开发者_如何学JAVAe, but I guess I'm just wondering if there's a better way?

---

There isn't really a better way, beyond some syntax and performance tweaks. For example, you might add a cache layer so that you aren't doing these string operations for every request. Something like this:

<p>@Resources.LocalizedStrings.ThankYouMessage</p>

which calls a function perhaps like this:

Localize("ThankYouMessage", Resources.Strings.ThankYouMessage)

which does a hashtable lookup by resource + culture:

//use Hashtable instead of Dictionary<> because DictionaryBase is not thread safe.
private static System.Collections.Hashtable _cache = 
    System.Collections.Hashtable.Synchronized(new Hashtable());

public static string Localize(string resourceName, string resourceContent) {
    string cultureName = System.Threading.Thread.CurrentThread.CurrentCulture.Name;

    if (string.IsNullOrEmpty(resourceName))
        throw new ArgumentException("'resourceName' is null or empty.");

    string cacheKey = resourceName + "/" + cultureName;

    object o = _cache[cacheKey];

    if (null == o) { //first generation; add it to the cache.
        _cache[cacheKey] = o = ReplaceTokensWithValues(resourceContent);
    }

    return o as string;
}

Notice the call to ReplaceTokensWithValues(). That is the function that contains all the "not horrible" string-replacement fiffery:

public static string ReplaceTokensWithValues(string s) {
    return s.Replace("{prefs_url}", Url.Action("Preferences", "User"))
       .Replace("{login_url}", Url.Action("Login", "User")
       .Replace("{any_other_stuff}", "random stuff");
}

By using a caching approach as above, ReplaceTokensWithValues() is only called once per culture, per resource for the lifetime of the application--instead of once per resource call. The difference may be on the order of 100 vs. 1,000,000.