C#: String.Inject() - Format strings by key tokens

I generally prefer to use String.Format() instead of doing a bunch of string additions, but constantly find myself splitting the code onto multiple lines with an appended comment to keep track of the indices:

string myString = string.Format("{0} is {1} and {2} is {3}",

  o.foo, //0

  o.bar, //1

  o.yadi, //2

  o.yada //3

);

Wouldn't it be nice you could instead write something like this?:

string myString = "{foo} is {bar} and {yadi} is {yada}".Inject(o);

Well, now you can - see the string extension method Inject below; it accepts an object, IDictionary or HashTable and replaces the property name/key tokens with the instance values.  Since it uses string.Format internally, it also supports string.Format-like custom formatting:

   1:  using System;

   2:  using System.Text.RegularExpressions;

   3:  using System.Collections;

   4:  using System.Globalization;

   5:  using System.ComponentModel;

   6:   

   7:  [assembly: CLSCompliant(true)]

   8:  namespace StringInject

   9:  {

  10:    public static class StringInjectExtension

  11:    {

  12:      /// <summary>

  13:      /// Extension method that replaces keys in a string with the values of matching object properties.

  14:      /// <remarks>Uses <see cref="String.Format()"/> internally; custom formats should match those used for that method.</remarks>

  15:      /// </summary>

  16:      /// <param name="formatString">The format string, containing keys like {foo} and {foo:SomeFormat}.</param>

  17:      /// <param name="injectionObject">The object whose properties should be injected in the string</param>

  18:      /// <returns>A version of the formatString string with keys replaced by (formatted) key values.</returns>

  19:      public static string Inject(this string formatString, object injectionObject)

  20:      {

  21:        return formatString.Inject(GetPropertyHash(injectionObject));

  22:      }

  23:   

  24:      /// <summary>

  25:      /// Extension method that replaces keys in a string with the values of matching dictionary entries.

  26:      /// <remarks>Uses <see cref="String.Format()"/> internally; custom formats should match those used for that method.</remarks>

  27:      /// </summary>

  28:      /// <param name="formatString">The format string, containing keys like {foo} and {foo:SomeFormat}.</param>

  29:      /// <param name="dictionary">An <see cref="IDictionary"/> with keys and values to inject into the string</param>

  30:      /// <returns>A version of the formatString string with dictionary keys replaced by (formatted) key values.</returns>

  31:      public static string Inject(this string formatString, IDictionary dictionary)

  32:      {

  33:        return formatString.Inject(new Hashtable(dictionary));

  34:      }

  35:   

  36:      /// <summary>

  37:      /// Extension method that replaces keys in a string with the values of matching hashtable entries.

  38:      /// <remarks>Uses <see cref="String.Format()"/> internally; custom formats should match those used for that method.</remarks>

  39:      /// </summary>

  40:      /// <param name="formatString">The format string, containing keys like {foo} and {foo:SomeFormat}.</param>

  41:      /// <param name="attributes">A <see cref="Hashtable"/> with keys and values to inject into the string</param>

  42:      /// <returns>A version of the formatString string with hastable keys replaced by (formatted) key values.</returns>

  43:      public static string Inject(this string formatString, Hashtable attributes)

  44:      {

  45:        string result = formatString;

  46:        if (attributes == null || formatString == null)

  47:          return result;

  48:   

  49:        foreach (string attributeKey in attributes.Keys)

  50:        {

  51:          result = result.InjectSingleValue(attributeKey, attributes[attributeKey]);

  52:        }

  53:        return result;

  54:      }

  55:   

  56:      /// <summary>

  57:      /// Replaces all instances of a 'key' (e.g. {foo} or {foo:SomeFormat}) in a string with an optionally formatted value, and returns the result.

  58:      /// </summary>

  59:      /// <param name="formatString">The string containing the key; unformatted ({foo}), or formatted ({foo:SomeFormat})</param>

  60:      /// <param name="key">The key name (foo)</param>

  61:      /// <param name="replacementValue">The replacement value; if null is replaced with an empty string</param>

  62:      /// <returns>The input string with any instances of the key replaced with the replacement value</returns>

  63:      public static string InjectSingleValue(this string formatString, string key, object replacementValue)

  64:      {

  65:        string result = formatString;

  66:        //regex replacement of key with value, where the generic key format is:

  67:        //Regex foo = new Regex("{(foo)(?:}|(?::(.[^}]*)}))");

  68:        Regex attributeRegex = new Regex("{(" + key + ")(?:}|(?::(.[^}]*)}))");  //for key = foo, matches {foo} and {foo:SomeFormat}

  69:        

  70:        //loop through matches, since each key may be used more than once (and with a different format string)

  71:        foreach (Match m in attributeRegex.Matches(formatString))

  72:        {

  73:          string replacement = m.ToString();

  74:          if (m.Groups[2].Length > 0) //matched {foo:SomeFormat}

  75:          {

  76:            //do a double string.Format - first to build the proper format string, and then to format the replacement value

  77:            string attributeFormatString = string.Format(CultureInfo.InvariantCulture, "{{0:{0}}}", m.Groups[2]);

  78:            replacement = string.Format(CultureInfo.CurrentCulture, attributeFormatString, replacementValue);

  79:          }

  80:          else //matched {foo}

  81:          {

  82:            replacement = (replacementValue ?? string.Empty).ToString();

  83:          }

  84:          //perform replacements, one match at a time

  85:          result = result.Replace(m.ToString(), replacement);  //attributeRegex.Replace(result, replacement, 1);

  86:        }

  87:        return result;

  88:   

  89:      }

  90:   

  91:   

  92:      /// <summary>

  93:      /// Creates a HashTable based on current object state.

  94:      /// <remarks>Copied from the MVCToolkit HtmlExtensionUtility class</remarks>

  95:      /// </summary>

  96:      /// <param name="properties">The object from which to get the properties</param>

  97:      /// <returns>A <see cref="Hashtable"/> containing the object instance's property names and their values</returns>

  98:      private static Hashtable GetPropertyHash(object properties)

  99:      {

 100:        Hashtable values = null;

 101:        if (properties != null)

 102:        {

 103:          values = new Hashtable();

 104:          PropertyDescriptorCollection props = TypeDescriptor.GetProperties(properties);

 105:          foreach (PropertyDescriptor prop in props)

 106:          {

 107:            values.Add(prop.Name, prop.GetValue(properties));

 108:          }

 109:        }

 110:        return values;

 111:      }

 112:   

 113:    }

 114:  }

File downloads:

• StringInjectExtension CS file.
• VisualStudio 2008 project (including 14 unit tests).