Wow that's a big integer! What's its largest prime factor?
What a fascinating solution!  It seems that for every smart decision you made, you also threw in a poor decision or two.

Smart decision: In PrimeFactors(), you start testing divisors from small to large, rather than large to small.

Poor decision: You used if (IsFactor(number,divisor) … rather than while (IsFactor(number,divisor)).  Using if instead of while disastrously complicates the program.

Smart decision: In IsPrime(), the index loop skips even numbers.  (Why is the variable named index?)

Poor decision: The divisor loop in PrimeFactors() doesn't skip even numbers.

Smart decision: In IsPrime() the index loop goes up to Math.Sqrt(number).

Poor decision: In PrimeFactors(), the divisor loop goes all the way up to number / 2.

Smart decision: You defined an IsFactor() function for readability, and used it in PrimeFactors().

Poor decision: You didn't use IsFactor() in IsPrime().

Smart decision: In PrimeFactors(), whenever you find a successful divisor, you continue the calculation based on factor = number / divisor rather than number.

Poor decision: You continue to factor factor by recursion instead of looping.  Worse, the way you used recursion requires you to append the results to the results array.

Poor decision: In the innermost if-else of PrimeFactors()…

if (IsPrime(factor))
{
    …
} else {
    Int64[] recursiveResults = PrimeFactors(factor);
    …
}


the call to PrimeFactors() repeats a lot of throwaway work that was done by IsPrime().

Overall, though, the fundamental issue is the if-vs.-while distinction.  Had you chosen while, then you could…


enumerate the successful divisors in nondecreasing order.  Currently, you keep a list of all prime factors and find its maximum.  If you could obtain the divisors in order, then you wouldn't need to bother with keeping a list at all.
eliminate IsPrime() altogether.  Every successful divisor will necessarily be prime since you will have factored out all smaller divisors already.