private static IElement searchElement(string name, string screenName, ListUIElements elementsAndIndicator) { List <IElement> elements = elementsAndIndicator.Elements; ListElementsIndicator indicator = elementsAndIndicator.Indicator; return(DoSearchElement(name, screenName, elements, indicator == ListElementsIndicator.OnlyRootElements)); }
/// <summary> /// /// </summary> /// <param name="classExpression"></param> /// <param name="projectPath"></param> /// <param name="name_space"></param> /// <param name="listUIElements"></param> /// <param name="mapAliasWithNode"></param> /// <param name="myLog"></param> /// <param name="instanceName"></param> /// <returns>relative file path</returns> private string GenerateClassExpScripts(ClassExpression classExpression, string projectPath, string name_space, ListUIElements listUIElements, Dictionary <string, string> mapAliasWithNode, MyLog myLog, string instanceName) { if (classExpression.getName() == null || classExpression.getListFunction() == null || classExpression.getListFunction().Count <= 0) { return(null); } string functionsScripts = ""; foreach (FunctionExpression func in classExpression.getListFunction()) { if (functionsScripts != "") { functionsScripts += NEW_LINE; } functionsScripts += GenerateFunctionExpScripts(func, listUIElements, mapAliasWithNode, myLog, instanceName); } // create new file string classContent = GetTemplateUCClassContent() //.Replace(GLOBAL_REPLACE, "") disabled by @duongtd 05/29 .Replace(CLASS_REPLACE, classExpression.getName()) .Replace(CONTENT_REPLACE, functionsScripts); string filePath = Path.Combine(classExpression.GetCorrectWorkspace(), classExpression.getName() + ".cs"); string fileContentTemplate = GetTemplateRunCsFileContent() .Replace(NAMESPACE_REPLACE, name_space); CreateNewFile(fileContentTemplate, classContent, Path.Combine(projectPath, filePath)); return(filePath); }
/// <summary> /// /// </summary> /// <param name="mapClassFunc">(classname, list of functions)</param> private List <string> GenerateAdditionScripts(Dictionary <string, List <FunctionExpression> > mapClassFunc, string projectPath, string name_space, ListUIElements listUIElements, Dictionary <string, string> mapAliasWithNode, MyLog myLog, string instanceName) { List <string> listRelativeFilePath = new List <string>(); string fileContentTemplate = GetTemplateRunCsFileContent() .Replace(NAMESPACE_REPLACE, name_space); foreach (var pair in mapClassFunc) { string className = pair.Key; List <FunctionExpression> listFunctions = pair.Value; string functionsScripts = ""; foreach (FunctionExpression func in listFunctions) { if (functionsScripts != "") { functionsScripts += NEW_LINE; } functionsScripts += GenerateFunctionExpScripts(func, listUIElements, mapAliasWithNode, myLog, instanceName); } // create new file string classContent = GetTemplateUCClassContent() //.Replace(GLOBAL_REPLACE, "") modified by @duong 05/29 .Replace(CLASS_REPLACE, className) .Replace(CONTENT_REPLACE, functionsScripts); string filePath = Path.Combine("UserCode", className + ".cs"); listRelativeFilePath.Add(filePath); CreateNewFile(fileContentTemplate, classContent, Path.Combine(projectPath, filePath)); } return(listRelativeFilePath); }
private SpecNode parseNode(string expression, ListUIElements elementsAndIndicator, Dictionary <string, string> mappingAlias, MyLog myLog) { /** * determine if Delay */ if (Regex.IsMatch(expression, AbstractSpecUserAction.DELAY_TITLE_EXPRESSION)) { return(new SpecNode(expression)); } /** * determine if Wait */ if (Regex.IsMatch(expression, AbstractSpecUserAction.PRE_WAIT + "(_\\d*)*") || Regex.IsMatch(expression, AbstractSpecUserAction.POST_WAIT + "(_\\d*)*")) { return(new SpecNode(expression)); } /** * determine if Keyboard */ if (Regex.IsMatch(expression, AbstractSpecUserAction.KEYBOARD_PRESS_REGEX)) { return(new SpecNode(expression)); } /** * determine if Result */ if (Regex.IsMatch(expression, AbstractSpecUserAction.RESULT)) { return(new SpecNode(expression)); } /** * determine if UserCode */ if (Regex.IsMatch(expression, AbstractSpecUserAction.USER_CODE)) { return(new SpecNode(expression)); } if (Regex.IsMatch(expression, AbstractSpecUserAction.USER_CODE_WITH_VARIABLE_DECLARE)) { return(new SpecNode(expression)); } Tuple <IElement, string> pair = parseNodeAndAttribute(expression, elementsAndIndicator, mappingAlias, myLog); if (pair == null) { return(null); } return(new SpecNode(pair.Item1, pair.Item2, expression)); }
/// <summary> /// /// </summary> /// <param name="pairSheet"></param> /// <param name="elementsAndIndicator">indication to determine root elements or list of all elements</param> /// <param name="myLog"></param> /// <returns></returns> private TestSpecificationScreen parsePairSheet(Tuple <TestSpecificationSheet, FunctionDescriptionSheet> pairSheet, ListUIElements elementsAndIndicator, MyLog myLog) { FunctionSheetParser functionSheetParser = new FunctionSheetParser(); List <ClassExpression> classExpressions = functionSheetParser.parse(pairSheet.Item2, myLog); TestSpecSheetParser testSpecSheetParser = new TestSpecSheetParser(); return(testSpecSheetParser.parse(pairSheet.Item1, elementsAndIndicator, myLog, classExpressions)); }
/// <summary> /// /// </summary> /// <param name="classesExpression"></param> /// <param name="projectPath"></param> /// <param name="name_space"></param> /// <param name="listUIElements"></param> /// <param name="mapAliasWithNode"></param> /// <param name="myLog"></param> /// <param name="instanceName"></param> /// <returns>a list of relative file path</returns> private List <string> GenerateClassExpScripts(List <ClassExpression> classesExpression, string projectPath, string name_space, ListUIElements listUIElements, Dictionary <string, string> mapAliasWithNode, MyLog myLog, string instanceName) { List <string> re = new List <string>(); foreach (ClassExpression classExp in classesExpression) { re.Add(GenerateClassExpScripts(classExp, projectPath, name_space, listUIElements, mapAliasWithNode, myLog, instanceName)); } return(re); }
public static IElement SearchIElement(string name, ListUIElements listUIElements) { if (listUIElements.Indicator == ListElementsIndicator.AllElements) { return(listUIElements.Elements.FirstOrDefault(ele => ele.Attributes.Name.Equals(name))); } foreach (IElement element in listUIElements.Elements) { IElement temp = DoSearchElementRecursive(name, element); if (temp != null) { return(temp); } } return(null); }
public static string ParamExp2String(string param, ListUIElements listUIElements, Dictionary <string, string> mapAliasWithNode, MyLog myLog, string instanceName, ScriptType scriptType) { string tempParamExp = ""; // Variable_ControlCPUStatus if (Regex.IsMatch(param, USER_CODE_WITH_VARIABLE_DECLARE)) { tempParamExp += param; } // Text Box One.Text else { tempParamExp += Node2ParamExp(param, listUIElements, mapAliasWithNode, myLog, instanceName, scriptType); } return(tempParamExp); }
/// <summary> /// /// </summary> /// <param name="filePath"></param> /// <param name="listUIElements">only root elements or all elements, depend on indicator attribute</param> /// <returns></returns> public bool Generate(string filePath, ListUIElements listUIElements) { // create a temp file string tempFilePath = Path.Combine(Path.GetTempPath(), GENERATED_FILE_NAME + "_" + DateTime.Now.ToString("yyMMdd-HHmmss")); File.Copy( //@"Resources\PictMaster-Template" @"D:\Research\projects\GUI-Testing-Automation\TestingApplication\Resources\PictMaster-Template.xls" , tempFilePath); Application excel = new Application(); Workbook workbook = excel.Workbooks.Open(tempFilePath, ReadOnly: false, Editable: true); Worksheet worksheet = workbook.Worksheets.Item[1] as Worksheet; if (worksheet == null) { return(false); } int rowIdx = 9; int colIdx = 2; int rowConstraintIdx = 66; if (listUIElements.Indicator == ListElementsIndicator.AllElements) { GenerateElements(listUIElements.Elements, ref rowIdx, ref rowConstraintIdx, ref colIdx, worksheet); } else if (listUIElements.Indicator == ListElementsIndicator.OnlyRootElements) { GenerateWithElementsRecursive(listUIElements.Elements, ref rowIdx, ref rowConstraintIdx, ref colIdx, worksheet); } excel.Application.ActiveWorkbook.Save(); excel.Application.Quit(); excel.Quit(); // move temp file to return File.Move(tempFilePath, filePath); return(true); }
public TestSpecificationScreen parse(TestSpecificationSheet testSpecSheet, ListUIElements elementsAndIndicator, MyLog myLog, List <ClassExpression> classExpressions) { NormalSheetParser normalSheetParser = new NormalSheetParser(); SpecScreen screen = normalSheetParser.Parse(testSpecSheet, elementsAndIndicator, myLog); if (screen == null) { return(null); } TestSpecificationScreen re = new TestSpecificationScreen(); re.AllUIElements = elementsAndIndicator; re.ListSpecNodes = screen.ListSpecNodes; re.ListValidationUserCode = screen.ListValidationUserCode; re.MappingAliasWithNode = screen.MappingAliasWithNode; re.Name = testSpecSheet.getFeatureName(); re.Scenarios = screen.Scenarios; re.ClassExpressions = classExpressions; return(re); }
/// <summary> /// only retrieve MapClassAndFuncsAddition /// </summary> /// <param name="listUcScriptsExp"></param> private List <string> GenerateAdditionScripts(List <UserCodeScriptsExpression> listUcScriptsExp, string projectPath, string name_space, ListUIElements listUIElements, Dictionary <string, string> mapAliasWithNode, MyLog myLog, string instanceName) { Dictionary <string, List <FunctionExpression> > mapClassFunc = new Dictionary <string, List <FunctionExpression> >(); foreach (var ucScriptsExp in listUcScriptsExp) { var newMapClassFunc = ucScriptsExp.MapClassAndFuncsAddition; foreach (var pair in newMapClassFunc) { if (mapClassFunc.ContainsKey(pair.Key)) { mapClassFunc[pair.Key].AddRange(pair.Value); } else { mapClassFunc.Add(pair.Key, pair.Value); } } } return(GenerateAdditionScripts(mapClassFunc, projectPath, name_space, listUIElements, mapAliasWithNode, myLog, instanceName)); }
/// <summary> /// 'GetAttributeValue<object>("Text")' for Ranorex /// </summary> /// <param name="nodeExp"></param> /// <param name="listUIElements"></param> /// <param name="mappingAlias"></param> /// <param name="myLog"></param> /// <param name="instanceName"></param> /// <returns></returns> public static string Node2ParamExp(string nodeExp, ListUIElements listUIElements, Dictionary <string, string> mappingAlias, MyLog myLog, string instanceName, ScriptType scriptType) { Tuple <IElement, string> elementAndAttibute = NormalSheetParser.parseNodeAndAttribute(nodeExp, listUIElements, mappingAlias, myLog); if (elementAndAttibute == null || elementAndAttibute.Item1 == null) { myLog.Warn("cannot find node: " + nodeExp); return("null"); } if (scriptType == ScriptType.Normal) { return(GetScriptAccessElement(elementAndAttibute.Item1, instanceName)); } //Ranorex scripts string re = getScriptAccessRanorexElement( new SpecNode(elementAndAttibute.Item1, elementAndAttibute.Item2, null), instanceName); if (elementAndAttibute.Item2 != null && !elementAndAttibute.Item2.Equals("")) { re += ".GetAttributeValue<object>(\"" + elementAndAttibute.Item2 + "\")"; } return(re); }
/// <summary> /// scripts content for a function /// </summary> /// <param name="functionExpression"></param> /// <param name="listUIElements"></param> /// <param name="mapAliasWithNode"></param> /// <param name="myLog"></param> /// <param name="instanceName"></param> /// <returns></returns> private string GenerateFunctionExpScripts(FunctionExpression functionExpression, ListUIElements listUIElements, Dictionary <string, string> mapAliasWithNode, MyLog myLog, string instanceName) { string accessibility = functionExpression.GetCorrectAccessibility(); string summary = functionExpression.getSummary(); List <ParameterExpression> @params = functionExpression.getParams(); string name = functionExpression.getName(); string returnDes = functionExpression.getReturnDescription(); string content = functionExpression.getContent(); string re = ""; if (summary != null) { re += "/// <summary>" + NEW_LINE; string[] listLines = summary.Split('\n'); foreach (string line in listLines) { re += "/// " + line + NEW_LINE; } re += "/// </summary>"; } var pair = GetParamsScripts(@params, listUIElements, mapAliasWithNode, myLog, instanceName); if (pair.Item2 != null && pair.Item2.Count > 0) { for (int fi = 0; fi < pair.Item2.Count; fi++) { string paramName = pair.Item2[fi]; string paramDesc = @params[fi].getDescription(); if (paramDesc == null) { paramDesc = ""; } if (re != "") { re += NEW_LINE; } re += "/// <param name=\"" + paramName + "\">" + paramDesc + "</param>"; } } string returnType = functionExpression.GetCorrectReturnType(); if (returnType != FunctionExpression.VOID) { if (re != "") { re += NEW_LINE; } re += "/// <returns>" + (returnDes ?? "") + "</returns>"; } if (re != "") { re += NEW_LINE; } // Ranorex need to insert annotation re += InsertAnnotation(); re += accessibility + " static " + returnType + " " + name + "("; re += pair.Item1; re += ")" + NEW_LINE; re += "{" + NEW_LINE; if (content != null) { string[] listLines = content.Split('\n'); foreach (string line in listLines) { string line1 = line.Trim().StartsWith("//") ? line.Trim() : "// " + line.Trim(); re += line1 + NEW_LINE; } } if (returnType != FunctionExpression.VOID) { re += "return null;" + NEW_LINE; } re += "}" + NEW_LINE; return(re); }
/// <summary> /// /// </summary> /// <param name="filePath"></param> /// <param name="elementsAndIndicator">indication to determine root elements or list of all elements</param> /// <param name="myLog"></param> /// <returns></returns> private List <SpecScreen> DoParse(string filePath, ListUIElements elementsAndIndicator, MyLog myLog) { string newFilePath = Utils.CreateTempFile(filePath); //Create COM Objects. Create a COM object for everything that is referenced Excel.Application xlApp = new Excel.Application(); Excel.Workbook xlWorkbook = xlApp.Workbooks.Open(newFilePath); //Excel._Worksheet xlWorksheet = xlWorkbook.Sheets[1]; List <AbstractSheet> listAbstractSheets = new List <AbstractSheet>(); for (int fi = 1; fi <= xlWorkbook.Sheets.Count; fi++) { Excel._Worksheet sheet = xlWorkbook.Sheets[fi]; string name = sheet.Name; AbstractSheet abstractSheet = null; foreach (Tuple <string, string> pairSheetNameRule in SHEET_NAME_TEMPLATE_LIST) { Regex regex = new Regex(pairSheetNameRule.Item1); MatchCollection matches = regex.Matches(name); if (matches.Count > 0) { string featureName = matches[0].Groups[1].Value; abstractSheet = new TestSpecificationSheet(featureName, sheet); } else { Regex regex2 = new Regex(pairSheetNameRule.Item2); MatchCollection matches2 = regex2.Matches(name); if (matches2.Count > 0) { string featureName = matches2[0].Groups[1].Value; abstractSheet = new FunctionDescriptionSheet(featureName, sheet); } } } if (abstractSheet == null) { abstractSheet = new NormalSheet(name, sheet); } listAbstractSheets.Add(abstractSheet); } List <NormalSheet> normalSheets = new List <NormalSheet>(); List <Tuple <TestSpecificationSheet, FunctionDescriptionSheet> > pairSheets = new List <Tuple <TestSpecificationSheet, FunctionDescriptionSheet> >(); foreach (AbstractSheet abstractSheet in listAbstractSheets) { if (abstractSheet is NormalSheet) { normalSheets.Add((NormalSheet)abstractSheet); } else if (abstractSheet is TestSpecificationSheet) { FunctionDescriptionSheet funcDescSheet = findFuncDesc(abstractSheet.getFeatureName(), listAbstractSheets); pairSheets.Add(new Tuple <TestSpecificationSheet, FunctionDescriptionSheet>( (TestSpecificationSheet)abstractSheet, funcDescSheet)); } } List <SpecScreen> screenList = new List <SpecScreen>(); foreach (Tuple <TestSpecificationSheet, FunctionDescriptionSheet> pairSheet in pairSheets) { SpecScreen screen = parsePairSheet(pairSheet, elementsAndIndicator, myLog); if (screen != null) { screenList.Add(screen); } } foreach (NormalSheet normalSheet in normalSheets) { SpecScreen screen = parseNormalSheet(normalSheet, elementsAndIndicator, myLog); if (screen != null) { screenList.Add(screen); } } //return screenList; //cleanup //GC.Collect(); //GC.WaitForPendingFinalizers(); //rule of thumb for releasing com objects: // never use two dots, all COM objects must be referenced and released individually // ex: [somthing].[something].[something] is bad //close and release xlWorkbook.Close(false); Marshal.ReleaseComObject(xlWorkbook); //quit and release xlApp.Quit(); Marshal.ReleaseComObject(xlApp); return(screenList); }
/// <summary> /// /// </summary> /// <param name="sheet"></param> /// <param name="elementsAndIndicator">indication to determine root elements or list of all elements</param> /// <param name="myLog"></param> /// <returns></returns> private SpecScreen parserOneSheet(Excel._Worksheet sheet, ListUIElements elementsAndIndicator, MyLog myLog) { Excel.Range xlRange = sheet.UsedRange; int rowCount = xlRange.Rows.Count; int columnCount = xlRange.Columns.Count; SpecScreen screen = new SpecScreen(); // get mapping alias Dictionary <string, string> mapAliasWithNode = getMappingAlias(sheet, rowCount, columnCount); screen.MappingAliasWithNode = mapAliasWithNode; /** * read first row to get all element Nodes */ //Row firstRow = sheet.getRow(ROW_TITLE_TESTCASE); string no = getCellValue(sheet, ROW_TITLE_TESTCASE, 1); //if (searchElement(no, null, allUIElements) == null && !no.Equals(NO, stringComparison.OrdinalIgnoreCase)) //{ // logWarnings.add("First column must numbered column!"); // logger.error("First column must numbered column!"); //} List <SpecNode> listSpecNodes = new List <SpecNode>(); // <start, end>-s List <Tuple <int, int> > listValidationUsercode = new List <Tuple <int, int> >(); // get each node element //int lastColumn = firstRow.getLastCellNum(); bool link = false; int startColumnIdx = 2; for (int fi = startColumnIdx; fi <= columnCount; fi++) { string value = getCellValue(sheet, ROW_TITLE_TESTCASE, fi); if (value == null || value.Trim().Equals("")) { if (checkLastColumn(sheet, fi, rowCount)) { columnCount = fi - 1; break; } else { if (listValidationUsercode.Count == 0) { listValidationUsercode.Add(new Tuple <int, int>(fi - 1 - startColumnIdx, fi - startColumnIdx)); } else { Tuple <int, int> lastPair = listValidationUsercode[listValidationUsercode.Count - 1]; if ((fi - lastPair.Item2 - startColumnIdx) == 1) { listValidationUsercode.RemoveAt(listValidationUsercode.Count - 1); listValidationUsercode.Add(new Tuple <int, int>(lastPair.Item1, fi - startColumnIdx)); } else { listValidationUsercode.Add(new Tuple <int, int>(fi - 1 - startColumnIdx, fi - startColumnIdx)); } } listSpecNodes.Add(listSpecNodes.Last()); } } else { if (Regex.IsMatch(value, AbstractSpecUserAction.LINKS)) { columnCount = fi - 1; link = true; break; } else { SpecNode specNode = parseNode(value, elementsAndIndicator, mapAliasWithNode, myLog); if (specNode == null) { return(null); } listSpecNodes.Add(specNode); } } } screen.Name = sheet.Name; screen.AllUIElements = elementsAndIndicator; screen.ListSpecNodes = listSpecNodes; screen.ListValidationUserCode = listValidationUsercode; /** * parseOneFile each scenario */ for (int fi = ROW_TITLE_TESTCASE + 1; fi <= rowCount; fi++) { //Row row = sheet.getRow(fi); bool isRowNotTest = true; if (getCellValue(sheet, fi, 1) == null || getCellValue(sheet, fi, 2) == null) { rowCount = fi - 1; break; } SpecScenario scenario = new SpecScenario(); for (int se = 2; se <= columnCount; se++) { Color color = Color.Empty; string value = getCellValue(sheet, fi, se); /** * check if result indicate 'not_test' */ if (listSpecNodes[se - 2].Expression.Equals(AbstractSpecUserAction.RESULT)) { if (value.Equals(AbstractSpecUserAction.NOT_TEST)) { isRowNotTest = true; break; } else if (value.Equals(AbstractSpecUserAction.TEST) || value.Equals("")) { ; } else { myLog.Warn("[WARNING] Result must be 'Test' or 'Not Test', not " + value + ", it will be treated as 'Test' by default", logger); } } color = getCellBgColor(sheet, fi, se); if (color.Equals(Color.Empty) || ( !color.Equals(AbstractSpecUserAction.NOT_TEST_COLOR1) && !color.Equals(AbstractSpecUserAction.NOT_TEST_COLOR2))) { isRowNotTest = false; } scenario.UserActionsInString.Add(value); scenario.Colors.Add(color); } if (isRowNotTest) { continue; } /** * pre-condition */ string linkExpress = ""; string lastCellValue = getCellValue(sheet, fi, columnCount + 1); if (link && lastCellValue != null && !lastCellValue.Equals("")) { linkExpress = lastCellValue; string[] preConsExp = linkExpress.Split(','); foreach (string preConExp in preConsExp) { scenario.PreConditionsExpression.Add(preConExp.Trim()); } } scenario.Id = fi - ROW_TITLE_TESTCASE; //scenario.ScreenName = screen.Name; if (screen.Scenarios == null) { screen.Scenarios = new List <IScenario>(); } screen.Scenarios.Add(scenario); } //release com objects to fully kill excel process from running in the background Marshal.ReleaseComObject(xlRange); Marshal.ReleaseComObject(sheet); return(screen); }
/// <summary> /// /// </summary> /// <param name="normalSheet"></param> /// <param name="elementsAndIndicator">indication to determine root elements or list of all elements</param> /// <param name="myLog"></param> /// <returns></returns> public SpecScreen Parse(AbstractSheet normalSheet, ListUIElements elementsAndIndicator, MyLog myLog) { return(parserOneSheet(normalSheet.getSheet(), elementsAndIndicator, myLog)); }
public static Tuple <IElement, string> parseNodeAndAttribute(string expression, ListUIElements elementsAndIndicator, Dictionary <string, string> mappingAlias, MyLog myLog) { if (mappingAlias != null && mappingAlias.ContainsKey(expression)) { expression = mappingAlias[expression]; } string[] subs = expression.Split('.'); string screenName = null; string nodeName = null; string attribute = null; IElement element = null; //case MainForm if (subs.Length == 1) { nodeName = subs[0]; element = searchElement(nodeName, screenName, elementsAndIndicator); } //case MainForm.Button else if (subs.Length == 2) { screenName = subs[0]; nodeName = subs[1]; element = searchElement(nodeName, screenName, elementsAndIndicator); //case MainForm.Text if (element == null) { attribute = nodeName; element = searchElement(screenName, null, elementsAndIndicator); } } //case MainForm.Button.Text and MainForm.DataGridView.Cell(1,1).Text else { screenName = subs[0]; nodeName = subs[1]; attribute = subs[2]; for (int i = 3; i < subs.Length; i++) { attribute += "." + subs[i]; } element = searchElement(nodeName, screenName, elementsAndIndicator); } if (element == null) { string alias = expression.Split('.')[0]; if (mappingAlias != null && mappingAlias.ContainsKey(alias)) { return(parseNodeAndAttribute(expression.Replace(alias, mappingAlias[alias]), elementsAndIndicator, mappingAlias, myLog)); } else { myLog.Warn("Can not find element " + expression, logger); return(null); } } return(new Tuple <IElement, string>(element, attribute)); }
/// <summary> /// /// </summary> /// <param name="normalSheet"></param> /// <param name="elementsAndIndicator">indication to determine root elements or list of all elements</param> /// <param name="myLog"></param> /// <returns></returns> private SpecScreen parseNormalSheet(NormalSheet normalSheet, ListUIElements elementsAndIndicator, MyLog myLog) { NormalSheetParser normalSheetParser = new NormalSheetParser(); return(normalSheetParser.Parse(normalSheet, elementsAndIndicator, myLog)); }
/// <summary> /// </summary> /// <param name="params"></param> /// <param name="listUIElements"></param> /// <param name="mapAliasWithNode"></param> /// <param name="myLog"></param> /// <param name="instanceName"></param> /// <returns>{params scripts, list of param's name}</returns> private Tuple <string, List <string> > GetParamsScripts(List <ParameterExpression> @params, ListUIElements listUIElements, Dictionary <string, string> mapAliasWithNode, MyLog myLog, string instanceName) { if (@params == null || @params.Count == 0) { return(new Tuple <string, List <string> >("", null)); } string re = ""; List <string> nameParams = new List <string>(); for (int fi = 1; fi <= @params.Count; fi++) { ParameterExpression param = @params[fi - 1]; if (re != "") { re += ", "; } string varName = "param_" + fi; nameParams.Add(varName); re += "object " + varName; } return(new Tuple <string, List <string> >(re, nameParams)); }