IntPtr演员与新演员

Question

I was just looking at an example, and in it I saw the code

return new IntPtr(handle);

After poking around our code, I found that we have already used a similar pattern, but in our code we had almost the same thing:

return (IntPtr)handle;

Is there a difference between those two takes? Will the second one be "better" in any way, since it doesn't allocate new memory, or is the cast just hiding the same constructor underneath?

Answer 1

In your examples, I'm guessing handle is an integer value? IntPtr declares an explicit conversion from Int32 (int) and Int64 (long) which simply calls the same constructor:

public static explicit operator IntPtr(int value)
{
    return new IntPtr(value);
}

So there is effectively no difference other than possible readability concerns.

Answer 2

Reflector says that the cast is calling the constructor under the hood anyway:

[Serializable, StructLayout(LayoutKind.Sequential), ComVisible(true)]
public struct IntPtr : ISerializable
{
    ...

    [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
    public static explicit operator IntPtr(int value)
    {
        return new IntPtr(value);
    }

}

Answer 3

So this thread is all talk and no numbers so lets talk metrics. I ran some test code to get some performance metrics using Visual Studio 2010 and

I got these metrics by calculating the average time of either method over 10 test runs with 10 million iterations each in Debug then Release mode (non optimized then optimized):

(Debug) Casting Method: ~32 ms Allocation Method: ~26 ms

(Release) Casting Method: ~20 ms Allocation Method: ~22 ms

What is also interesting is to compare these metrics to similar code with managed C++ only using gcnew and the results are much different.

Same setup again. Except comparing the casting method: "IntPtr^ ptr = (IntPtr) i;" vs the allocation method: "IntPtr^ ptr = (IntPtr) i;".

(Debug) Casting Method: ~91ms Allocation Method: ~127ms

(Release) Casting Method: ~22ms Allocation Method: ~124ms

Now if you are scratching your head saying well why is C# so much faster than managed C++ and the answer is it isn't. The most efficient way to use IntPtr is as value type not a reference to a value type. For instance like so "IntPtr ptr = (IntPtr) i;". This would give you ~24ms (Debug more) or (~22 Release mode). See how it was optimized above by the compiler to get the 22ms rather than the 90ms.

Conclusion in C#, unless you are looking at REALLY REALLY tight code it doesn't matter. I think with my code in Release it was actually optimizing the cast right out because commenting out the cast gave the same ~22ms. But for the most part compiler has your back on this one in C# well at least VS 2010 does. However, in Managed C++/CLI if you are looking at code with even minimal performance constraints then watch out. The compiler will not automatically optimize gcnew allocations to the casting approach and it's almost 6 times faster... I actually ran into this particular problem in C++/CLI which is what led me to post on this thread when dealing with some real-time audio processing. My code (C#): (My managed C++ code was very similar except I had to write Average() myself and used console to output rather than message boxes).

    static void Main()
    {
        List<int> castTimings = new List<int>();
        List<int> allocTimings = new List<int>();

        for (int i = 0; i < TEST_RUNS; ++i)
        {
            castTimings.Add(RunCastMethod().Milliseconds);
            allocTimings.Add(RunAllocationMethod().Milliseconds);
        }

        MessageBox.Show(string.Format("Casting Method took: {0}ms", castTimings.Average() ));
        MessageBox.Show(string.Format("Allocation Method took: {0}ms", allocTimings.Average() ));
    }

    private static TimeSpan RunAllocationMethod() {
        DateTime start = DateTime.Now;

        for (int i = 0; i < TEST_ITERATIONS; ++i)
        {
            IntPtr ptr = new IntPtr(i);
        }

        return ( DateTime.Now - start );
    }

    private static TimeSpan RunCastMethod()
    {
        DateTime start = DateTime.Now;

        for (int i = 0; i < TEST_ITERATIONS; ++i)
        {
            IntPtr ptr = (IntPtr) i;
        }

        return (DateTime.Now - start);
    }

Answer 4

Since IntPtr is a value type, using new does not allocate any memory.

Technically, the calls still compile down to different IL - one actually calls the constructor, another calls the explicit conversion operator. I'm not sure if there's any actual difference between those two after a JIT pass, however - most likely none (though I doubt you'd notice either way in practice, this being a femtooptimization).

In any case, cast is more idiomatic than using a constructor, so I'd suggest going with it for that reason alone.