Deferred template string interpolation

Question

In C# there is a string interpolation support like this:

$"Constant with {Value}"

which will format this string using in-scope variable Value.

But the following won't compile in current C# syntax.

Say, I have a static Dictionary<string, string> of templates:

templates = new Dictionary<string, string>
{
    { "Key1", $"{Value1}" },
    { "Key2", $"Constant with {Value2}" }
}

And then on every run of this method I want to fill in the placeholders:

public IDictionary<string, string> FillTemplate(IDictionary<string, string> placeholderValues)
{
    return templates.ToDictionary(
        t => t.Key,
        t => string.FormatByNames(t.Value, placeholderValues));
}

Is it achievable without implementing Regex parsing of those placeholders and then a replace callback on that Regex? What are the most performant options that can suit this method as being a hot path?

For example, it is easily achievable in Python:

>>> templates = { "Key1": "{Value1}", "Key2": "Constant with {Value2}" }
>>> values = { "Value1": "1", "Value2": "example 2" }
>>> result = dict(((k, v.format(**values)) for k, v in templates.items()))
>>> result
{'Key2': 'Constant with example 2', 'Key1': '1'}
>>> values2 = { "Value1": "another", "Value2": "different" }
>>> result2 = dict(((k, v.format(**values2)) for k, v in templates.items()))
>>> result2
{'Key2': 'Constant with different', 'Key1': 'another'}

Answer 1

No, it's not possible, instead you should use String.Format.

With String format your string template would look like string template = "The temperature is {0}°C." and then to insert the value you could just:

decimal temp = 20.4m;
string s = String.Format(template, temp);

As shown in the Microsoft examples.

Answer 2

Using an extension method that does a substitution based on regular expressions, I get a good speed up over using multiple Replace calls for each value.

Here is my extension method for expanding brace surrounded variables:

public static class ExpandExt {
    static Regex varPattern = new Regex(@"{(?<var>\w+)}", RegexOptions.Compiled);
    public static string Expand(this string src, Dictionary<string, string> vals) => varPattern.Replace(src, m => vals.TryGetValue(m.Groups[1].Value, out var v) ? v : m.Value);
}

And here is the sample code using it:

var ans = templates.ToDictionary(kv => kv.Key, kv => kv.Value.Expand(values));

Over 10,000 repeating expansions with values at 18 entries and typically only one replacement, I get 3x faster than multiple String.Replace calls.

Answer 3

I think your best alternative to Regular Expressions is doing Replace on each possible Value key, but which is faster would depend on how many values you have and how common replacements for those values are.

var templates = new Dictionary<string, string> {
    { "Key1", "{Value1}" },
    { "Key2", "Constant with {Value2}" }
};

var values = new Dictionary<string, string> { { "Value1", "1" }, { "Value2", "example 2" } };

var ans = templates.ToDictionary(kv => kv.Key, kv => values.Aggregate(kv.Value, (s, v) => s.Replace($"{{{v.Key}}}", v.Value)));

Note that a foreach instead of Aggregate would be marginally faster, again depending on how many entries are in values. Also, pre-building new key and values Arrays with key already surrounded by braces can bring about a 4x speedup, but we are talking about milliseconds in your example.

var subkeys = values.Select(kv => $"{{{kv.Key}}}").ToArray();
var subvals = values.Select(kv => kv.Value).ToArray();

var ans4 = templates.ToDictionary(kv => kv.Key, kv => {
    var final = kv.Value;
    for (int j1 = 0; j1 < subkeys.Length; ++j1)
        final = final.Replace(subkeys[j1], subvals[j1]);
    return final;
});

Of course, if your values array changes with each method call, using two Lists with braces around the keys would be a better storage structure as translating every time will eat up the time savings.