Finding Possible Strings from Series of Numbers
A string implements IEnumerable&lt;char&gt; and has an indexer, so you can iterate it as an array.

You can therefore simplify this:


string[][] StringMapping = new string[number.Length][];
            int LengthIndex = 0;

            foreach (char c in number)
            {
                switch (c)
                {
                    case '2':
                        StringMapping[LengthIndex] = new string[] {"a", "b", "c"};
                 ...



without any other changes to:

string[] StringMapping = new string[number.Length];
            int LengthIndex = 0;

            foreach (char c in number)
            {
                switch (c)
                {
                    case '2':
                        StringMapping[LengthIndex] = "abc";


and your code will work fine.

You could though create a separate method for the mapping as:

private static string GetPattern(char number)
{
  switch (number)
  {
    case '2': return "abc";
    case '3': return "def";
    case '4': return "ghi";
    case '5': return "jkl";
    case '6': return "mno";
    case '7': return "pqrs"; 
    case '8': return "tuv"; 
    case '9': return "wxyz";
    default: throw new InvalidOperationException();
  }
}


So your StringMapping could be initialized as:

string[] stringMapping = number.Select(n =&gt; GetPattern(n)).ToArray();


Some would claim that a Dictionary&lt;char, string&gt; would be better instead of the switch statement. In a localized scenario for instance, where you would load the mapping dynamically that would be the solution.

Notice the naming: stringMapping (camelCase) for class fields and local variables instead of StringMapping (PascalCase) that is used for properties and method names.



I find SizeArray unnecessary and waste of memory:


  int[] SizeArray = new int[StringMapping.Length];



The only place you are using it is here:


      if (counterArray[incIndex] + 1 &lt; SizeArray[incIndex])



which could be replaces with:

if (counterArray[incIndex] + 1 &lt; stringMapping[incIndex].Length)





  for (int countdown = totalCombinationCount; countdown &gt; 0; countdown--)


There is nothing wrong with iterating backward if the situation demands it, but at least I have to look an extra time, when I see a backward loop. Here there is no reason for the above backward iteration as you only use it to count combinations, the countdown index isn't used to anything in the loop, so it could run forward without any damage:

for (int countdown = 0; countdown &lt; totalCombinationCount; countdown++)




Your algorithm works fine, but the overall impression is that it is more complex than it has to be, and due to the double nested loops it is not very efficient.

FYI: below are some other approaches (they all use the GetPattern() method shown above):

1) An iterative version that uses a list to cache all the combinations while creating them:

void LetterCombinationsIter(string numbers)
{
  IEnumerable&lt;string&gt; CreateCombinations()
  {
    List&lt;string&gt; combs = new List&lt;string&gt; { "" };

    for (int i = 0; i &lt; numbers.Length; i++)
    {
      List&lt;string&gt; temp = new List&lt;string&gt;();
      string chars = GetPattern(numbers[i]);

      foreach (string comb in combs)
      {
        foreach (char ch in chars)
        {
          temp.Add(comb + ch);
        }
      }

      combs = temp;
    }

    return combs;
  }

  Console.WriteLine(string.Join(Environment.NewLine, CreateCombinations()));
}


2) A recursive version which is often the intuitive choice for this kind of problems:

void LetterCombinationsRec(string numbers)
{
  char[] buffer = new char[numbers.Length];

  IEnumerable&lt;string&gt; HandleIndex(int index)
  {
    if (index &gt;= numbers.Length)
    {
      yield return new string(buffer);
    }
    else
    {
      foreach (char ch in GetPattern(numbers[index]))
      {
        buffer[index] = ch;
        foreach (string comb in HandleIndex(index + 1))
        {
          yield return comb;
        }
      }
    }
  }

  Console.WriteLine(string.Join(Environment.NewLine, HandleIndex(0)));
}


3) Finally a version using Linq that solves the problem in a few lines of code:

void LetterCombinationsLinq(string numbers)
{
  IEnumerable&lt;string&gt; CreateCombinations()
  {
    return numbers.Aggregate(new[] { "" }.AsEnumerable(), (combs, n) =&gt;
    {
      string chars = GetPattern(n);
      return combs.SelectMany(pre =&gt; chars.Select(ch =&gt; pre + ch));
    });
  }

  Console.WriteLine(string.Join(Environment.NewLine, CreateCombinations()));
}