471,330 Members | 1,782 Online
Bytes | Software Development & Data Engineering Community
Post +

Home Posts Topics Members FAQ

Join Bytes to post your question to a community of 471,330 software developers and data experts.

Indirect method calls ... how to?

Is is possible in C# to have the equivalent of an array of function pointers in C?

I have a situation where a top level class exposes methods like Add, Delete, ... and a few
child classes with the same methods. Depending on a configuration parameter, the child
method will be invoked when the top level class is invoked.

I would like to avoid having to do something like this:

int configuration;

public bool Add()
{
switch (configuration)
{
case 1:
return ChildClass1.Add();
case 2:
return ChildClass2.Add();
}
}

I would rather have something like this instead (code not complete)

Arraylist MethodPTR;
int configuration;

public mainClassConstructor()
{
// Initialize MethodPTR with the address of the methods

MethodPTR = new ArrayList(8);
configuration = RetrieveConfiguration();

switch (configuration)
{
case 1:
MethodPTR[0] = ChildClass1.Add; // Assistance required here
MethodPTR[1] = ChildClass1.Delete; // Assistance required here
break;
case 2:
MethodPTR[0] = ChildClass2.Add; // Assistance required here
MethodPTR[1] = ChildClass2.Delete; // Assistance required here
break;
}
}

public bool Add()
{
return MedthoPTR[0](); // This is where I need assistance
}

public bool Delete()
{
return MedthoPTR[1](); // This is where I need assistance
}

Thank you all in advance.

Gaetan

Jan 30 '06 #1
8 3490
Not really any function pointers.

But....

Take a look at the Reflection classes.

You can get an object that represents a method (MethodInfo class) from a
class and then call the Invoke() method of it to actually execute it. You
could keep an array of MethodInfo objects and treat them sort of like
function pointers.

Also, you can Invoke() a method by using a string representation of the
method name as long as you have an instance of the object that contains it.

Hope this gives you some ideas!

--
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Charles Cox
VC/VB/C# Developer
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

"Gaetan" <so*****@somewhere.com> wrote in message
news:jo********************************@4ax.com...
Is is possible in C# to have the equivalent of an array of function
pointers in C?

I have a situation where a top level class exposes methods like Add,
Delete, ... and a few
child classes with the same methods. Depending on a configuration
parameter, the child
method will be invoked when the top level class is invoked.

I would like to avoid having to do something like this:

int configuration;

public bool Add()
{
switch (configuration)
{
case 1:
return ChildClass1.Add();
case 2:
return ChildClass2.Add();
}
}

I would rather have something like this instead (code not complete)

Arraylist MethodPTR;
int configuration;

public mainClassConstructor()
{
// Initialize MethodPTR with the address of the methods

MethodPTR = new ArrayList(8);
configuration = RetrieveConfiguration();

switch (configuration)
{
case 1:
MethodPTR[0] = ChildClass1.Add; // Assistance required here
MethodPTR[1] = ChildClass1.Delete; // Assistance required here
break;
case 2:
MethodPTR[0] = ChildClass2.Add; // Assistance required here
MethodPTR[1] = ChildClass2.Delete; // Assistance required here
break;
}
}

public bool Add()
{
return MedthoPTR[0](); // This is where I need assistance
}

public bool Delete()
{
return MedthoPTR[1](); // This is where I need assistance
}

Thank you all in advance.

Gaetan

Jan 30 '06 #2
Well, first some comments than an answer to your questions.

1) Not really sure if your desired way is any better than the way you are
rejecting. You are still using a switch statement, you are just moving it
to a new location.
2) People who work on this after you may not understand what you are doing.
You would need to document this really well.
3) Although not a big issue, your way would not be as performant because
you are storing pointers to the methods. There would also be the overhead
of calling the methods. (again this is not a big deal, just thought I would
mention it.)

Now, for your answer. The .NET equivalent of function pointers are
Delegates. When you create a delegate, you tell it what method it should
wrap. You can then store the delegate for later use.

On a side note, let me offer some design comments (knowing full well that I
do not have knowledge of what you are trying to accomplish).

When you say "child class", are you referring to inherited subclasses? If
that is the case, then you might want to make Add abstract and then the
correct derived class method will be called, or you can have the base class
have an Add method and the derived classes have an AddImpl method incase you
need the base class to do some additional work. I might be able to offer a
better design if you wanted to share the relationship between the various
classes (i.e. inheritance, composition, etc.).

"Gaetan" <so*****@somewhere.com> wrote in message
news:jo********************************@4ax.com...
Is is possible in C# to have the equivalent of an array of function
pointers in C?

I have a situation where a top level class exposes methods like Add,
Delete, ... and a few
child classes with the same methods. Depending on a configuration
parameter, the child
method will be invoked when the top level class is invoked.

