How to create dynamic object with nested children?

I have table:

| Key                 | Value    |
| name                | testtest |
| username            | testtest |
| phone               | 33333    |
| website             | www      |
| company.name        | test     |
| company.catchPhrase | test     |
| company.bs          | test     |

I is possible to use table.CreateDynamicInstance(); to create dynamic object with nested children?
Something like json:

{
        "name": "test1232315125",
        "username": "testfdhdfh",
        "phone": "4636346236236",
        "website": "sdgsdgsdgsdgsdg",
        "company": {
            "name": "sdgsdgsdgsdg",
            "catchPhrase": "dgsdghdfjdf",
            "bs": "sdgsdgdfjfd"
        }
}

[icnocop]

Hi.

Did you find a solution?

No

I found code to build nested table for class but dont know how to change it to build dynamic table without setting T

using System;
using System.Linq;
using System.Reflection;
using System.Text.RegularExpressions;
using TechTalk.SpecFlow;
using TechTalk.SpecFlow.Assist;
 
public static class TableExtensions
{
    public static T BuildInstance<T>(this Table table)
    {
        T result = table.CreateInstance<T>();
 
        // find sub-properties by looking for "."
        var propNames = table.Rows.OfType<TableRow>()
            .Where(x => x[0].Contains("."))
            .Select(x => Regex.Replace(x[0], @"^(.+?)\..+$", "$1"));
 
        foreach (var propName in propNames)
        {
            // look for matching property in result object
            var prop = typeof(T).GetProperty(
                propName,
                BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);
 
            if (prop != null)
            {
                // create sub-table with relevant rows (field == propName.something)
                var subTable = new Table("field", "value");
                var re = new Regex(string.Format(@"^{0}\.([^\.]*)$", propName), RegexOptions.IgnoreCase);
                table.Rows.OfType<TableRow>().Where(x => re.IsMatch(x[0]))
                    .Select(x => new[] { re.Replace(x[0], "$1"), x[1] })
                    .ToList()
                    .ForEach(x => subTable.AddRow(x));
 
                // make recursive call to create child object
                var createInstance = typeof(TableExtensions)
                    .GetMethod(
                        "BuildInstance",
                        BindingFlags.Public | BindingFlags.Static,
                        null,
                        CallingConventions.Any,
                        new Type[] { typeof(Table) },
                        null);
                createInstance = createInstance.MakeGenericMethod(prop.PropertyType);
                object propValue = createInstance.Invoke(null, new object[] { subTable });
 
                // assign child object to result
                prop.SetValue(result, propValue);
            }
        }
 
        return result;
    }
}

[marcusoftnet]

Hi,

yeah... that is not something I forsaw the tool doing. So it's not implemented.

But I'm thinking that you can do this, pretty easy, using step argument transformations, like I have done here https://github.com/marcusoftnet/SpecFlow.Assist.Dynamic/blob/master/SpecFlow.Assist.Dynamic/DynamicStepArgumentTransformations.cs

Instead of my code you can plug-in the code that you have above.

[Binding]
    public class Haxy89ArgumentTransformations
    {
        [StepArgumentTransformation]
        public dynamic TransformToEnumerable(Table table)
        {
           // your code from above
        }
}

You might want to remove the <StepArgumentTransformation> node from you config file

<stepAssemblies>
  <stepAssembly assembly="SpecFlow.Assist.Dynamic" /> 
</stepAssemblies>

that SpecFlowAssistDynamic is adding when installing.

Yeah but still, I want to build object dynamicaly without provide class as T.
In my simple code I have to provide some class as T

[marcusoftnet]

Ok - but why do you need to do that?

If you change your signature to

[StepArgumentTransformation]
public dynamic BuildInstance(Table table) {}

You don't need a at all.

Read up on https://specflow.org/documentation/Step-Argument-Transformations/ for ways to ensure that you only get called for the steps that required transformation. As written above the code will get called for every step with a table.

This is not going to work with dynamic:

 public static dynamic BuildInstance(this Table table)
        {
            dynamic result = table.CreateInstance<dynamic>();

            // find sub-properties by looking for "."
            var propNames = table.Rows.OfType<TableRow>()
                .Where(x => x[0].Contains("."))
                .Select(x => Regex.Replace(x[0], @"^(.+?)\..+$", "$1"));

            foreach (var propName in propNames)
            {
                // look for matching property in result object
                var prop = typeof(T).GetProperty(
                    propName,
                    BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);

                if (prop != null)
                {
                    // create sub-table with relevant rows (field == propName.something)
                    var subTable = new Table("field", "value");
                    var re = new Regex(string.Format(@"^{0}\.([^\.]*)$", propName), RegexOptions.IgnoreCase);
                    table.Rows.OfType<TableRow>().Where(x => re.IsMatch(x[0]))
                        .Select(x => new[] { re.Replace(x[0], "$1"), x[1] })
                        .ToList()
                        .ForEach(x => subTable.AddRow(x));

                    // make recursive call to create child object
                    var createInstance = typeof(TableExtensions)
                        .GetMethod(
                            "BuildInstance",
                            BindingFlags.Public | BindingFlags.Static,
                            null,
                            CallingConventions.Any,
                            new Type[] { typeof(Table) },
                            null);
                    createInstance = createInstance.MakeGenericMethod(prop.PropertyType);
                    object propValue = createInstance.Invoke(null, new object[] { subTable });

                    // assign child object to result
                    prop.SetValue(result, propValue);
                }
            }

            return result;

[marcusoftnet]

But you don't need to make it an extension method (using static and this). You can use the [StepArgumentTransformation] way instead.

Or did I miss something in your original question? You want an extension method?
Then it's outside the scope of this tool, I'm afraid.

It is not necessary for me to make it extension method but marking it as StepARgumentTransformation is not the solutions. I still have to provied T class, but I dont want to. I want to buld dynamic object with nested dynamic objects

[marcusoftnet]

Hmmm - this is something we would need to pair on I'm afraid.

Pretty sure it could work with a StepArgumentTransformation, but I might be wrong.
I'll see if I can play around with it later.

Sorry to stop here and I hope you can find a way.

Thanks for using my little tool

Thanks