Fun With Extension Methods - Extending Object Part 1

VB.NET
<DebuggerDisplayAttribute("Bug: {Title} Priority: {Priority}")> _
Public Class Bug

End Class    

C#
[DebuggerDisplayAttribute("Bug: {Title} Priority: {Priority}")]
public class Bug
{

}      

VB.NET
<DebuggerDisplay("{DebugInfo()}")> _
Public Class Bug

End Class    

C#
[DebuggerDisplay("{DebugInfo()}")]
public class Bug
{

}      

VB.NET
Private Function DebugInfo() As String
  Dim result As String = String.Format("Count: {0}. ", Count)
  If this.Items.Count > 0 Then
    result += string.Format("First item: {0}.", this.Items(0).ToString())
  End If
  return result
End Function

C#
private string DebugInfo()
{
  string result = string.Format("Count: {0}. ", Count);
  if (this.Items.Count > 0)
  {
    result += string.Format("First item: {0}.", this.Items[0].ToString());
  }
  return result;
} 

VB.NET
Dim result As String = _
           String.Format("Bug: {Title} Priority: {Priority}", myBug)
C#
string result = 
              string.Format("Bug: {Title} Priority: {Priority}", myBug);

string result = myPerson.ToString("Person: {Name} {SomeLiteral}");

string result = 
    "Person: {Id} First address: {Addresses[0].Street}".FormatWith(myPerson);

public static class ObjectExtensions
{
  // The ToString overloads are inspired by:
  // A Smarter (or Pure Evil) ToString with Extension Methods
  // FormatWith 2.0 - String formatting with named variables
  // This implementation is a combination of both: the regular expressions 
  // from Scott Hanselman combined with the DataBinder.Eval idea 
  // from James Newton-King.
  
  /// <summary>
  /// Enables you to get a string representation of the object using string 
  /// formatting with property names, rather than index based values.
  /// </summary>
  /// <param name="anObject">The object being extended.</param>
  /// <param name="aFormat">The formatting string, like "Hi, my name 
  /// is {FirstName} {LastName}".</param>
  /// <returns>A formatted string with the values from the object replaced 
  /// in the format string.</returns>
  /// <remarks>To embed a pair of {} on the string, simply double them: 
  /// "I am a {{Literal}}".</remarks>
  public static string ToString(this object anObject, string aFormat)
  {
    return ObjectExtensions.ToString(anObject, aFormat, null);
  }

  /// <summary>
  /// Enables you to get a string representation of the object using string 
  /// formatting with property names, rather than index based values.
  /// </summary>
  /// <param name="anObject">The object being extended.</param>
  /// <param name="aFormat">The formatting string, like "Hi, my name is 
  /// {FirstName} {LastName}".</param>
  /// <param name="formatProvider">An System.IFormatProvider that 
  /// provides culture-specific formatting information.</param>
  /// <returns>A formatted string with the values from the object replaced in 
  /// the format string.</returns>
  /// <remarks>To embed a pair of {} on the string, simply double them: 
  /// "I am a {{Literal}}".</remarks>
  public static string ToString(this object anObject, string aFormat, 
       IFormatProvider formatProvider)
  {
    StringBuilder sb = new StringBuilder();
    Type type = anObject.GetType();
    Regex reg = new Regex(@"({)([^}]+)(})", RegexOptions.IgnoreCase);
    MatchCollection mc = reg.Matches(aFormat);
    int startIndex = 0;
    foreach (Match m in mc)
    {
      Group g = m.Groups[2];
      int length = g.Index - startIndex - 1;
      sb.Append(aFormat.Substring(startIndex, length));

      string toGet = string.Empty;
      string toFormat = string.Empty;
      int formatIndex = g.Value.IndexOf(":");
      if (formatIndex == -1)
      {
        toGet = g.Value;
      }
      else
      {
        toGet = g.Value.Substring(0, formatIndex);
        toFormat = g.Value.Substring(formatIndex + 1);
      }

      if (!toGet.StartsWith("{")) // Make sure we're not dealing 
                                  // with a string literal wrapped in {}
      {

        // Get the object's value using DataBinder.Eval.
        object resultAsObject = DataBinder.Eval(anObject, toGet);

        // Format the value based on the incoming formatProvider 
        // and format string
        string result = string.Format(formatProvider, 
                     "{0:" + toFormat + "}", resultAsObject);

        sb.Append(result);
      }
      else         // Property name started with a { which means we treat it 
                   // as a literal.
      {
        sb.Append(g.Value);
      }
      startIndex = g.Index + g.Length + 1;
    }
    if (startIndex < aFormat.Length)
    {
      sb.Append(aFormat.Substring(startIndex));
    }
    return sb.ToString();
  }
}
        

[TestMethod]
public void FormatString()
{
  Person myPerson = new Person("Imar", "Spaanjaars");
  string result = myPerson.ToString(
            "FirstName: {FirstName} with LastName: {LastName}");
  Assert.AreEqual("FirstName: Imar with LastName: Spaanjaars", result);
}