Variable name from string

[Jan Roelof de Pijper]

Hi group,

Is it possible to derive a variable name from a string? So, if I have
a string "myVar" I want to define a variable myVar.

Any suggestions welcome!
Jan Roelof

 

[Jon Skeet [C# MVP]]

Is it possible to derive a variable name from a string? So, if I have
a string "myVar" I want to define a variable myVar.

Variables are declared at compile time, not run time. Now, what do you
actually want to achieve? Usually when people ask this question, they
really just want a map from string to some kind of object - in which
case, Hashtable or StringDictionary would probably be the right thing
to look at.

 

[Jan Roelof de Pijper]

Variables are declared at compile time, not run time. Now, what do you
actually want to achieve? Usually when people ask this question, they
really just want a map from string to some kind of object - in which
case, Hashtable or StringDictionary would probably be the right thing
to look at.

Thanks for your response! Actually, it's not really variable names I
want. I want to define an enumerated type whose members will be used
to identify events. The number of events and their names are not known
beforehand, but will be read from a configuration file - a simple text
file.

So, the textfile could look like this:

SystemStart
SystemStop
StartSynthesis
etc etc

and then my enum would be

enum MyEvents{ SystemStart, SystemStop, StartSynthesis };

Does this make sense? I must admit I have no experience whatsoever
with Hashtables and dictionaries, but maybe it's time got some

Thanks,
Jan Roelof

 

[Martin]

public enum test {

test1 = 1,

test2 =2

};

Console.WriteLine(test.test1.ToString());

gives test1

ML



TODO: Add constructor logic here

 

[Jon Skeet [C# MVP]]

Thanks for your response! Actually, it's not really variable names I
want. I want to define an enumerated type whose members will be used
to identify events. The number of events and their names are not known
beforehand, but will be read from a configuration file - a simple text
file.

So, the textfile could look like this:

SystemStart
SystemStop
StartSynthesis
etc etc

and then my enum would be

enum MyEvents{ SystemStart, SystemStop, StartSynthesis };

Does this make sense? I must admit I have no experience whatsoever
with Hashtables and dictionaries, but maybe it's time got some

Well, you could use the CodeDom or whatever to create such a type on
the fly - but what would be the benefit? What are you actually going to
do with this type afterwards? Why does it have to be an actual type,
rather than just being a set or map?

 

[Jan Roelof de Pijper]

Well, you could use the CodeDom or whatever to create such a type on
the fly - but what would be the benefit? What are you actually going to
do with this type afterwards? Why does it have to be an actual type,
rather than just being a set or map?

OK, here's what I am trying to do. I am writing a dialogue system. In
its present form it will allow a user to get information on train
departure and arrival times in a kiosk-like setting, using both speech
and a touch screen for input and output. There is one controlling
module, which starts up all the other modules (class libraries) that
make up the system. The controlling module reads a configuration file
to determine what classes to instantiate and in what modules they can
be found and then uses Assembly.LoadFrom, Assembly.GetTypes and
Activator.CreateInstance to do so. All communication between the
modules is done through events. These events and methods to raise them
are defined in a single central module that all other modules must
reference.

This all works pretty well and it's very easy to add new modules,
replace existing ones, and so on. Now I want to make this
infrastructure more general by also putting the events - which
basically define the functionality of the system - in a configuration
file. It would then be a snap to add new events, or use a completely
different set of events, without having to recompile anything.

So, I am thinking of having just one event, something like:

public delegate void EventHandlerKiosk( Object sender, EKioskEvents
kioskEvent, object obj );
public static event EventHandlerKiosk eventKiosk ;

The event would be raised by calling this method:

public static void RaiseEventKiosk( object sender, EKioskEvents
kioskEvent, object objKiosk ){
if( eventKiosk != null )
eventKiosk( sender, kioskEvent, objKiosk );
}

The second parameter in the EventHandler would be an enumerator
indicating the type of event. The third parameter would pass data.

I hope this explains what I am trying to do.
I am grateful for any ideas you might have!

Thanks,
Jan Roelof

 

[Jon Skeet [C# MVP]]

I hope this explains what I am trying to do.

Sort of - but I'm not sure how you're going to respond to different
event types if you don't know them at compile time. If you're going to
create a new type at runtime, how are you actually going to *use* it in
your code? If you don't have EKioskEvents defined until runtime, you
can't use it in your code directly, can you?

 

[Jan Roelof de Pijper]

Sort of - but I'm not sure how you're going to respond to different
event types if you don't know them at compile time. If you're going to
create a new type at runtime, how are you actually going to *use* it in
your code? If you don't have EKioskEvents defined until runtime, you
can't use it in your code directly, can you?

Absolutely right. The idea is to make it easy for someone to use the
infrastructure to set up a new dialogue system for a different domain,
say a pizza ordering service. They would

1. decide on the set of events necessary to accomplish the task,
2. add these events in the configuration file,
3. write modules (class libraries) that implement the functionality
and use the events to trigger actions and pass data,
4. Add the module and class names to the configuration file.

Now if there is a module that allows a user to type in a pizza name
and another module that collects all pizza data, the first module
could simply use

RaiseEventKiosk(
this, KioskEvents.NewPizzaName, (object)strPizzaName );

to send the pizza name to the second module. The receiving module
would have something like

CKioskEvents.eventKiosk += new EventHandlerKiosk( OnKioskEvent );

private void OnKioskEvent(
object sender, EKioskEvents kioskEvent, object objKiosk )
{
switch( kioskEvent )
{
case EKioskEvents.NewPizzaName :
m_strPizzaName = (string)objKiosk ;
...........
break ;
case EKioskEvents.NewAddress :
m_strAddress = (string)objKiosk ;
...........
default :
break ;
}
}

The central Kiosk control module takes care of starting up these two
modules (and any other ones), and the common events module sees to it
that all events are known to all modules and that they can raise them
and respond to them. The emphasis on the use of events here is that
there is no need to know beforehand how many modules there will be, or
their names. This would be necessary if use were made of public
properties and/or methods. If a new module is added later, it only
needs to know about the events available and it can become a full
participant immediately.

Does this make it clearer what I'm trying to do?
And thanks for thinking with me

Jan Roelof

 

[Jon Skeet [C# MVP]]

Absolutely right. The idea is to make it easy for someone to use the
infrastructure to set up a new dialogue system for a different domain,
say a pizza ordering service. They would

1. decide on the set of events necessary to accomplish the task,
2. add these events in the configuration file,
3. write modules (class libraries) that implement the functionality
and use the events to trigger actions and pass data,
4. Add the module and class names to the configuration file.

But they'd have to also run a tool to generate the code for the enums,
or they wouldn't be able to compile their code, surely?

I think I'm still missing when you want the new enum to become
available for use.

 

[jr_de_pijper]

But they'd have to also run a tool to generate the code for the enums,
or they wouldn't be able to compile their code, surely?

I think I'm still missing when you want the new enum to become
available for use.

I finally recognize your point, and you are absolutely right, of
course.Sometimes, I need to be hit over the head more than once before
comprehension dawns. What I want cannot be done through this enum.
Instead, I suppose I could use the strings themselves, rather than
using them to derive enum constants from:

RaiseEventKiosk(
this, "NewPizzaName", (object)strPizzaName );

CKioskEvents.eventKiosk += new EventHandlerKiosk( OnKioskEvent );

private void OnKioskEvent(
object sender, string strKioskEvent, object objKiosk )
{
switch( strKioskEvent )
{
case "NewPizzaName" :
m_strPizzaName = (string)objKiosk ;
...........
break ;
case "NewAddress" :
m_strAddress = (string)objKiosk ;
...........
default :
break ;
}
}

I would lose Intellisense support and automatic documentation through
NDoc, though ..

Thanks,
Jan Roelof

 

[Jon Skeet [C# MVP]]

I finally recognize your point, and you are absolutely right, of
course.Sometimes, I need to be hit over the head more than once before
comprehension dawns.

I'm glad we're finally on the same page - although it was equally
likely I wasn't seeing *your* point!

What I want cannot be done through this enum.
Instead, I suppose I could use the strings themselves, rather than
using them to derive enum constants from:

RaiseEventKiosk(
this, "NewPizzaName", (object)strPizzaName );

You don't need to cast strPizzaName to object here, unless you've also
got a method with a signature

private void OnKioskEvent(
object sender, string strKioskEvent, string objKiosk )

and you wish to make sure you get the right override.

I would lose Intellisense support and automatic documentation through
NDoc, though ..

But if you don't have the names until runtime, you couldn't get
Intellisense support and NDoc documentation anyway.

You might want to consider writing a tool which takes the configuration
file and *generates* an enum declaration that people could then use
(and annotate, eg with documentation) in their projects.

 

[Jan Roelof de Pijper]

You might want to consider writing a tool which takes the configuration
file and *generates* an enum declaration that people could then use
(and annotate, eg with documentation) in their projects.

I am going to think about this one. Thanks very much for all your
efforts (and indeed your contributions all over the newsgroup).

Jan Roelof