Project Euler 4: Largest palindrome product

@AlanT mentioned really good points. The change of the algorithm should drastically increase the performance.

However, the Main function is left alone, let's try to improve it.

Add some space

    public static void Main()
    {
        Console.WriteLine("ProjectEuler4: Largest palindrome product");

        // this is the test case from the original statement/problem
        // it should return Palindrome: 9009 | firstFactor: 99 | secondFactor: 91
        int numDigits;
        numDigits = 2;
        ProjectEuler4 PE4_2dig = new ProjectEuler4(numDigits);
        Console.WriteLine("The largest palindrome product of {0}-digit numbers is: {1}", numDigits, PE4_2dig.GetAnswer());

        // this is the challenge
        numDigits = 3;
        ProjectEuler4 PE4_3dig = new ProjectEuler4(numDigits);
        Console.WriteLine("The largest palindrome product of {0}-digit numbers is: {1}", numDigits, PE4_3dig.GetAnswer());

        // another test with 4 digits, for performance
        numDigits = 4;
        ProjectEuler4 PE4_4dig = new ProjectEuler4(numDigits);
        Console.WriteLine("The largest palindrome product of {0}-digit numbers is: {1}", numDigits, PE4_4dig.GetAnswer());
    }

Init vars together with declaring

    public static void Main()
    {
        Console.WriteLine("ProjectEuler4: Largest palindrome product");

        // this is the test case from the original statement/problem
        // it should return Palindrome: 9009 | firstFactor: 99 | secondFactor: 91
        int numDigits = 2;
        ProjectEuler4 PE4_2dig = new ProjectEuler4(numDigits);
        Console.WriteLine("The largest palindrome product of {0}-digit numbers is: {1}", numDigits, PE4_2dig.GetAnswer());

        // this is the challenge
        numDigits = 3;
        ProjectEuler4 PE4_3dig = new ProjectEuler4(numDigits);
        Console.WriteLine("The largest palindrome product of {0}-digit numbers is: {1}", numDigits, PE4_3dig.GetAnswer());

        // another test with 4 digits, for performance
        numDigits = 4;
        ProjectEuler4 PE4_4dig = new ProjectEuler4(numDigits);
        Console.WriteLine("The largest palindrome product of {0}-digit numbers is: {1}", numDigits, PE4_4dig.GetAnswer());
    }

Notice repeating code & extract it

    public static void Main()
    {
        Console.WriteLine("ProjectEuler4: Largest palindrome product");

        // this is the test case from the original statement/problem
        // it should return Palindrome: 9009 | firstFactor: 99 | secondFactor: 91
        var numDigits = 2;
        var answer = GetPESolution(numDigits);
        WriteResult(numDigits, answer);

        // this is the challenge
        numDigits = 3;
        answer = GetPESolution(numDigits);
        WriteResult(numDigits, answer);

        // another test with 4 digits, for performance
        numDigits = 4;
        answer = GetPESolution(numDigits);
        WriteResult(numDigits, answer);
    }

    private static int GetPESolution(int numDigits)
    {
        var pe = new ProjectEuler4(numDigits);
        var answer = pe.GetAnswer();
        return answer;
    }

    private static void WriteResult(int numDigits, int answer)
    {
        Console.WriteLine("The largest palindrome product of {0}-digit numbers is: {1}", numDigits, answer);
    }

At this stage the code is readable. Along the way, we got rid of the ugly var names like PE4_3dig.

Now, we can further refactor it to have something like...

    // ProjectEuler4: Largest palindrome product
    // https://projecteuler.net/problem=4
    public static void Main()
    {
        Console.WriteLine("ProjectEuler4: Largest palindrome product");

        // this is the test case from the original statement/problem
        // it should return Palindrome: 9009 | firstFactor: 99 | secondFactor: 91
        TestPE(2);

        // this is the challenge
        TestPE(3);

        // another test with 4 digits, for performance
        TestPE(4);
    }

    private static void TestPE(int numDigits)
    {
        var answer = GetPESolution(numDigits);
        WriteResult(numDigits, answer);
    }

    private static int GetPESolution(int numDigits)
    {
        var pe = new ProjectEuler4(numDigits);
        var answer = pe.GetAnswer();
        return answer;
    }

    private static void WriteResult(int numDigits, int answer)
    {
        Console.WriteLine("The largest palindrome product of {0}-digit numbers is: {1}", numDigits, answer);
    }

But I insist on...

Transform it to tests

You yourself call it test case in a comment. You should end up with methods like

    [TestMethod]
    public void OriginalProblem()
    {
        var numDigits = 2;
        var expected = 9009;

        var actual = PE4.GetPESolution(numDigits);

        Assert.AreEqual(expected, actual);
    }

Side notes

1. If you still want to have console output, you should have it in one place, as now it is scattered.

2. You do not need to add a comment above every function. I.e.

    // Get the minimum and maximum values of possible numbers considering the number of digits requested.
    private int[] GetMinAndMax()
   

   Here, the method name is good enough. Notice, however, that the comment is misleading a bit, the method does not really request any number of digits (as it has no parameters), it somehow has it already. Also, would you remember to modify the comment if you modify the method, e.g. start returning only max here?

3. And you definetely do not need this comment:

   // Constructor
   public ProjectEuler4(int numberOfDigits)
   

   Well, everybody should understand this is a constuctor.

   Actually, of all your comments I would at best leave only comments in the Main method and a SO link. Really, the names you have given to the methods are fine, good job.

4. Consider using this keyword whenever applicable, it usually increases readability.

I'm finding your code very hard to follow. Let me describe to you how I'd solve this problem.

First, state the problem. We want the largest of all products of two 3-digit numbers that are palindromes.

Let's start with all products of two 3-digit numbers:

static IEnumerable<int> Products()
{
  for (int i = 100; i < 1000; ++i)
    for (int j = i; j < 1000; ++j)
      yield return i * j;
}

Now we have all the products. But we want only the products that are palindromes:

var palindromes = Products().Where(p => IsPalindrome(p));

Exercise: implement IsPalindrome efficiently.

We want the biggest of them:

var answer = palindromes.Max();

And we're done. Not only is this solution about ten total lines of code, each line is obviously correct.

My advice to you is: raise the level of abstraction of your code. If you want to get the largest of a set of things, there should be a line of code in there that says largest = things.Max();. Is there a concept mentioned in the problem statement? Then find or make a function that implements that concept. Your code will get a lot easier to follow.

In fact we can even eliminate the initial loops and reduce the whole thing to just one query:

    var palindromes = from i in Enumerable.Range(100, 900)
                      from j in Enumerable.Range(i, 900 - i) 
                      let p = i * j
                      where IsPalindrome(p)
                      select p;
    Console.WriteLine(palindromes.Max());

Notice how compact and how plainly correct this code is.