5

I use a type derived from a DynamicObject as a builder for some strings. At the end I call ToString to get the final result.

At this point I thought it would give me a normal string but this string is somehow strange. It behaves like one when I use string functions on it but it behaves like I don't know actually what, something neither a string nor a dynamic.

This is how I implemented ToString on my builder

public class Example : DynamicObject
{
    public override bool TryConvert(ConvertBinder binder, out object result)
    {
        if (binder.ReturnType == typeof(string))
        {
            result = ToString();
            return true;
        }
        result = null;
        return false;
    }   

    public override string ToString()
    {
        return base.ToString();
    }
}

When I run it like this

dynamic example = new Example();
Console.WriteLine(example.ToString().ToUpper());

the result is correct: USERQUERY+EXAMPLE (when executed in LINQPad)

However if I call the second line like this

Console.WriteLine(example.ToString().Extension());

where

static class Extensions
{
    public static string Extension(this string str)
    {
        return str.ToUpper();
    }
}

the application crashes with a RuntimeBinderException saying

'string' does not contain a definition for 'Extension'

but if I cast the result it works again

Console.WriteLine(((string)example.ToString()).Extension());

Maybe one more example.

Console.WriteLine((string)example); // UserQuery+Example

but

Console.WriteLine(example); // DynamicObject UserQuery+Example

You can actually never be sure what you'll get until you cast it to string.

Why is this happening and is there a way to avoid the additional cast and get somehow a real string?

t3chb0t
  • 16,340
  • 13
  • 78
  • 118

1 Answers1

7

That's because ToString called on dynamic is typed to return dynamic and not string:

dynamic example = new Example();
// test will be typed as dynamic
var test = example.ToString();

When you call ToUpper on test it will use dynamic binding and resolve to string.ToUpper at runtime. You have to cast to a concrete type to escape dynamic typing.

Extension methods is a compile-time feature and as such is not supported by dynamic typing as extension method. You can still call it using regular static method invocation syntax.

Extensions.Extension(example.ToString());

But again - example.ToString() will return dynamic and type binding will happen at runtime to check if it can be used as a parameter to Extensions.Extension call. Check this answer for details.

Community
  • 1
  • 1
MarcinJuraszek
  • 124,003
  • 15
  • 196
  • 263
  • ok, I understand why an extension does not work directly on a dynamic object but this does not work either `example.ToString().ToLower().Extension()` so this means that as long as I don't cast it to a concrete type I'll always get `dynamic` back no matter if the method retuned `int` or `string` or anything? – t3chb0t Jan 01 '17 at 13:00
  • Yes, you're correct. You need to cast to some specific type to escape dynamic typing. That cast can be either explicit (by using `(string)`) or implicit by assigning dynamically-typed expression to a statically-typed variable or passing it as parameter into a statically-typed method. – MarcinJuraszek Jan 01 '17 at 13:03