In C#, I'm wondering what the best way is to have the equivalent of a sort
of "dynamic" enumeration... here's the deal --
Assume there's a data table of Widgets where each widget has an ID, a name,
and a type. The table will contain a few widgets initially, but could grow
to 20-30 or so. Each widget is of a certain WidgetType as well. For now,
suppose it looks like this:
ID Name Type
1 Foo 1
2 Bar 2
3 Rat 1
4 Fink 3
The WidgetType table might look like this:
ID Name
1 Square
2 Circle
3 Triangle
Throughout the application, these widgets and widget types will be referred
to using the ID value. While it should be rare, it's not unreasonable to
think that those ID values and/or names could change. Similarly, the
introduction of new widgets will be rare and will nearly always be
accompanied by an updated build. Assume that there will also be a "widget
manager" that governs the set of widgets and provides widget-related
services.
The ideal approach from a development perspective would be an enum so that
the developer could simply type "Widgets." and get the intellisense list of
available widgets. Similarly, they type "WidgetTypes." and get the set of
available types. Because the values and/or set of widgets could change, that
would seem to be out.
I could create a public hashtable member on the widget manager, and then
populate it at runtime, so that the developer now uses something like:
WidgetMgr.Widgets["Foo"]
WidgetMgr.WidgetTypes["Square"]
.... but that means they have to know the corresponding Name values to get at
the ID.
While I can think of a few "workable" methods, what's a "best practice" way
to manage this collection of widgets, and provide users of the class library
with a relatively easy way to get at individual widgets in the set? Are
indexers a possible solution to this?
Thanks,
J
