Is there a "String.Format" that can accept named input parameters instead of index placeholders? [duplicate]

If you don't have C#6 available in your project you can use Linq's .Aggregate():

    var str = "Her name is @name and she's @age years old";

    var parameters = new Dictionary<string, object>();
    parameters.Add("@name", "Lisa");
    parameters.Add("@age", 10);

    str = parameters.Aggregate(str, (current, parameter)=> current.Replace(parameter.Key, parameter.Value.ToString()));

If you want something matching the specific syntax in the question you can put together a pretty simple class based on Aggregate:

public class StringFormatter{

    public string Str {get;set;}

    public Dictionary<string, object> Parameters {get;set;}

    public StringFormatter(string p_str){
        Str = p_str;
        Parameters = new Dictionary<string, object>();
    }

    public void Add(string key, object val){
        Parameters.Add(key, val);
    }

    public override string ToString(){
        return Parameters.Aggregate(Str, (current, parameter)=> current.Replace(parameter.Key, parameter.Value.ToString()));
    }

}

Usable like:

var str = new StringFormatter("Her name is @name and she's @age years old");
str.Add("@name", "Lisa");
str.Add("@age", 10);

Console.WriteLine(str);

Note that this is clean-looking code that's geared to being easy-to-understand over performance.

If you are ok assigning a local variable that contains the data you use to replace the template parameters, you can use the C# 6.0 string interpolation feature.

The basic principle is that you can do fairly advanced string replacement logic based on input data.

Simple example:

string name = "John";
string message = $"Hello, my name is {name}."

Complex example:

List<string> strings = ...
string summary = $"There are {strings.Count} strings. " 
  + $"The average length is {strings.Select(s => s.Length).Average()}"

Drawbacks:

• No support for dynamic templates (e.g. from a resources file)

(Major) advantages:

• It enforces compile time checks on your template replacement.

A nice open source solution that has almost the same syntax, is Mustache. It has two available C# implementations from what I could find - mustache-sharp and Nustache.

I have worked with mustache-sharp and found that it does not have the same power as the string interpolation, but comes close. E.g. you can do the following (stolen from it's github page).

Hello, {{Customer.Name}}
{{#newline}}
{{#newline}}
{{#with Order}}
{{#if LineItems}}
Here is a summary of your previous order:
{{#newline}}
{{#newline}}
{{#each LineItems}}
    {{ProductName}}: {{UnitPrice:C}} x {{Quantity}}
    {{#newline}}
{{/each}}
{{#newline}}
Your total was {{Total:C}}.
{{#else}}
You do not have any recent purchases.
{{/if}}
{{/with}}

With C# 6 you can use String Interpolation to directly add variables into a string.

For example:

string name = "List";
int age = 10;

var str = $"Her name is {name} and she's {age} years old";

Note, the use of the dollar sign ($) before the string format.

So why not just Replace?

string str = "Her name is @name and she's @age years old";
str = str.Replace("@name", "Lisa");
str = str.Replace("@age", "10");

There is no built in way to do this, but you can write a class that will do it for you.
Something like this can get you started:

public class ParameterizedString
{
    private string _BaseString;
    private Dictionary<string, string> _Parameters;

    public ParameterizedString(string baseString)
    {
        _BaseString = baseString;
        _Parameters = new Dictionary<string, string>();
    }

    public bool AddParameter(string name, string value)
    {
        if(_Parameters.ContainsKey(name))
        {
            return false;
        }
        _Parameters.Add(name, value);
        return true;
    }

    public override string ToString()
    {
        var sb = new StringBuilder(_BaseString);
        foreach (var key in _Parameters.Keys)
        {
            sb.Replace(key, _Parameters[key]);
        }
        return sb.ToString();
    }
}

Note that this example does not force any parameter name convention. This means that you should be very careful picking your parameters names otherwise you might end up replacing parts of the string you didn't intend to.

string interpolation is a good solution however it requires C#6.

In such case I am using StringBuilder

var sb = new StringBuilder();

sb.AppendFormat("Her name is {0} ", "Lisa");
sb.AppendFormat("and she's {0} years old", "10");
// You can add more lines

string result = sb.ToString();

You can also use expressions with C#6's string interpolation:

string name = "Lisa";
int age = 20;
string str = $"Her name is {name} and she's {age} year{(age == 1 ? "" : "s")} old";

    string name = "Lisa";
    int age = 20;
    string str = $"Her name is {name} and she's {age} years old";

This is called an Interpolated String, which is a basically a template string that contains expressions inside of it.