当属性已知时，为什么不使用动态而不是反射呢？

Question

This question is similar to this one , but assuming that we know the member name at compile time.

---

Assuming that we have a class

public class MyClass
{
    public string TheProperty { get; set; }
}

and in another method, we want to set the TheProperty member of an instance of that class, but we don't know the type of the instance at compile time, we only know the property name at compile time. So, as I see it, there are two ways to do that now:

object o = new MyClass(); // For simplicity.

o.GetType().GetProperty("TheProperty").SetValue(o, "bar"); // (1)    
((dynamic) o).TheProperty = "bar"; // (2)

I measured this test case using the System.Diagnostics.Stopwatch class to find out that reflection took 475 ticks and the way using dynamic took 0 ticks , therefore being about as fast as a direct call to new MyClass().TheProperty = "bar" .

---

Since I have almost never seen the second way, I am a little confused and my questions now are:

• Is there a lapse of thought or anything?
• Should the second way be preferred over the first or the other way around? I don't see any disadvantages of using the second way; both (1) and (2) would throw exceptions if the property would not have been found, wouldn't they?
• Why does the second way seem to be used so rarely even though seemingly being the faster?

Answer 1

(...)reflection took 475 ticks and the way using dynamic took 0 ticks(...)

That is simply false. The problem is that you are not understanding how dynamic works. I will assume you are correctly setting up the benchmark:

1. Running in Release mode with optimizations turned on and without the debugger.
2. You are jitting the methods before actually measuring times.

And here comes the key part you are probably not doing:

3. Jit the dynamic test without actually performing the dynamic runtime binding .

And why is 3 important? Because the runtime will cache the dynamic call and reuse it! So in a naive benchmark implementation, if you are doing things right, you will incurr the cost of the initial dynamic call jitting the method and therefore you won't measure it.

Run the following benchmark:

public static void Main(string[] args)
{
    var repetitions = 1;
    var isWarmup = true;
    var foo = new Foo();

    //warmup
    SetPropertyWithDynamic(foo, isWarmup); //JIT method without caching the dynamic call
    SetPropertyWithReflection(foo); //JIT method
    var s = ((dynamic)"Hello").Substring(0, 2); //Start up the runtime compiler

    for (var test = 0; test < 10; test++)
    {
        Console.WriteLine($"Test #{test}");
        var watch = Stopwatch.StartNew();

        for (var i = 0; i < repetitions; i++)
        {
            SetPropertyWithDynamic(foo);
        }

        watch.Stop();
        Console.WriteLine($"Dynamic benchmark: {watch.ElapsedTicks}");

        watch = Stopwatch.StartNew();

        for (var i = 0; i < repetitions; i++)
        {
            SetPropertyWithReflection(foo);
        }

        watch.Stop();
        Console.WriteLine($"Reflection benchmark: {watch.ElapsedTicks}");
    }

    Console.WriteLine(foo);
    Console.ReadLine();
}

static void SetPropertyWithDynamic(object o, bool isWarmup = false)
{
    if (isWarmup)
        return;

    ((dynamic)o).TheProperty = 1;
}

static void SetPropertyWithReflection(object o)
{
    o.GetType().GetProperty("TheProperty").SetValue(o, 1);
}

public class Foo
{
    public int TheProperty { get; set; }
    public override string ToString() => $"Foo: {TheProperty}";
}

Spot the difference between the first run and the subsequent ones?