Why is C# BigInteger faster than C++ MPIR?

Question

I wrote a simple single-threaded application that checks whether a given number is prime. It is meant to support arbitrarily large integers, so I made use of the BigInteger class in C#. Here is the code:

using System;
using System.Diagnostics;
using System.Numerics;

namespace PrimeChecker {
    public static class Program {
        /// <summary>
        /// Gets the number of threads that parallel loops will use from the thread pool when called.
        /// </summary>
        private static BigInteger MinusOne = BigInteger.MinusOne,
            Zero = BigInteger.Zero,
            One = BigInteger.One,
            Two = new BigInteger(2),
            Three = new BigInteger(3),
            Five = new BigInteger(5),
            Six = new BigInteger(6);

        public static void Main(string[] args) {
            string value = args.Length == 0 ? null : args[0];
            BigInteger num, factor;
            Stopwatch elapsed = new Stopwatch();
            do {
                if (value == null) {
                    Console.Write("\nEnter integer to check if prime (or blank to exit): ");
                    value = Console.ReadLine();
                }
                if (value.Length == 0)
                    return;
                value.Trim();
                if (BigInteger.TryParse(value, out num)) {
                    Console.Write("Checking...");
                    elapsed.Restart();
                    if (num.IsZero)
                        Console.WriteLine("nope, divisible by 0. :/ (elapsed: 0ms)");
                    else if (num.IsOne)
                        Console.WriteLine("nope, divisible by 1. :/ (elapsed: 0ms)");
                    else {
                        factor = IsPrime(num);
                        elapsed.Stop();
                        if (factor.IsOne)
                            Console.WriteLine("prime! :D (elapsed: " + elapsed.Elapsed.ToString() + ")");
                        else
                            Console.WriteLine("nope, divisible by at least " + factor + " and " + (num / factor) + ". :/ (elapsed: " + elapsed.Elapsed.ToString() + ")");
                    }
                } else
                    Console.WriteLine("Not a valid integer... :*");
                value = null;
            } while (true);
        }

        private static BigInteger LogBase2(BigInteger num) {
            if (num <= Zero)
                return MinusOne; //does not support negative values
            BigInteger i = Zero;
            while (!(num >>= 1).IsZero)
                i++;
            return i;
        }

        public static BigInteger Sqrt(this BigInteger num) {
            if (num.IsZero)
                return Zero;
            else if (num.IsOne)
                return One;
            else if (num.Sign > 0) {
                BigInteger root = LogBase2(num);
                BigInteger lowerBound;
                while (num < (lowerBound = root * root) || num > lowerBound + root + root) {
                    root += num / root;
                    root >>= 1;
                }
                return root;
            } else
                return MinusOne;
        }

        /// <summary>
        /// Returns 0 if num is 0, 1 if the value is prime or 1, -1 if the value is negative,
        /// else returns the smallest factor of the num.
        /// </summary>
        /// <param name="num">The integer to check if prime.</param>
        public static BigInteger IsPrime(BigInteger num) {
            if (num.IsZero)
                return Zero;
            else if (num.Sign < 0)
                return MinusOne;
            else if (num <= Three || num == Five)
                return One;
            else if (num.IsEven)
                return Two;
            else if ((num % Three).IsZero)
                return Three;
            BigInteger root = Sqrt(num);
            if (!root.IsEven)
                root++;
            BigInteger i = Five;
            while (i < root && !((num % i).IsZero || (num % (i += Two)).IsZero)) //main loop here
                i += Four;
            return i < root ? i : One;
        }
    }
}

However, I wanted to investigate writing the same application in C++. I managed to accomplish this by making use of the MPIR library on Windows. The full code code and Visual Studio project can be found on GitHub: https://github.com/mathusummut/PrimeCheckerCpp, but here is the main loop:

while (mpz_cmp(i, root) == -1) {  //loop is here
    mpz_mod(temp, num, i);
    if (mpz_sgn(temp) == 0)
        break;
    mpz_add_ui(i, i, 2u);
    mpz_mod(temp, num, i);
    if (mpz_sgn(temp) == 0)
        break;
    mpz_add_ui(i, i, 4u);
}

When I run the C# executable to check whether 2305843009213693951 is prime, I get this output:

Enter integer to check if prime (or blank to exit): 2305843009213693951
Checking...prime! :D (elapsed: 00:00:52.2468554)

whereas when I run the C++ executable, I get this output:

Enter integer to check if prime (or blank to exit): 2305843009213693951
Checking...prime! :D (elapsed: 60.429640s)

Why is the C++ implementation slower? Is the MPIR library at fault here, or am I doing something wrong?

NB: Both are compiled and tested in Release mode 64-bit with full optimizations enabled with no debugger attached.

NB: @hatchet was right, when I tried an integer that is not representable with 64 bits, the C++ implementation was faster. For example, trying 108446744073709551647, the C# version took 13.5 minutes whereas the C++ version took only 6.5 minutes to execute!