update

Author: Wangyang Ding

src/WorkflowCore.DSL/Services/DefinitionLoader.cs

@@ -217,90 +217,117 @@ private void AttachOutputs(StepSourceV1 source, Type dataType, Type stepType, Wo
                 var sourceExpr = DynamicExpressionParser.ParseLambda(new[] { stepParameter }, typeof(object), output.Value);
 
                 var dataParameter = Expression.Parameter(dataType, "data");
-                Expression targetProperty = dataParameter;
 
-                // Check if our datatype has a matching property
 
-                PropertyInfo propertyInfo = null;
-                String[] paths = output.Key.Split('.');
-
-                bool hasAddOutput = false;
-
-                foreach (String propertyName in paths)
+                if(output.Key.Contains(".") || output.Key.Contains("["))
                 {
-                    if (hasAddOutput)
-                    {
-                        throw new ArgumentException($"Unknown property for output {output.Key} on {source.Id}");
-                    }
+                    AttachNestedOutput(output, step, source, sourceExpr, dataParameter);
+                }else
+                {
+                    AttachDirectlyOutput(output, step, dataType, sourceExpr, dataParameter);
+                }
+            }
+        }
 
-                    if (targetProperty == null)
-                    {
-                        break;
-                    } 
+        private void AttachDirectlyOutput(KeyValuePair<string, string> output, WorkflowStep step, Type dataType, LambdaExpression sourceExpr, ParameterExpression dataParameter)
+        {
+            Expression targetProperty;
 
-                    if (propertyName.Contains("["))
-                    {
-                        String[] items = propertyName.Split('[');
+            // Check if our datatype has a matching property
+            var propertyInfo = dataType.GetProperty(output.Key);
+            if (propertyInfo != null)
+            {
+                targetProperty = Expression.Property(dataParameter, propertyInfo);
+                var targetExpr = Expression.Lambda(targetProperty, dataParameter);
+                step.Outputs.Add(new MemberMapParameter(sourceExpr, targetExpr));
+            }
+            else
+            {
+                // If we did not find a matching property try to find a Indexer with string parameter
+                propertyInfo = dataType.GetProperty("Item");
+                targetProperty = Expression.Property(dataParameter, propertyInfo, Expression.Constant(output.Key));
 
-                        if (items.Length != 2)
-                        {
-                            throw new ArgumentException($"Unknown property for output {output.Key} on {source.Id}");
-                        }
+                Action<IStepBody, object> acn = (pStep, pData) =>
+                {
+                    object resolvedValue = sourceExpr.Compile().DynamicInvoke(pStep); ;
+                    propertyInfo.SetValue(pData, resolvedValue, new object[] { output.Key });
+                };
 
-                        items[1] = items[1].Trim().TrimEnd(']').Trim().Trim('"');
+                step.Outputs.Add(new ActionParameter<IStepBody, object>(acn));
+            }
 
-                        MemberExpression memberExpression = Expression.Property(targetProperty, items[0]);
+        }
 
-                        if (memberExpression == null)
-                        {
-                            throw new ArgumentException($"Unknown property for output {output.Key} on {source.Id}");
-                        }
-                        propertyInfo = ((PropertyInfo)memberExpression.Member).PropertyType.GetProperty("Item");  
+        private void AttachNestedOutput( KeyValuePair<string, string> output, WorkflowStep step, StepSourceV1 source, LambdaExpression sourceExpr, ParameterExpression dataParameter)
+        {
+            PropertyInfo propertyInfo = null;
+            String[] paths = output.Key.Split('.');
+         
+            Expression targetProperty = dataParameter;
 
-                        Action<IStepBody, object> acn = (pStep, pData) =>
-                        {
-                            var targetExpr = Expression.Lambda(memberExpression, dataParameter);
-                            object data = targetExpr.Compile().DynamicInvoke(pData);
-                            object resolvedValue = sourceExpr.Compile().DynamicInvoke(pStep); ;
-                            propertyInfo.SetValue(data, resolvedValue, new object[] { items[1] });
-                        };
-
-                        step.Outputs.Add(new ActionParameter<IStepBody, object>(acn));
-                        hasAddOutput = true;
-                    }
-                    else
-                    {
-                        try
-                        {
-                            targetProperty = Expression.Property(targetProperty, propertyName);
-                        }catch
-                        {
-                            targetProperty = null;
-                            break;
-                        }
-                    }
+            bool hasAddOutput = false;
+
+            foreach (String propertyName in paths)
+            {
+                if (hasAddOutput)
+                {
+                    throw new ArgumentException($"Unknown property for output {output.Key} on {source.Id}");
                 }
 
-                if (targetProperty != null && ! hasAddOutput)
+                if (targetProperty == null)
                 {
-                    var targetExpr = Expression.Lambda(targetProperty, dataParameter);
-                    step.Outputs.Add(new MemberMapParameter(sourceExpr, targetExpr));
+                    break;
                 }
-                else if (! hasAddOutput)
+
+                if (propertyName.Contains("["))
                 {
-                    // If we did not find a matching property try to find a Indexer with string parameter
-                    propertyInfo = dataType.GetProperty("Item");
-                    targetProperty = Expression.Property(dataParameter, propertyInfo, Expression.Constant(output.Key));
+                    String[] items = propertyName.Split('[');
+
+                    if (items.Length != 2)
+                    {
+                        throw new ArgumentException($"Unknown property for output {output.Key} on {source.Id}");
+                    }
+
+                    items[1] = items[1].Trim().TrimEnd(']').Trim().Trim('"');
+
+                    MemberExpression memberExpression = Expression.Property(targetProperty, items[0]);
+
+                    if (memberExpression == null)
+                    {
+                        throw new ArgumentException($"Unknown property for output {output.Key} on {source.Id}");
+                    }
+                    propertyInfo = ((PropertyInfo)memberExpression.Member).PropertyType.GetProperty("Item");
 
                     Action<IStepBody, object> acn = (pStep, pData) =>
                     {
+                        var targetExpr = Expression.Lambda(memberExpression, dataParameter);
+                        object data = targetExpr.Compile().DynamicInvoke(pData);
                         object resolvedValue = sourceExpr.Compile().DynamicInvoke(pStep); ;
-                        propertyInfo.SetValue(pData, resolvedValue, new object[] { output.Key });
+                        propertyInfo.SetValue(data, resolvedValue, new object[] { items[1] });
                     };
 
                     step.Outputs.Add(new ActionParameter<IStepBody, object>(acn));
+                    hasAddOutput = true;
+                }
+                else
+                {
+                    try
+                    {
+                        targetProperty = Expression.Property(targetProperty, propertyName);
+                    }
+                    catch
+                    {
+                        targetProperty = null;
+                        break;
+                    }
                 }
             }
+
+            if (targetProperty != null && !hasAddOutput)
+            {
+                var targetExpr = Expression.Lambda(targetProperty, dataParameter);
+                step.Outputs.Add(new MemberMapParameter(sourceExpr, targetExpr));
+            }
         }
 
         private void AttachOutcomes(StepSourceV1 source, Type dataType, WorkflowStep step)

test/WorkflowCore.TestAssets/DataTypes/CounterBoardWithDynamicData.cs

@@ -5,5 +5,6 @@ namespace WorkflowCore.TestAssets.DataTypes
     public class CounterBoardWithDynamicData: CounterBoard
     {
         public DynamicData DynamicDataInstance { get; set; }
+        public CounterBoard CounterBoardInstance { get; set; }
     }
 }

test/WorkflowCore.TestAssets/stored-dynamic-definition.yaml

@@ -15,7 +15,7 @@ Steps:
   Inputs:
     Value: data.Counter2
   Outputs:
-    Counter2: step.Value
+    CounterBoardInstance.Counter1: step.Value
   NextStepId: Step3
 - Id: Step3
   StepType: WorkflowCore.Primitives.If, WorkflowCore