I would like to avoid having to do something like this:

int configuration;

public bool Add()
{
switch (configuration)
{
case 1:
return ChildClass1.Add();
case 2:
return ChildClass2.Add();
}
}

I would rather have something like this instead (code not complete)

Arraylist MethodPTR;
int configuration;

public mainClassConstructor()
{
// Initialize MethodPTR with the address of the methods

MethodPTR = new ArrayList(8);
configuration = RetrieveConfiguration();

switch (configuration)
{
case 1:
MethodPTR[0] = ChildClass1.Add; // Assistance required here
MethodPTR[1] = ChildClass1.Delete; // Assistance required here
break;
case 2:
MethodPTR[0] = ChildClass2.Add; // Assistance required here
MethodPTR[1] = ChildClass2.Delete; // Assistance required here
break;
}
}

public bool Add()
{
return MedthoPTR[0](); // This is where I need assistance
}

public bool Delete()
{
return MedthoPTR[1](); // This is where I need assistance
}

Thank you all in advance.

Gaetan

Jan 30 '06 #3
Check out .Net delegates. This is the equivalent of managed function
pointers.

--
HTH,

Kevin Spencer
Microsoft MVP
..Net Developer
Who is Mighty Abbott?
A twin turret scalawag.

"Gaetan" <so*****@somewhere.com> wrote in message
news:jo********************************@4ax.com...
Is is possible in C# to have the equivalent of an array of function
pointers in C?

I have a situation where a top level class exposes methods like Add,
Delete, ... and a few
child classes with the same methods. Depending on a configuration
parameter, the child
method will be invoked when the top level class is invoked.

I would like to avoid having to do something like this:

int configuration;

public bool Add()
{
switch (configuration)
{
case 1:
return ChildClass1.Add();
case 2:
return ChildClass2.Add();
}
}

I would rather have something like this instead (code not complete)

Arraylist MethodPTR;
int configuration;

public mainClassConstructor()
{
// Initialize MethodPTR with the address of the methods

MethodPTR = new ArrayList(8);
configuration = RetrieveConfiguration();

switch (configuration)
{
case 1:
MethodPTR[0] = ChildClass1.Add; // Assistance required here
MethodPTR[1] = ChildClass1.Delete; // Assistance required here
break;
case 2:
MethodPTR[0] = ChildClass2.Add; // Assistance required here
MethodPTR[1] = ChildClass2.Delete; // Assistance required here
break;
}
}

public bool Add()
{
return MedthoPTR[0](); // This is where I need assistance
}

public bool Delete()
{
return MedthoPTR[1](); // This is where I need assistance
}

Thank you all in advance.

Gaetan

Jan 30 '06 #4
Delegates are "function pointers" in .NET.

"C.C. (aka Me)" <me@home.com> wrote in message
news:jZ********************@comcast.com...
Not really any function pointers.

But....

Take a look at the Reflection classes.

You can get an object that represents a method (MethodInfo class) from a
class and then call the Invoke() method of it to actually execute it. You
could keep an array of MethodInfo objects and treat them sort of like
function pointers.

Also, you can Invoke() a method by using a string representation of the
method name as long as you have an instance of the object that contains
it.

Hope this gives you some ideas!

--
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Charles Cox
VC/VB/C# Developer
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

"Gaetan" <so*****@somewhere.com> wrote in message
news:jo********************************@4ax.com...
Is is possible in C# to have the equivalent of an array of function
pointers in C?

I have a situation where a top level class exposes methods like Add,
Delete, ... and a few
child classes with the same methods. Depending on a configuration
parameter, the child
method will be invoked when the top level class is invoked.

I would like to avoid having to do something like this:

int configuration;

public bool Add()
{
switch (configuration)
{
case 1:
return ChildClass1.Add();
case 2:
return ChildClass2.Add();
}
}

I would rather have something like this instead (code not complete)

Arraylist MethodPTR;
int configuration;

public mainClassConstructor()
{
// Initialize MethodPTR with the address of the methods

MethodPTR = new ArrayList(8);
configuration = RetrieveConfiguration();

switch (configuration)
{
case 1:
MethodPTR[0] = ChildClass1.Add; // Assistance required here
MethodPTR[1] = ChildClass1.Delete; // Assistance required here
break;
case 2:
MethodPTR[0] = ChildClass2.Add; // Assistance required here
MethodPTR[1] = ChildClass2.Delete; // Assistance required here
break;
}
}

public bool Add()
{
return MedthoPTR[0](); // This is where I need assistance
}

public bool Delete()
{
return MedthoPTR[1](); // This is where I need assistance
}

Thank you all in advance.

