I wrote a method that returns
List<KeyValuePair<CommandType, List<string>>>
CommandType
is of Type enum
public enum CommandType
{
Programmed,
Manual
}
My issue is that the value in the KeyValuePair
sometimes is an enum
, and sometimes it is a list of strings, but I need to keep all the KeyValuePair
in one list.
currently, I pass the value as an object in the keyvaluepair and when the method returns the list and an iterate through it, based on the key, I cast the value back to its original type.
Is there a better way to implement this?
here is a sample code
public enum ProgrammedCommands
{
Sntp,
Snmp,
}
private List<KeyValuePair<CommandType, object>> GetCommandsFromTemplate(string[] templateLines)
{
var list = new List<KeyValuePair<CommandType, object>>();
if (templateLines != null)
for (int lineIndex = 0; lineIndex < templateLines.Length; lineIndex++)
{
if (templateLines[lineIndex].Contains("!*") && templateLines[lineIndex].Contains("*!"))
{
KeyValuePair<CommandType, object> ProgrammedSetting;
List<string> programmedCommandList;
if (templateLines[lineIndex].Contains("SNTP - SNTP Server Commands"))
{
ProgrammedSetting = new KeyValuePair<CommandType, object>(CommandType.Programmed, ProgrammedCommands.Sntp);
list.Add(ProgrammedSetting);
}
else if (templateLines[lineIndex].Contains("MANUAL"))
{
lineIndex++;
List<string> manual = new List<string>();
while (true)
{
if (lineIndex >= templateLines.Length)
break;
if (templateLines[lineIndex].Contains("!!["))
lineIndex++;
else if (templateLines[lineIndex].Contains("]!!"))
break;
else
{
manual.Add(templateLines[lineIndex]);
lineIndex++;
}
}
ProgrammedSetting = new KeyValuePair<CommandType, object>(CommandType.Manual, manual);
list.Add(ProgrammedSetting);
}
}
}
return list;
}
If you want to use a single storage for different types, since the type of values can be determined only at run-time, then you should use object
type for boxing values and then when you need to work with a value in a typed manner, check for its type and unbox it to desired type and use it.
So you can use one of these data structures based on your requirements:
Dictionary<CommandType, object>
← The key should be unique. List<KeyValuePair<CommandType, object>>
← There key of pair doesn't need to be unique. Note: You probably can imagine solutions like creating a common base class BaseType
and derive two different ListContainer
and EnumContainer
from the BaseType
and creating ListContainer
and EnumContainer
at runtime and store in a Dictionary<CommandType, BaseType>
. Such structures probably just can help you to limit the storage to desired type rather than using object.
The technical post webpages of this site follow the CC BY-SA 4.0 protocol. If you need to reprint, please indicate the site URL or the original address.Any question please contact:yoyou2525@163.com.