PrimeFactorize method for int
First of all, the PrimeFactorize() does never terminate for number = 1
because the check IntUtils.IsPrime(number) will never return true.
The call PrimeFactorize(1) should return an empty list.

To compare the performance of various implementations, I used the following simple
test program which computes all prime factors of the numbers up to 10,000. The sum
is calculated to prevent the compiler from removing function calls whose result is
not used, and to verify that all implementations give the same results.

using System.Diagnostics; // for StopWatch

public static void Main()
{
    Stopwatch stopWatch = Stopwatch.StartNew();
    var sum = 0;
    for(var N = 2; N &lt;= 10000; N++) 
    {
        foreach(var P in IntUtils.PrimeFactorize(N))
        {
            sum += P;
        }
    }
    stopWatch.Stop();
    Console.WriteLine("Sum: {0}, Time: {1} ms", sum, stopWatch.Elapsed.TotalMilliseconds);
}


The tests were done on a MacBook, using
 Mono.

For your code, the result is

 Sum: 10243046, Time: 2945.7256 ms


Your code creates a list of primes in order to find the lowest factor of the given number,
and the GetPrimesBetween() function seems be the performance bottleneck.

The IsPrime() function can be improved slightly. Since divisibility by 2, 3, 5 is
checked upfront, the loop can start with i = 7. Inside the loop, divisibility by
both i and i+2 is checked, so that the next possible divisor is i+4. Therefore
the loop should be

    // iterate with trial division
    int i = 7;
    while (i * i &lt;= n)
    {
        if (n % i == 0 || n % (i + 2) == 0)
        {
            return false;
        }
        i += 4;
    }


This reduces the execution time to

Sum: 10243046, Time: 1193.3498 ms


To improve the PrimeFactorize() function, note that every composite number \$ n \$ necessarily
has a factor \$ p \le \sqrt n \$. Also, if a factor is found, 
you can repeatedly check that factor instead of breaking out of the
loop and starting with the first prime again. 

This leads to the following implementation:

public static IEnumerable&lt;int&gt; PrimeFactorize(int number)
{
    List&lt;int&gt; primes = IntUtils.GetPrimesBetween(2, (int)Math.Sqrt(number));            
    foreach (var p in primes)
    {
        while (number % p == 0)
        {
            yield return p;
            number /= p;
        }
    }
    // Now either number == 1 or number is a prime:
    if (number &gt; 1) {
        yield return number;
    }
}


which reduces the execution time considerably:

Sum: 10243046, Time: 15.6476 ms


A faster way to determine all prime numbers in a given range are sieving methods.
A simple implementation of the sieve of Eratosthenes is
(taken from https://codereview.stackexchange.com/a/62158/35991, but
as an enumerator):

public static IEnumerable&lt;int&gt;GetPrimesUpto(int number) {
    bool[] isComposite = new bool[number + 1];
    for (int x = 2; x &lt;= number; x++)
    {
        if (!isComposite[x])
        {
            yield return x;
            for (int y = x * x; y &lt;= number; y = y + x)
            {
                isComposite[y] = true;
            }
        }
    }
}


which can then be used as:

public static IEnumerable&lt;int&gt; PrimeFactorize(int number)
{
    var primes = IntUtils.GetPrimesUpto((int)Math.Sqrt(number));            
    foreach(var p in primes)
    {
        while (number % p == 0)
        {
            yield return p;
            number /= p;
        }
    }
    if (number &gt; 1) {
        yield return number;
    }
}


Execution time:

Sum: 10243046, Time: 9.6804 ms


But actually you don't need to compute a list of primes first
(and I am essentially repeating the arguments from https://codereview.stackexchange.com/a/64795/35991).

The smallest factor of a number is necessarily a prime. You already
divide the number by any factor found, but this means that the lowest
factor of the updated number is again a prime. So by repeatedly
searching for the lowest factor you'll find all prime factors without
doing any extra test for primality.

Again it suffices to check for factors up
to the square root of the (remaining) number. After that,  number is
either equal to one or a prime.

This leads to the following function:

// Generate prime factors for a number, e.g., input 12 returns 2 2 3
public static IEnumerable&lt;int&gt; PrimeFactorize(int number)
{
    // Check divisibility by 2:
    while (number % 2 == 0) {
        yield return 2;
        number /= 2;
    }
    // Check divisibility by 3, 5, 7, ...
    for (var i = 3; i * i &lt;= number; i += 2) {
        while (number % i == 0) {
            yield return i;
            number /= i;
        }
    }
    if (number &gt; 1) {
        yield return number;
    }
}


Execution time:

Sum: 10243046, Time: 2.6631 ms


(C# is not my primary language, but I hope that the code demonstrates the idea.)