Pad left or right with string.format (not padleft or padright) with arbitrary string

Can I use String.Format() to pad a certain string with arbitrary characters?

Console.WriteLine("->{0,18}<-", "hello");
Console.WriteLine("->{0,-18}<-", "hello");

returns 

->             hello<-
->hello             <-

I now want the spaces to be an arbitrary character. The reason I cannot do it with padLeft or padRight is because I want to be able to construct the format string at a different place/time then the formatting is actually executed.

--EDIT--
Seen that there doesn't seem to be an existing solution to my problem I came up with this (after Think Before Coding's suggestion)
--EDIT2--
I needed some more complex scenarios so I went for Think Before Coding's second suggestion

[TestMethod]
public void PaddedStringShouldPadLeft() {
    string result = string.Format(new PaddedStringFormatInfo(), "->{0:20:x} {1}<-", "Hello", "World");
    string expected = "->xxxxxxxxxxxxxxxHello World<-";
    Assert.AreEqual(result, expected);
}
[TestMethod]
public void PaddedStringShouldPadRight()
{
    string result = string.Format(new PaddedStringFormatInfo(), "->{0} {1:-20:x}<-", "Hello", "World");
    string expected = "->Hello Worldxxxxxxxxxxxxxxx<-";
    Assert.AreEqual(result, expected);
}
[TestMethod]
public void ShouldPadLeftThenRight()
{
    string result = string.Format(new PaddedStringFormatInfo(), "->{0:10:L} {1:-10:R}<-", "Hello", "World");
    string expected = "->LLLLLHello WorldRRRRR<-";
    Assert.AreEqual(result, expected);
}
[TestMethod]
public void ShouldFormatRegular()
{
    string result = string.Format(new PaddedStringFormatInfo(), "->{0} {1:-10}<-", "Hello", "World");
    string expected = string.Format("->{0} {1,-10}<-", "Hello", "World");
    Assert.AreEqual(expected, result);
}

Because the code was a bit too much to put in a post, I moved it to github as a gist:
http://gist.github.com/533905#file_padded_string_format_info

There people can easily branch it and whatever :)

From stackoverflow

• Edit: I misunderstood your question, I thought you were asking how to pad with spaces.

  What you are asking is not possible using the string.Format alignment component; string.Format always pads with whitespace. See the Alignment Component section of MSDN: Composite Formatting.

  According to Reflector, this is the code that runs inside StringBuilder.AppendFormat(IFormatProvider, string, object[]) which is called by string.Format:

  int repeatCount = num6 - str2.Length;
  if (!flag && (repeatCount > 0))
  {
      this.Append(' ', repeatCount);
  }
  this.Append(str2);
  if (flag && (repeatCount > 0))
  {
      this.Append(' ', repeatCount);
  }
  

  As you can see, blanks are hard coded to be filled with whitespace.

  configurator : I misunderstood the question...

  borisCallens : It is possible with numbers .. I would think it realy stupid if it is possible with numbers and not with strings.

  configurator : How is it possible with numbers?

  borisCallens : I was kind of lying there. But you can do the following: Console.WriteLine("->{0:00000}<-", 12); That would give you ->00012<-

  borisCallens : I see your edit there ;) Thanks for going the extra mile to check the internal code for me. Please have look at my solution in OP. Looks rather solid to me.

• You could encapsulate the string in a struct that implements IFormattable

  public struct PaddedString : IFormattable
  {
     private string value;
     public PaddedString(string value) { this.value = value; }
  
     public string ToString(string format, IFormatProvider formatProvider)
     { 
        //... use the format to pad value
     }
  
     public static explicit operator PaddedString(string value)
     {
       return new PaddedString(value);
     }
  }
  

  Then use this like that :

   string.Format("->{0:x20}<-", (PaddedString)"Hello");
  

  result:

  "->xxxxxxxxxxxxxxxHello<-"
  

• There is another solution.

  Implement IFormatProvider to return a ICustomFormatter that will be passed to string.Format :

  public class StringPadder : ICustomFormatProvider
  {
    public string Format(string format, object arg,
         IFormatProvider formatProvider)
    {
       // do padding for string arguments
       // use default for others
    }
  }
  
  public class StringPadderFormatProvider : IFormatProvider
  {
    public ICustomFormatProvider GetFormat(Type type)
    { 
       if (formatType == typeof(ICustomFormatProvider))
          return new StringPadder();
  
       return null;
    }
    public static readonly IFormatProvider Default =
       new StringPadderFormatProvider();
  }
  

  Then you can use it like this :

  string.Format(StringPadderFormatProvider.Default, "->{0:x20}<-", "Hello");
  

  borisCallens : This one allows for multiple arguments to be formatted. Updated OP.

  demokritos : parameter for GetFormat should be (Type formatType) rather than (Type type) I reckon.