added in ability to access all process variables through FullKeys which goes beyond the variable container and moves up into the process definition to list runtime constants, definition constants and definition files.

Author: roger-castaldo

BusinessProcess.cs

@@ -119,6 +119,54 @@ public object this[string name]
             }
         }
 
+        internal string[] Keys
+        {
+            get
+            {
+                List<string> ret = new List<string>();
+                if (_constants != null)
+                {
+                    foreach (sProcessRuntimeConstant sprc in _constants)
+                    {
+                        if (!ret.Contains(sprc.Name))
+                            ret.Add(sprc.Name);
+                    }
+                }
+                if (_Elements != null)
+                {
+                    foreach (IElement elem in _Elements)
+                    {
+                        if (elem is Definition)
+                        {
+                            Definition def = (Definition)elem;
+                            if (def.ExtensionElement != null)
+                            {
+                                foreach (IElement e in ((ExtensionElements)def.ExtensionElement).Children)
+                                {
+                                    if (e is DefinitionVariable)
+                                    {
+                                        DefinitionVariable dv = (DefinitionVariable)e;
+                                        if (!ret.Contains(dv.Name))
+                                            ret.Add(dv.Name);
+                                    }
+                                    else if (e is DefinitionFile)
+                                    {
+                                        DefinitionFile df = (DefinitionFile)e;
+                                        if (!ret.Contains(string.Format("{0}.{1}", df.Name, df.Extension)))
+                                            ret.Add(string.Format("{0}.{1}", df.Name, df.Extension));
+                                        if (!ret.Contains(df.Name))
+                                            ret.Add(df.Name);
+                                    }
+                                }
+                            }
+                            break;
+                        }
+                    }
+                }
+                return ret.ToArray();
+            }
+        }
+
         [ThreadStatic()]
         private static BusinessProcess _current;
         public static BusinessProcess Current { get { return _current; } }

ProcessVariablesContainer.cs

@@ -87,5 +87,29 @@ public string[] Keys
                 return ret.ToArray();
             }
         }
+
+        public string[] FullKeys
+        {
+            get
+            {
+                List<string> ret = new List<string>(Keys);
+                if (_process!=null)
+                {
+                    foreach (string key in _process.Keys)
+                    {
+                        if (!ret.Contains(key))
+                            ret.Add(key);
+                    }
+                }else if (BusinessProcess.Current != null)
+                {
+                    foreach (string key in BusinessProcess.Current.Keys)
+                    {
+                        if (!ret.Contains(key))
+                            ret.Add(key);
+                    }
+                }
+                return ret.ToArray();
+            }
+        }
     }
 }

ReadOnlyProcessVariablesContainer.cs

@@ -27,6 +27,8 @@ internal ReadOnlyProcessVariablesContainer(ProcessVariablesContainer variables)
 
         public string[] Keys { get { return _variables.Keys; } }
 
+        public string[] FullKeys { get { return _variables.FullKeys; } }
+
         public Exception Error { get { return _error; } }
     }
 }