Gaetan


Jan 30 '06 #5
> Is is possible in C# to have the equivalent of an array of function
pointers in C?

I have a situation where a top level class exposes methods like Add,
Delete, ... and a few child classes with the same methods. Depending
on a configuration parameter, the child method will be invoked when
the top level class is invoked.


I would use delegates for this. The following example is not very elegant
but, it shows the basic use of delegates and from what I read, it should
apply to your situation.

Chris

---

class Class1
{

[STAThread]
static void Main(string[] args)
{
Class1 class1 = new Class1(0);
Class1 class2 = new Class1(1);

class1.Add();
class1.Delete();

class2.Add();
class2.Delete();

Console.ReadLine();
}

public delegate void TakeCarOfStuffHandler();

TakeCarOfStuffHandler addHandler;
TakeCarOfStuffHandler deleteHandler;

public Class1(int i)
{
ChildClass1 class1 = new ChildClass1();
ChildClass2 class2 = new ChildClass2();

switch(i)
{
case 0:
addHandler = new TakeCarOfStuffHandler(class1.Add);
deleteHandler = new TakeCarOfStuffHandler(class1.Delete);
break;
case 1:
addHandler = new TakeCarOfStuffHandler(class2.Add);
deleteHandler = new TakeCarOfStuffHandler(class2.Delete);
break;
}
}

public void Add()
{
addHandler();
}

public void Delete()
{
deleteHandler();
}
}

class ChildClass1
{
public void Add()
{
Console.WriteLine("ChildClass1.Add()");
}

public void Delete()
{
Console.WriteLine("ChildClass1.Delete()");
}
}

class ChildClass2
{
public void Add()
{
Console.WriteLine("ChildClass2.Add()");
}

public void Delete()
{
Console.WriteLine("ChildClass2.Delete()");
}
}
Jan 30 '06 #6
I don't understand how your problem is different from standard
polymorphism:

public class Base
{
public virtual bool Add() { ... }
public virtual bool Delete() { ... }
}

public class Child : Base
{
public override bool Add() { ... }
public override bool Delete() { ... }
}

then

Base aBase = new Child();
aBase.Add();

I'm sure I'm missing something here... how do your requirements differ
from what's offered by polymorphism?

Jan 30 '06 #7

Thanks Peter for your explanations. I have taken a closer look at using either Delegates
or an abstract class. I think that what I'm trying to do could be more easily implemented
with a base class and derived classes.
On Mon, 30 Jan 2006 10:21:42 -0800, "Peter Rilling" <pe***@nospam.rilling.net> wrote:
Well, first some comments than an answer to your questions.

1) Not really sure if your desired way is any better than the way you are
rejecting. You are still using a switch statement, you are just moving it
to a new location.
2) People who work on this after you may not understand what you are doing.
You would need to document this really well.
3) Although not a big issue, your way would not be as performant because
you are storing pointers to the methods. There would also be the overhead
of calling the methods. (again this is not a big deal, just thought I would
mention it.)

Now, for your answer. The .NET equivalent of function pointers are
Delegates. When you create a delegate, you tell it what method it should
wrap. You can then store the delegate for later use.

On a side note, let me offer some design comments (knowing full well that I
do not have knowledge of what you are trying to accomplish).

When you say "child class", are you referring to inherited subclasses? If
that is the case, then you might want to make Add abstract and then the
correct derived class method will be called, or you can have the base class
have an Add method and the derived classes have an AddImpl method incase you
need the base class to do some additional work. I might be able to offer a
better design if you wanted to share the relationship between the various
classes (i.e. inheritance, composition, etc.).

Jan 30 '06 #8
Thanks Bruce ... this is the way I will go.

On 30 Jan 2006 10:37:17 -0800, "Bruce Wood" <br*******@canada.com> wrote:
I don't understand how your problem is different from standard
polymorphism:

public class Base
{
public virtual bool Add() { ... }
public virtual bool Delete() { ... }
}

public class Child : Base
{
public override bool Add() { ... }
public override bool Delete() { ... }
}

then

Base aBase = new Child();
aBase.Add();

I'm sure I'm missing something here... how do your requirements differ
from what's offered by polymorphism?

Jan 30 '06 #9

This discussion thread is closed

Replies have been disabled for this discussion.

Similar topics

2 posts views Thread by Matt Leslie | last post: by
reply views Thread by Sham Ramakrishnan | last post: by
4 posts views Thread by Lawrence Oluyede | last post: by
1 post views Thread by Gurur | last post: by
reply views Thread by rosydwin | last post: by

By using Bytes.com and it's services, you agree to our Privacy Policy and Terms of Use.

To disable or enable advertisements and analytics tracking please visit the manage ads & tracking page.