Deconstructing dynamic values

[jshirota]

Is there any reason why I cannot deconstruct dynamic values into typed variables?

using System;

var cat = new Cat();

// This is OK.
(dynamic x, dynamic y) = cat;
var name = (string)x;
var age = (int)y;

// This is not.  Why?
// (string name, int age) = cat;

Console.WriteLine($"{name} {age}");

public class Cat
{
    // Some dynamic data from somewhere.
    private dynamic[] data = { "Leo", 8 };

    public void Deconstruct(out dynamic name, out dynamic age)
    {
        name = data[0];
        age = data[1];
    }
}

[svick]

The error message is:

error CS0266: Cannot implicitly convert type 'dynamic' to 'string'. An explicit conversion exists (are you missing a cast?)

I find that odd, since dynamic can be implicitly converted to string (or almost any other type). So I wouldn't be surprised if this was a compiler bug.

[jshirota]

I agree with svick. It seems a bit inconsistent.

[Rekkonnect]

This definitely seems like a bug to me, and should perhaps be looked at. Willing to take up the development of this, as I've already worked on similar areas involving deconstruction.

[jshirota]

It's actually not specific to deconstructing, but I'm finding inconsistencies in the way 'out' parameters behave.

In the code below, I'm commenting out the lines that are not compiling.

//C1.GetNumber(out long a);
//C1.GetNumber(out dynamic b);
//C2.GetNumber(out long c);
C2.GetNumber(out dynamic d);
//new C3().GetNumber(out long e);
//new C3().GetNumber(out dynamic f);
//new C4().GetNumber(out long g);
new C4().GetNumber(out dynamic h);
(long i, _) = new C5();
(dynamic j, _) = new C5();
//(long k, _) = new C6();
(dynamic l, _) = new C6();

class C1 { public static void GetNumber(out int x) => x = 1; }
class C2 { public static void GetNumber(out dynamic x) => x = 1; }
class C3 { public void GetNumber(out int x) => x = 1; }
class C4 { public void GetNumber(out dynamic x) => x = 1; }
class C5 { public void Deconstruct(out int x, out int y) => (x, y) = (1, 2); }
class C6 { public void Deconstruct(out dynamic x, out dynamic y) => (x, y) = (1, 2); }

[Rekkonnect]

• When you declare a variable inline, I find it okay-ish that you cannot do out long a on an out int parameter, and similarly out dynamic on a non-dynamic parameter. As for out int on an out dynamic parameter, I'm kinda hesitant to opinionate, as dynamicness is supposed to lease off the strictness of static typing.
• When you declare a non-dynamic variable inside the deconstructed result which has a dynamic in that position, I would expect it to behave as if you're manually assigning the single result into a variable.

[HaloFour]

Right, that's the expected behavior for ref/out parameters. The type of the parameter is ref T and the argument must be the same type. You cannot coerce or cast between types. The dynamic type is just object with some additional sugar built into the compiler.