Prompt(string caption, string message, Collection<FieldDescription> descriptions)
{
// Need to implement EchoOnPrompt
HandleThrowOnReadAndPrompt();
if (descriptions == null)
{
throw PSTraceSource.NewArgumentNullException("descriptions");
}
if (descriptions.Count < 1)
{
throw PSTraceSource.NewArgumentException("descriptions",
ConsoleHostUserInterfaceStrings.PromptEmptyDescriptionsErrorTemplate, "descriptions");
}
// we lock here so that multiple threads won't interleave the various reads and writes here.
lock (_instanceLock)
{
Dictionary<string, PSObject> results = new Dictionary<string, PSObject>();
Boolean cancelInput = false;
if (!String.IsNullOrEmpty(caption))
{
// Should be a skin lookup
WriteLineToConsole();
WriteToConsole(PromptColor, RawUI.BackgroundColor, WrapToCurrentWindowWidth(caption));
WriteLineToConsole();
}
if (!String.IsNullOrEmpty(message))
{
WriteLineToConsole(WrapToCurrentWindowWidth(message));
}
if (AtLeastOneHelpMessageIsPresent(descriptions))
{
WriteLineToConsole(WrapToCurrentWindowWidth(ConsoleHostUserInterfaceStrings.PromptHelp));
}
int descIndex = -1;
foreach (FieldDescription desc in descriptions)
{
descIndex++;
if (desc == null)
{
throw PSTraceSource.NewArgumentException("descriptions",
ConsoleHostUserInterfaceStrings.NullErrorTemplate,
string.Format(CultureInfo.InvariantCulture, "descriptions[{0}]", descIndex));
}
PSObject inputPSObject = null;
string fieldPrompt = null;
fieldPrompt = desc.Name;
bool fieldEchoOnPrompt = true;
// FieldDescription.ParameterAssemblyFullName never returns null. But this is
// defense in depth.
if (string.IsNullOrEmpty(desc.ParameterAssemblyFullName))
{
string paramName =
string.Format(CultureInfo.InvariantCulture, "descriptions[{0}].AssemblyFullName", descIndex);
throw PSTraceSource.NewArgumentException(paramName, ConsoleHostUserInterfaceStrings.NullOrEmptyErrorTemplate, paramName);
}
Type fieldType = InternalHostUserInterface.GetFieldType(desc);
if (fieldType == null)
{
if (InternalHostUserInterface.IsSecuritySensitiveType(desc.ParameterTypeName))
{
string errMsg =
StringUtil.Format(ConsoleHostUserInterfaceStrings.PromptTypeLoadErrorTemplate,
desc.Name, desc.ParameterTypeFullName);
PromptingException e = new PromptingException(errMsg,
null, "BadTypeName", ErrorCategory.InvalidType);
throw e;
}
fieldType = typeof(string);
}
if (fieldType.GetInterface(typeof(IList).FullName) != null)
{
// field is a type implementing IList
ArrayList inputList = new ArrayList(); // stores all converted user input before
// assigned to an array
// if the field is an array, the element type can be found; else, use Object
Type elementType = typeof(Object);
if (fieldType.IsArray)
{
elementType = fieldType.GetElementType();
int rank = fieldType.GetArrayRank();
// This check may be redundant because it doesn't seem possible to create
// an array of zero dimension.
if (rank <= 0)
{
string msg = StringUtil.Format(ConsoleHostUserInterfaceStrings.RankZeroArrayErrorTemplate, desc.Name);
ArgumentException innerException = PSTraceSource.NewArgumentException(
string.Format(CultureInfo.InvariantCulture,
"descriptions[{0}].AssemblyFullName", descIndex));
PromptingException e = new PromptingException(msg, innerException, "ZeroRankArray", ErrorCategory.InvalidOperation);
throw e;
}
}
StringBuilder fieldPromptList = new StringBuilder(fieldPrompt);
// fieldPromptList = fieldPrompt + "[i] :"
fieldPromptList.Append("[");
while (true)
{
fieldPromptList.Append(
string.Format(CultureInfo.InvariantCulture, "{0}]: ", inputList.Count));
Boolean inputListEnd = false;
Object convertedObj = null;
string inputString = PromptForSingleItem(elementType, fieldPromptList.ToString(), fieldPrompt, caption, message,
desc, fieldEchoOnPrompt, true, out inputListEnd, out cancelInput, out convertedObj);
if (cancelInput || inputListEnd)
{
break;
}
else if (!cancelInput)
{
inputList.Add(convertedObj);
// Remove the indices from the prompt
fieldPromptList.Length = fieldPrompt.Length + 1;
}
}
// if cancelInput, should throw OperationCancelException?
if (!cancelInput)
{
object tryConvertResult = null;
if (LanguagePrimitives.TryConvertTo(inputList, fieldType, out tryConvertResult))
{
inputPSObject = PSObject.AsPSObject(tryConvertResult);
}
else
{
inputPSObject = PSObject.AsPSObject(inputList);
}
}
}
else
{
string printFieldPrompt = StringUtil.Format(ConsoleHostUserInterfaceStrings.PromptFieldPromptInputSeparatorTemplate,
fieldPrompt);
// field is not a list
Object convertedObj = null;
Boolean dummy = false;
PromptForSingleItem(fieldType, printFieldPrompt, fieldPrompt, caption, message, desc,
fieldEchoOnPrompt, false, out dummy, out cancelInput, out convertedObj);
if (!cancelInput)
{
inputPSObject = PSObject.AsPSObject(convertedObj);
}
}
if (cancelInput)
{
s_tracer.WriteLine("Prompt canceled");
WriteLineToConsole();
results.Clear();
break;
}
results.Add(desc.Name, PSObject.AsPSObject(inputPSObject));
}
return results;
}
}
public Collection<int> PromptForChoice(string caption, string message, Collection<ChoiceDescription> choices, IEnumerable<int> defaultChoices)
{
ConsoleHostUserInterface.ReadLineResult readLineResult = ConsoleHostUserInterface.ReadLineResult.endedOnEnter;
Collection<int> nums;
this.HandleThrowOnReadAndPrompt();
if (choices != null)
{
if (choices.Count != 0)
{
Dictionary<int, bool> nums1 = new Dictionary<int, bool>();
if (defaultChoices != null)
{
foreach (int defaultChoice in defaultChoices)
{
if (defaultChoice < 0 || defaultChoice >= choices.Count)
{
object[] objArray = new object[3];
objArray[0] = "defaultChoice";
objArray[1] = "choices";
objArray[2] = defaultChoice;
throw PSTraceSource.NewArgumentOutOfRangeException("defaultChoice", defaultChoice, "ConsoleHostUserInterfaceStrings", "InvalidDefaultChoiceForMultipleSelection", objArray);
}
else
{
if (nums1.ContainsKey(defaultChoice))
{
continue;
}
nums1.Add(defaultChoice, true);
}
}
}
Collection<int> nums2 = new Collection<int>();
lock (this.instanceLock)
{
if (!string.IsNullOrEmpty(caption))
{
this.WriteLineToConsole();
this.WriteToConsole(this.PromptColor, this.RawUI.BackgroundColor, this.WrapToCurrentWindowWidth(caption));
this.WriteLineToConsole();
}
if (!string.IsNullOrEmpty(message))
{
this.WriteLineToConsole(this.WrapToCurrentWindowWidth(message));
}
string[,] strArrays = null;
HostUIHelperMethods.BuildHotkeysAndPlainLabels(choices, out strArrays);
this.WriteChoicePrompt(strArrays, nums1, true);
if (nums1.Count > 0)
{
this.WriteLineToConsole();
}
int num = 0;
while (true)
{
string str = StringUtil.Format(ConsoleHostUserInterfaceStrings.ChoiceMessage, num);
this.WriteToConsole(this.PromptColor, this.RawUI.BackgroundColor, this.WrapToCurrentWindowWidth(str));
string str1 = this.ReadLine(false, "", out readLineResult, true, true);
if (readLineResult == ConsoleHostUserInterface.ReadLineResult.endedOnBreak)
{
string promptCanceledError = ConsoleHostUserInterfaceStrings.PromptCanceledError;
PromptingException promptingException = new PromptingException(promptCanceledError, null, "PromptForChoiceCanceled", ErrorCategory.OperationStopped);
throw promptingException;
}
if (str1.Length == 0)
{
break;
}
if (str1.Trim() != "?")
{
int num1 = HostUIHelperMethods.DetermineChoicePicked(str1.Trim(), choices, strArrays);
if (num1 >= 0)
{
nums2.Add(num1);
num++;
}
}
else
{
this.ShowChoiceHelp(choices, strArrays);
}
}
if (nums2.Count == 0 && nums1.Keys.Count >= 0)
{
foreach (int key in nums1.Keys)
{
nums2.Add(key);
}
}
nums = nums2;
}
return nums;
}
else
{
object[] objArray1 = new object[1];
objArray1[0] = "choices";
throw PSTraceSource.NewArgumentException("choices", "ConsoleHostUserInterfaceStrings", "EmptyChoicesErrorTemplate", objArray1);
}
}
else
{
throw PSTraceSource.NewArgumentNullException("choices");
}
}
public override int PromptForChoice(string caption, string message, Collection<ChoiceDescription> choices, int defaultChoice)
{
ConsoleHostUserInterface.ReadLineResult readLineResult = ConsoleHostUserInterface.ReadLineResult.endedOnEnter;
int num;
this.HandleThrowOnReadAndPrompt();
if (choices != null)
{
if (choices.Count != 0)
{
if (defaultChoice < -1 || defaultChoice >= choices.Count)
{
object[] objArray = new object[2];
objArray[0] = "defaultChoice";
objArray[1] = "choice";
throw PSTraceSource.NewArgumentOutOfRangeException("defaultChoice", defaultChoice, "ConsoleHostUserInterfaceStrings", "InvalidDefaultChoiceErrorTemplate", objArray);
}
else
{
lock (this.instanceLock)
{
if (!string.IsNullOrEmpty(caption))
{
this.WriteLineToConsole();
this.WriteToConsole(this.PromptColor, this.RawUI.BackgroundColor, this.WrapToCurrentWindowWidth(caption));
this.WriteLineToConsole();
}
if (!string.IsNullOrEmpty(message))
{
this.WriteLineToConsole(this.WrapToCurrentWindowWidth(message));
}
int num1 = defaultChoice;
string[,] strArrays = null;
HostUIHelperMethods.BuildHotkeysAndPlainLabels(choices, out strArrays);
Dictionary<int, bool> nums = new Dictionary<int, bool>();
if (defaultChoice >= 0)
{
nums.Add(defaultChoice, true);
}
do
{
Label0:
this.WriteChoicePrompt(strArrays, nums, false);
string str = this.ReadLine(false, "", out readLineResult, true, true);
if (readLineResult != ConsoleHostUserInterface.ReadLineResult.endedOnBreak)
{
if (str.Length != 0)
{
if (str.Trim() != "?")
{
num1 = HostUIHelperMethods.DetermineChoicePicked(str.Trim(), choices, strArrays);
}
else
{
this.ShowChoiceHelp(choices, strArrays);
goto Label0;
}
}
else
{
if (defaultChoice >= 0)
{
num1 = defaultChoice;
break;
}
else
{
goto Label0;
}
}
}
else
{
string promptCanceledError = ConsoleHostUserInterfaceStrings.PromptCanceledError;
PromptingException promptingException = new PromptingException(promptCanceledError, null, "PromptForChoiceCanceled", ErrorCategory.OperationStopped);
throw promptingException;
}
}
while (num1 < 0);
num = num1;
}
return num;
}
}
else
{
object[] objArray1 = new object[1];
objArray1[0] = "choices";
throw PSTraceSource.NewArgumentException("choices", "ConsoleHostUserInterfaceStrings", "EmptyChoicesErrorTemplate", objArray1);
}
}
else
{
throw PSTraceSource.NewArgumentNullException("choices");
}
}
public override Dictionary<string, PSObject> Prompt(string caption, string message, Collection<FieldDescription> descriptions)
{
Dictionary<string, PSObject> strs;
this.HandleThrowOnReadAndPrompt();
if (descriptions != null)
{
if (descriptions.Count >= 1)
{
lock (this.instanceLock)
{
Dictionary<string, PSObject> strs1 = new Dictionary<string, PSObject>();
bool flag = false;
if (!string.IsNullOrEmpty(caption))
{
this.WriteLineToConsole();
this.WriteToConsole(this.PromptColor, this.RawUI.BackgroundColor, this.WrapToCurrentWindowWidth(caption));
this.WriteLineToConsole();
}
if (!string.IsNullOrEmpty(message))
{
this.WriteLineToConsole(this.WrapToCurrentWindowWidth(message));
}
if (ConsoleHostUserInterface.AtLeastOneHelpMessageIsPresent(descriptions))
{
this.WriteLineToConsole(this.WrapToCurrentWindowWidth(ConsoleHostUserInterfaceStrings.PromptHelp));
}
int num = -1;
foreach (FieldDescription description in descriptions)
{
num++;
if (description != null)
{
PSObject pSObject = null;
string name = description.Name;
bool flag1 = true;
if (!string.IsNullOrEmpty(description.ParameterAssemblyFullName))
{
Type fieldType = InternalHostUserInterface.GetFieldType(description);
if (fieldType == null)
{
if (!InternalHostUserInterface.IsSecuritySensitiveType(description.ParameterTypeName))
{
fieldType = typeof(string);
}
else
{
string str = StringUtil.Format(ConsoleHostUserInterfaceStrings.PromptTypeLoadErrorTemplate, description.Name, description.ParameterTypeFullName);
PromptingException promptingException = new PromptingException(str, null, "BadTypeName", ErrorCategory.InvalidType);
throw promptingException;
}
}
if (fieldType.GetInterface(typeof(IList).FullName) == null)
{
string str1 = StringUtil.Format(ConsoleHostUserInterfaceStrings.PromptFieldPromptInputSeparatorTemplate, name);
object obj = null;
bool flag2 = false;
this.PromptForSingleItem(fieldType, str1, name, caption, message, description, flag1, false, out flag2, out flag, out obj);
if (!flag)
{
pSObject = PSObject.AsPSObject(obj);
}
}
else
{
ArrayList arrayLists = new ArrayList();
Type elementType = typeof(object);
if (fieldType.IsArray)
{
elementType = fieldType.GetElementType();
int arrayRank = fieldType.GetArrayRank();
if (arrayRank <= 0)
{
string str2 = StringUtil.Format(ConsoleHostUserInterfaceStrings.RankZeroArrayErrorTemplate, description.Name);
object[] objArray = new object[1];
objArray[0] = num;
ArgumentException argumentException = PSTraceSource.NewArgumentException(string.Format(CultureInfo.InvariantCulture, "descriptions[{0}].AssemblyFullName", objArray));
PromptingException promptingException1 = new PromptingException(str2, argumentException, "ZeroRankArray", ErrorCategory.InvalidOperation);
throw promptingException1;
}
}
StringBuilder stringBuilder = new StringBuilder(name);
stringBuilder.Append("[");
while (true)
{
object[] count = new object[1];
count[0] = arrayLists.Count;
stringBuilder.Append(string.Format(CultureInfo.InvariantCulture, "{0}]: ", count));
bool flag3 = false;
object obj1 = null;
this.PromptForSingleItem(elementType, stringBuilder.ToString(), name, caption, message, description, flag1, true, out flag3, out flag, out obj1);
if (flag || flag3)
{
break;
}
if (!flag)
{
arrayLists.Add(obj1);
stringBuilder.Length = name.Length + 1;
}
}
if (!flag)
{
object obj2 = null;
if (!LanguagePrimitives.TryConvertTo(arrayLists, fieldType, out obj2))
{
pSObject = PSObject.AsPSObject(arrayLists);
}
else
{
pSObject = PSObject.AsPSObject(obj2);
}
}
}
if (!flag)
{
strs1.Add(description.Name, PSObject.AsPSObject(pSObject));
}
else
{
ConsoleHostUserInterface.tracer.WriteLine("Prompt canceled", new object[0]);
this.WriteLineToConsole();
strs1.Clear();
break;
}
}
else
{
object[] objArray1 = new object[1];
objArray1[0] = num;
string str3 = string.Format(CultureInfo.InvariantCulture, "descriptions[{0}].AssemblyFullName", objArray1);
object[] objArray2 = new object[1];
objArray2[0] = str3;
throw PSTraceSource.NewArgumentException(str3, "ConsoleHostUserInterfaceStrings", "NullOrEmptyErrorTemplate", objArray2);
}
}
else
{
object[] objArray3 = new object[1];
object[] objArray4 = new object[1];
objArray4[0] = num;
objArray3[0] = string.Format(CultureInfo.InvariantCulture, "descriptions[{0}]", objArray4);
throw PSTraceSource.NewArgumentException("descriptions", "ConsoleHostUserInterfaceStrings", "NullErrorTemplate", objArray3);
}
}
strs = strs1;
}
return strs;
}
else
{
object[] objArray5 = new object[1];
objArray5[0] = "descriptions";
throw PSTraceSource.NewArgumentException("descriptions", "ConsoleHostUserInterfaceStrings", "PromptEmptyDescriptionsErrorTemplate", objArray5);
}
}
else
{
throw PSTraceSource.NewArgumentNullException("descriptions");
}
}
/// <summary>
///
/// See base class
///
/// </summary>
/// <param name="caption"></param>
/// <param name="message"></param>
/// <param name="choices"></param>
/// <param name="defaultChoice"></param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">
///
/// If <paramref name="choices"/> is null.
///
/// </exception>
/// <exception cref="ArgumentException">
///
/// If <paramref name="choices"/>.Count is 0.
///
/// </exception>
/// <exception cref="ArgumentOutOfRangeException">
///
/// If <paramref name="defaultChoice"/> is greater than
/// the length of <paramref name="choices"/>.
///
/// </exception>
/// <exception cref="PromptingException">
///
/// when prompt is canceled by, for example, Ctrl-c.
///
/// </exception>
public override int PromptForChoice(string caption, string message, Collection<ChoiceDescription> choices, int defaultChoice)
{
HandleThrowOnReadAndPrompt();
if (choices == null)
{
throw PSTraceSource.NewArgumentNullException("choices");
}
if (choices.Count == 0)
{
throw PSTraceSource.NewArgumentException("choices",
ConsoleHostUserInterfaceStrings.EmptyChoicesErrorTemplate, "choices");
}
if ((defaultChoice < -1) || (defaultChoice >= choices.Count))
{
throw PSTraceSource.NewArgumentOutOfRangeException("defaultChoice", defaultChoice,
ConsoleHostUserInterfaceStrings.InvalidDefaultChoiceErrorTemplate, "defaultChoice", "choice");
}
// we lock here so that multiple threads won't interleave the various reads and writes here.
lock (_instanceLock)
{
if (!string.IsNullOrEmpty(caption))
{
// Should be a skin lookup
WriteLineToConsole();
WriteToConsole(PromptColor, RawUI.BackgroundColor, WrapToCurrentWindowWidth(caption));
WriteLineToConsole();
}
if (!string.IsNullOrEmpty(message))
{
WriteLineToConsole(WrapToCurrentWindowWidth(message));
}
int result = defaultChoice;
string[,] hotkeysAndPlainLabels = null;
HostUIHelperMethods.BuildHotkeysAndPlainLabels(choices, out hotkeysAndPlainLabels);
Dictionary<int, bool> defaultChoiceKeys = new Dictionary<int, bool>();
// add the default choice key only if it is valid. -1 is used to specify
// no default.
if (defaultChoice >= 0)
{
defaultChoiceKeys.Add(defaultChoice, true);
}
do
{
WriteChoicePrompt(hotkeysAndPlainLabels, defaultChoiceKeys, false);
ReadLineResult rlResult;
string response = ReadLine(false, "", out rlResult, true, true);
if (rlResult == ReadLineResult.endedOnBreak)
{
string msg = ConsoleHostUserInterfaceStrings.PromptCanceledError;
PromptingException e = new PromptingException(
msg, null, "PromptForChoiceCanceled", ErrorCategory.OperationStopped);
throw e;
}
if (response.Length == 0)
{
// they just hit enter.
if (defaultChoice >= 0)
{
// if there's a default, pick that one.
result = defaultChoice;
break;
}
continue;
}
// decide which choice they made.
if (response.Trim() == "?")
{
// show the help
ShowChoiceHelp(choices, hotkeysAndPlainLabels);
continue;
}
result = HostUIHelperMethods.DetermineChoicePicked(response.Trim(), choices, hotkeysAndPlainLabels);
if (result >= 0)
{
break;
}
// their input matched none of the choices, so prompt again
}
while (true);
return result;
}
}
/// <summary>
/// Presents a dialog allowing the user to choose options from a set of options.
/// </summary>
/// <param name="caption">
/// Caption to precede or title the prompt. E.g. "Parameters for get-foo (instance 1 of 2)"
/// </param>
/// <param name="message">
/// A message that describes what the choice is for.
/// </param>
/// <param name="choices">
/// An Collection of ChoiceDescription objects that describe each choice.
/// </param>
/// <param name="defaultChoices">
/// The index of the labels in the choices collection element to be presented to the user as
/// the default choice(s).
/// </param>
/// <returns>
/// The indices of the choice elements that corresponds to the options selected.
/// </returns>
/// <seealso cref="System.Management.Automation.Host.PSHostUserInterface.PromptForChoice"/>
public Collection<int> PromptForChoice(string caption,
string message,
Collection<ChoiceDescription> choices,
IEnumerable<int> defaultChoices)
{
HandleThrowOnReadAndPrompt();
if (choices == null)
{
throw PSTraceSource.NewArgumentNullException("choices");
}
if (choices.Count == 0)
{
throw PSTraceSource.NewArgumentException("choices",
ConsoleHostUserInterfaceStrings.EmptyChoicesErrorTemplate, "choices");
}
Dictionary<int, bool> defaultChoiceKeys = new Dictionary<int, bool>();
if (null != defaultChoices)
{
foreach (int defaultChoice in defaultChoices)
{
if ((defaultChoice < 0) || (defaultChoice >= choices.Count))
{
throw PSTraceSource.NewArgumentOutOfRangeException("defaultChoice", defaultChoice,
ConsoleHostUserInterfaceStrings.InvalidDefaultChoiceForMultipleSelection,
"defaultChoice",
"choices",
defaultChoice);
}
if (!defaultChoiceKeys.ContainsKey(defaultChoice))
{
defaultChoiceKeys.Add(defaultChoice, true);
}
}
}
Collection<int> result = new Collection<int>();
// we lock here so that multiple threads won't interleave the various reads and writes here.
lock (_instanceLock)
{
// write caption on the console, if present.
if (!string.IsNullOrEmpty(caption))
{
// Should be a skin lookup
WriteLineToConsole();
WriteToConsole(PromptColor, RawUI.BackgroundColor, WrapToCurrentWindowWidth(caption));
WriteLineToConsole();
}
// write message
if (!string.IsNullOrEmpty(message))
{
WriteLineToConsole(WrapToCurrentWindowWidth(message));
}
string[,] hotkeysAndPlainLabels = null;
HostUIHelperMethods.BuildHotkeysAndPlainLabels(choices, out hotkeysAndPlainLabels);
WriteChoicePrompt(hotkeysAndPlainLabels, defaultChoiceKeys, true);
if (defaultChoiceKeys.Count > 0)
{
WriteLineToConsole();
}
// used to display ChoiceMessage like Choice[0],Choice[1] etc
int choicesSelected = 0;
do
{
// write the current prompt
string choiceMsg = StringUtil.Format(ConsoleHostUserInterfaceStrings.ChoiceMessage, choicesSelected);
WriteToConsole(PromptColor, RawUI.BackgroundColor, WrapToCurrentWindowWidth(choiceMsg));
ReadLineResult rlResult;
string response = ReadLine(false, "", out rlResult, true, true);
if (rlResult == ReadLineResult.endedOnBreak)
{
string msg = ConsoleHostUserInterfaceStrings.PromptCanceledError;
PromptingException e = new PromptingException(
msg, null, "PromptForChoiceCanceled", ErrorCategory.OperationStopped);
throw e;
}
// they just hit enter
if (response.Length == 0)
{
// this may happen when
// 1. user wants to go with the defaults
// 2. user selected some choices and wanted those
// choices to be picked.
// user did not pick up any choices..choose the default
if ((result.Count == 0) && (defaultChoiceKeys.Keys.Count >= 0))
{
// if there's a default, pick that one.
foreach (int defaultChoice in defaultChoiceKeys.Keys)
{
result.Add(defaultChoice);
}
}
// allow for no choice selection.
break;
}
// decide which choice they made.
if (response.Trim() == "?")
{
// show the help
ShowChoiceHelp(choices, hotkeysAndPlainLabels);
continue;
}
int choicePicked = HostUIHelperMethods.DetermineChoicePicked(response.Trim(), choices, hotkeysAndPlainLabels);
if (choicePicked >= 0)
{
result.Add(choicePicked);
choicesSelected++;
}
// prompt for multiple choices
}
while (true);
return result;
}
}