CODEWITHSUNDEEP
c#.netstringstring-formatting
Punit Singhi
Punit Singhi

Reputation:

How to provide custom string placeholder for string format

I have a string 

string str ="Enter {0} patient name";

I am using string.format to format it.

String.Format(str, "Hello");

Now if i want patient also to be retrieved from some config then I need to change str to something like "Enter {0} {1} name". So it will replace the {1} with second value. The problem is that I want instead of {1} some other format something like {pat}. But when I try to use, it throws an error. The reason I want a different format is that there are lot of files I need to change like this(which may contain {0},{1} etc). So I need a custom placeholder which can be replaced at run-time.

Upvotes: 31

Views: 73927

Answers (10)

Mass Dot Net
Mass Dot Net

Reputation: 2259

If you're using .NET 7 or later, you can use anonymous types and raw string literals to create a relatively elegant text templating code solution:

using System;
                
var data = new
{
    MyString = "a",
    MyInteger = 15,
    MyBoolean = true
};
    
var stringValue = $"""
MyString  = "{data.MyString}"
MyInteger = {data.MyInteger}
MyBoolean = {data.MyBoolean.ToString().ToLowerInvariant()}
""";
        
Console.WriteLine(stringValue);

Here's the output the above code produces:

MyString  = "a"
MyInteger = 15
MyBoolean = true

Upvotes: 0

MagogCZ
MagogCZ

Reputation: 93

var user = new User()
{
    Name = "John",
    Age = 21
};
String result = $"Your name is {user.Name} and your age is {user.Age}";

Upvotes: 2

samwyse
samwyse

Reputation: 2996

I wanted something that worked more like Python's string formatting, so I wrote this: https://gist.github.com/samwyse/b225b32ae1aea6fb27ad9c966b9ca90b

Use it like this:

Dim template = New FormatFromDictionary("{cat} vs {dog}")
Dim d = New Dictionary(Of String, Object) From {
    {"cat", "Felix"}, {"dog", "Rex"}}
Console.WriteLine(template.Replace(d)) ' Felix vs Rex

Upvotes: 0

Ole K
Ole K

Reputation: 869

You can also use the example from Marc Gravell and Extend the String class object:

public static class StringExtension
{
    static readonly Regex re = new Regex(@"\{([^\}]+)\}", RegexOptions.Compiled);
    public static string FormatPlaceholder(this string str, Dictionary<string, string> fields)
    {
        if (fields == null)
            return str;

        return re.Replace(str, delegate(Match match)
        {
            return fields[match.Groups[1].Value];
        });

    }
}

Example usage:

String str = "I bought a {color} car";
Dictionary<string, string> fields = new Dictionary<string, string>();
fields.Add("color", "blue");

str.FormatPlaceholder(fields));

Upvotes: 2

Magnus Lindhe
Magnus Lindhe

Reputation: 7327

You might want to check out FormatWith 2.0 by James Newton-King. It allows you to use property names as formatting tokens such as this:

var user = new User()
{
    Name = "Olle Wobbla",
    Age = 25
};

Console.WriteLine("Your name is {Name} and your age is {Age}".FormatWith(user));

You can also use it with anonymous types.

UPDATE: There is also a similar solution by Scott Hanselman but it is implemented as a set of extension methods on Object instead of String.

UPDATE 2012: You can get Calrius Consulting's NETFx String.FormatWith Extension Method NuGet package on NuGet.org

UPDATE 2014: There is also StringFormat.NET and littlebit's StringFormat

Upvotes: 57

Bryan Legend
Bryan Legend

Reputation: 6896

Here's another version of this that I found here: http://www.reddit.com/r/programming/comments/bodml/beef_up_params_in_c_5_to_solve_lambda_abuse/c0nrsf1

Any solution to this is going to involve reflection, which is less than ideal, but here's his code with some of the other major performance issues resolved. (No error checking. Add it if you like.):

1) Uses direct runtime reflection, no DataBinder overhead

2) Doesn't use regular expressions, uses a single-pass parse and state.

3) Doesn't convert the string into an intermediate string and then convert it again to the final format.

4) Allocates and concatenates with a single StringBuilder instead of newing up strings all over the place and concatenating them into new strings.

5) Removes the stack overhead of calling a delegate for n replace operations.

6) In general is a single pass through that will scale in a relatively linear manner (still some cost for each prop lookup and nested prop lookup, but that's that.)

public static string FormatWith(this string format, object source)
{
    StringBuilder sbResult = new StringBuilder(format.Length);
    StringBuilder sbCurrentTerm = new StringBuilder();
    char[] formatChars = format.ToCharArray();
    bool inTerm = false;
    object currentPropValue = source;

    for (int i = 0; i < format.Length; i++)
    {
        if (formatChars[i] == '{')
            inTerm = true;
        else if (formatChars[i] == '}')
        {
            PropertyInfo pi = currentPropValue.GetType().GetProperty(sbCurrentTerm.ToString());
            sbResult.Append((string)(pi.PropertyType.GetMethod("ToString", new Type[]{}).Invoke(pi.GetValue(currentPropValue, null), null)));
            sbCurrentTerm.Clear();
            inTerm = false;
            currentPropValue = source;
        }
        else if (inTerm)
        {
            if (formatChars[i] == '.')
            {
                PropertyInfo pi = currentPropValue.GetType().GetProperty(sbCurrentTerm.ToString());
                currentPropValue = pi.GetValue(source, null);
                sbCurrentTerm.Clear();
            }
            else
                sbCurrentTerm.Append(formatChars[i]);
        }
        else
            sbResult.Append(formatChars[i]);
    }
    return sbResult.ToString();
}

Upvotes: 2

mujtaba Hyder
mujtaba Hyder

Reputation: 49

object[] myInts = new int[] {8,9};

However you can get away with:

object[] myInts = new string[] { "8", "9" }; 
string bar = string.Format("{0} {1}", myInts);

Upvotes: 3

Chansik Im
Chansik Im

Reputation: 1493

I saw all the answers above, yet, couldn't get the question right :)

Is there any particular reason why the following code does not meet your requirement?

string myFirstStr = GetMyFirstStrFromSomewhere();
string mySecondStr = GetMySecondStrFromSomewhere();

string result = "Enter " + myFirstStr + " " + mySecondStr + " name";

Upvotes: 2

Dean Povey
Dean Povey

Reputation: 9446

You are probably better off using Replace for the custom field and Format for the rest, like:

string str = "Enter {0} {pat} name";
String.Format(str.Replace("{pat}", "Patient"), "Hello");

Upvotes: 2

Marc Gravell
Marc Gravell

Reputation: 1063338

Regex with a MatchEvaluator seems a good option:

static readonly Regex re = new Regex(@"\{([^\}]+)\}", RegexOptions.Compiled);
static void Main()
{
    string input = "this {foo} is now {bar}.";
    StringDictionary fields = new StringDictionary();
    fields.Add("foo", "code");
    fields.Add("bar", "working");

    string output = re.Replace(input, delegate (Match match) {
        return fields[match.Groups[1].Value];
    });
    Console.WriteLine(output); // "this code is now working."
}

Upvotes: 21

Related Questions