查找.NET字符串结果的格式化部分

Question

I'm using string.Format in a data-driven fashion - I know how many objects to format there are, but nothing else - and I'd like to find out which parts of the result are formatted objects and which parts come verbatim from the format string. (I intend to display the formatted result in the UI with the formatted parts "hot", so that they can be hovered over and clicked on to activate some UI related to the object that produced them.)

For example, suppose I call this hypothetical formatting function, passing in a particular format string, and (string)"fred" as object 0, and (int)50 as object 1. And suppose the result is (fred) . I'd like to be able to determine that the 4 chars starting at index 1 are the result of formatting object 0, and that object 1 wasn't formatted. (Clearly the format string in this case was something like "{0}" .)

Is there some built-in way of doing this?

(This feels like a generic .NET/CLR question - but in case it's relevant, I'm using C#.)

Answer 1

If you know just the format string and the resulting string, but not the parameters which were formatted, it is not possible to find them in the resulting string.

For instance, the following lines produce the same result:

string.Format("{0}{1}", "a", "bc")
string.Format("{0}{1}", "ab", "c")

Answer 2

You could also work with regular expressions, more specifically using a MatchEvaluator , so you could keep track of those indexes. I made an example, which you can customize for your application:

static void Main(string[] args)
{
    var arg0 = (string)"fred";
    var arg1 = (int)50;
    var format = "{0}";

    var result = Format(format, arg0, arg1);
    for(int index = 0; index < result.Arguments.Length; index++)
    {
        if(String.IsNullOrEmpty(result.Arguments[index].Capture))
        {
            Console.WriteLine(
                "Argument {0} with value {1} was unused", 
                index, result.Arguments[index].Value);
        }
        else
        {
            Console.WriteLine(
                "Argument {0} with value {1} was used, starting at index {2}", 
                index, result.Arguments[index].Value,
                result.Arguments[index].Index);
        }
    }
}

static Transformation Format(string format, params object[] args)
{
    var value = new Transformation
    {
        Format    = format,
        Arguments = (args ?? new object[]{})
            .Select (o => new Argument{ Value = o })
            .ToArray()
    };

    value.Result = Regex.Replace(format, @"{(\d+)}", (match) =>
    {
        int index = Convert.ToInt32(match.Groups[1].Value);
        if (index > args.Length) return "";

        var @this = args[index];
        var result = @this == null ? "" : @this.ToString();

        value.Arguments[index].Index   = match.Index;
        value.Arguments[index].Capture = match.Value;
        value.Arguments[index].Length  = result.Length;

        return result;
    });

    return value;
}

class Transformation
{
    public string Format        { get; set; }
    public string Result        { get; set; }
    public Argument[] Arguments { get; set; }
}

class Argument
{
    public object Value         { get; set; }
    public int Index            { get; set; }
    public int Length           { get; set; }
    public string Capture       { get; set; }
}

Answer 3

In the end I wrote my own thing, as it sounded like there wasn't any built-in way of getting what I wanted, whether from an existing function or by hooking into something somewhere.

Firstly, an object to store the location in the result where each object's string was inserted:

    public class FormattedStringPart
    {
        public int ObjectIndex { get; private set; }
        public int StartIndex { get; private set; }
        public int Length { get; private set; }

        public FormattedStringPart(int objectIndex, int startIndex, int length)
        {
            ObjectIndex = objectIndex;
            StartIndex = startIndex;
            Length = length;
        }
    }

Then the function itself works through the format string, building up a StringBuilder is it goes. Either it adds chars verbatim, or it finds a format part, which it formats with string.Format keeping track of the indexes so it can make a new FormattedStringPart for the insertion. (The key thing that makes this quite easy is that you can just hand off the format part and the entire array of object to string.Format - so there's no need to look carefully at the format part to check for validity. Just pass it to string.Format and see what happens.)

    public static string FormatString(string format, 
                                      object[] args, 
                                      out FormattedStringPart[] formattedParts)
    {
        var parts = new List<FormattedStringPart>();
        var result = new StringBuilder();

        int i = 0;
        while (i < format.Length)
        {
            char c = format[i];

            if (c == '{')
            {
                int j = format.IndexOf('}', i);
                if (j < 0)
                    throw new FormatException("Missing '}'");

                int startIndex = result.Length;

                result.AppendFormat(format.Substring(i, (j - i) + 1), args);

                ++i;

                // the AppendFormat call should have ensured there's a
                // valid number following...
                int objectIndex = 0;
                while (format[i] >= '0' && format[i] <= '9')
                {
                    objectIndex *= 10;
                    objectIndex += (int)(format[i] - '0');

                    ++i;
                }

                parts.Add(new FormattedStringPart(objectIndex, 
                                                  startIndex, 
                                                  result.Length - startIndex));

                i = j + 1;
            }
            else
            {
                result.Append(c);
                ++i;
            }
        }

        if (parts.Count == 0)
            formattedParts = null;
        else
            formattedParts = parts.ToArray();

        return result.ToString();
    }

Eagle-eyed string.Format fans will note that this isn't quite exactly like string.Format - this is not (yet?) important in my situation.