访问动态属性会引发“Microsoft.CSharp.RuntimeBinder.RuntimeBinderException”类型的异常

Question

I am passing a handler function as an argument to another function. One of the arguments of the handler is a dynamic object and I am accessing one of its properties.

Here is an example:

    protected virtual void OnTime(dynamic timed, HttpResponseMessage response, TimeSpan time)
    {
        _logger.Write(timed?.name);
    }

And here is how the handler gets invoked:

OnTime?.Invoke(new {name = dto.name, dto, request }, httpResponseMessage, elapsed);

This worked well. Then I shuffled some things around and it broke. The dynamic object comes in as expected with all of its properties but now timed?.name throws Microsoft.CSharp.RuntimeBinder.RuntimeBinderException exception complaining that the object does not have a definition of property name .

I looked at these answers for a solution:

Why does the assignment from a dynamic object throw a RuntimeBinderException?

Dynamic throwing Microsoft.CSharp.RuntimeBinder.RuntimeBinderException on private types

and the following works:

Dictionary<string, object> values = ((object)timed)
                                 .GetType()
                                 .GetProperties()
                                 .ToDictionary(p => p.Name, p => p.GetValue(v));

( Get properties of a Dynamic Type )

but I am not sure why direct access stopped working. Any ideas? Thank you!

Answer 1

I discovered the reason it broke. Initially, both the handler and the function the handler is passed in belonged to the same assembly. After the refactoring the handler and the object invoking it were split into different projects and namespaces thus preventing the binding at compile time.

The solution was to no longer pass a dynamic but a serialized object:

OnTime?.Invoke(JsonConvert.SerializeObject(new { name = dto.Name, dto, request }), httpResponseMessage, elapsed);

and then consume it as:

    protected virtual void OnTime(string timed, HttpResponseMessage response, TimeSpan time)
    {
        var operation = JsonConvert.DeserializeAnonymousType(timed, new { name = string.Empty });

        _logger.Write(operation.name);
    }

Decoupling thus requires the extra step of serialization but allows for more reuse of the code.