String has how many parameters

Before using String.Format to format a string in C#, I would like to know how many parameters does that string accept?

For eg. if the string was "{0} is not the same as {1}", I would like to know that this string accepts two parameters For eg. if the开发者_开发技巧 string was "{0} is not the same as {1} and {2}", the string accepts 3 parameters

How can I find this efficiently?

String.Format receives a string argument with format value, and an params object[] array, which can deal with an arbitrary large value items.

For every object value, it's .ToString() method will be called to resolve that format pattern

EDIT: Seems I misread your question. If you want to know how many arguments are required to your format, you can discover that by using a regular expression:

string pattern = "{0} {1:00} {{2}}, Failure: {0}{{{1}}}, Failure: {0} ({0})";
int count = Regex.Matches(Regex.Replace(pattern, 
    @"(\{{2}|\}{2})", ""), // removes escaped curly brackets
    @"\{\d+(?:\:?[^}]*)\}").Count; // returns 6

As Benjamin noted in comments, maybe you do need to know number of different references. If you don't using Linq, here you go:

int count = Regex.Matches(Regex.Replace(pattern, 
    @"(\{{2}|\}{2})", ""), // removes escaped curly brackets
    @"\{(\d+)(?:\:?[^}]*)\}").OfType<Match>()
    .SelectMany(match => match.Groups.OfType<Group>().Skip(1))
    .Select(index => Int32.Parse(index.Value))
    .Max() + 1; // returns 2

This also address @280Z28 last problem spotted.

Edit by 280Z28: This will not validate the input, but for any valid input will give the correct answer:

int count2 =
    Regex.Matches(
        pattern.Replace("{{", string.Empty),
        @"\{(\d+)")
    .OfType<Match>()
    .Select(match => int.Parse(match.Groups[1].Value))
    .Union(Enumerable.Repeat(-1, 1))
    .Max() + 1;

You'll have to parse through the string and find the highest integer value between the {}'s...then add one.

...or count the number of sets of {}'s.

Either way, it's ugly. I'd be interested to know why you need to be able to figure out this number programatically.

EDIT

As 280Z28 mentioned, you'll have to account for the various idiosyncrasies of what can be included between the {}'s (multiple {}'s, formatting strings, etc.).

I rely on ReSharper to analyze that for me, and it is a pity that Visual Studio does not ship with such a neat feature.