Indirect method calls ... how to?

G

Gaetan

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
 
C

C.C. \(aka Me\)

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!
 
P

Peter Rilling

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 said:
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
Click to expand...
 
K

Kevin Spencer

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.
 
P

Peter Rilling

Delegates are "function pointers" in .NET.

C.C. (aka Me) said:
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 said:
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
Click to expand...
Click to expand...
 
C

chris martin

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.
Click to expand...

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()");
}
}
 
B

Bruce Wood

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?
 
G

Gaetan

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.
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Similar Threads

is it any point using the interface IDisposable like I do here 1
ArrayList pass to method 4
Sorting 19
Using ITypedList to fill DataGrid not working 4
Method 'System.Object DynamicInvoke(System.Object[])' has nosupported translation to SQL. 2
Problem with BinaryFormatter Deserialize method 10
implicitly handle operator == when class overrides Equals method 5
how to call base implementation of method from base 2

Top