Convert string to given regex pattern

As already said, this is question has nothing in common with regex. Well, except pattern, but you using it in diferent context. You need just to format some strings, using some pattern.

You could use this function for example:

public string ConvertToFormat(string strToFormat, string pattern)
{
  if (pattern.Count(c => c == 'X') != strToFormat.Length)
    throw new ArgumentException("Number of placeholders in pattern is different from number of characters in the input string!");
  StringBuilder sb = new StringBuilder();
  int j = 0;
  for(int i = 0; i < pattern.Length; i++)
    if (pattern[i] == 'X')
    {
      sb.Append(strToFormat[j]);
      j++;
    }
    else
      sb.Append(pattern[i]);

  return sb.ToString();
}

and use like this:

string result = ConvertToFormat("1234567890", "XXXX-XXXX-XX");
result = ConvertToFormat("1234567890", "XXX-XXX-XXX-X");
result = ConvertToFormat("1234567890", "XXX=XXX=XXX=X");

UPDATE

Dynamic solution with regtex:

public string RegexConvertToFormat(string strToFormat, int blockSize, char separator)
{
  return Regex.Replace("1235645847", ".{" + blockSize + "}" , "$&" + separator).TrimEnd(separator);
}

Usage:

string s = RegexConvertToFormat("1234567890", 4, '-');
s = RegexConvertToFormat("1234567890", 3, '-');
s = RegexConvertToFormat("1234567890", 3, '=');

string input="123456789";
var pattern="XXX-XXX=XXX";

var reg=new Regex(new string('N',input.Length).Replace("N","(\\w)"));//1.
var regX=new Regex("X");
for (int i = 1; i <= input.Length; i++)
{
    pattern=regX.Replace(pattern,"$"+i.ToString(),1);//2.
}
Console.WriteLine( reg.Replace(input,pattern));

1. replace input 123456789 to (\w)(\w)(\w)(\w)(\w)(\w)(\w)(\w) multi groups

2. replace pattern XXX-XXX=XXX to groups replacement $1$2$3-$4$5$6=$7$8$9

A simple Linq will do:

public static string ApplyPattern(string value, string mask) {
  if (null == value)
    throw new ArgumentNullException("value");
  else if (null == mask)
    throw new ArgumentNullException("mask");
  else if (mask.Count(c => c == 'X') != value.Length)
    throw new ArgumentException("Inconsistent mask", "mask"); 

  int index = 0;

  // index++ - side effect - which is, however, safe in the context
  return string.Concat(mask
    .Select(c => c == 'X' ? value[index++] : c));
}

Demo:

string[] testMasks = new string[] {
  "XXXX-XXXX-XX",
  "XXX-XXX-XXX-X",
  "XXX=XXX=XXX=X",
  "XX-XXX-X-XXXX",
  "+XX-=XXX-X--XXXX",
  "+(XX)=XXX-X--XXXX?",
};

string report = string.Join(Environment.NewLine, testMasks
  .Select(mask => $"{mask,20} -> {ApplyPattern("1234567890", mask)}"));

Console.Write(report);

Outcome:

XXXX-XXXX-XX         -> 1234-5678-90
XXX-XXX-XXX-X        -> 123-456-789-0
XXX=XXX=XXX=X        -> 123=456=789=0
XX-XXX-X-XXXX        -> 12-345-6-7890
+XX-=XXX-X--XXXX     -> +12-=345-6--7890
+(XX)=XXX-X--XXXX?   -> +(12)=345-6--7890?