Reusing Delegate objects

[Tedb]

Is there any reason why you can't reuse a delegate object instance versus
creating a new one each time? For example in the following scenario I have
a DataPoints object with an array of DataPoint objects, each of these has a
Changed event. My Client objects subscribe to some or all of the DataPoint
Changed events. Client1 creates a new delegate instance for each DataPoint
event subscribed to, while Client2 creates one delegate instance and shares
it for all DataPoint events. Here is an example (air code):
class DataPoints
{

class DataPoint
{
public delegate void DataPointChange dEvent(DataPoin t aPoint);
public event DataPointChange dEvent Changed;
}

DataPoint[64] datapoint;

}

//This client creates a new delegate instance for each datapoint
class Client1
{

public void InitClient(Data Points dp)
{

for (int x=0; x< dp.datapoint.Le ngth;x++)
{
dp.datapoint[x].Changed += new
DataPoint.DataP ointChangedEven t(DataPoint_Cha nged);
}
}

void DataPoint_Chang ed(DataPoint aPoint)
{

}

}

//This client shares one delegate instance for all datapoint events
class Client2
{

public void InitClient(Data Points dp)
{

DataPoint.DataP ointChangedEven t DPChangedDelega te;

DPChangedDelega te = new
DataPoint.DataP ointChangedEven t(DataPoint_Cha nged);

for (int x=0; x< dp.datapoint.Le ngth;x++)
{
dp.datapoint[x].Changed += DPChangedDelega te;
}
}

void DataPoint_Chang ed(DataPoint aPoint)
{

}

}


Thanks for input.

Ted

[Wessel Troost]

> Is there any reason why you can't reuse a delegate object instance versus

creating a new one each time?

A delegate contains a reference to an object and a reference to a
function. If neither changes, you can reuse the same delegate.

Your object is DataPoint, and the function is DataPoint_Chang ed. So I
think in your case it's safe te reuse the same delegate.

Confusingly, your "DataPoint" class contains an array of 64 "datapoint" s.
Now if you were to create a delegate to call a "datapoint" member
function, the object would differ for each delegate. In which case you'd
have to create a new delegate each time.

Greetings,
Wessel

[Wessel Troost]

> Is there any reason why you can't reuse a delegate object instance versus

creating a new one each time?

A delegate contains a reference to an object and a reference to a
function. If neither changes, you can reuse the same delegate.

Your object is DataPoint, and the function is DataPoint_Chang ed. So I
think in your case it's safe te reuse the same delegate.

Confusingly, your "DataPoint" class contains an array of 64 "datapoint" s.
Now if you were to create a delegate to call a "datapoint" member
function, the object would differ for each delegate. In which case you'd
have to create a new delegate each time.

Greetings,
Wessel

[Tedb]

Thanks for the reply, if I understand you correctly it is proper to create
one delegate instance that points to a function of my client instance and
use it to subscribe to multiple datapoint changed events (saving a little
bit of overhead of creating multiple instances of delegate). What I am
trying to accomplish is that when any of the 64 datapoint instances fires
it's changed event, my client instance receives notification of this.
"Wessel Troost" <no*****@like.t he.sun> wrote in message
news:op.sudke8k pf3yrl7@asbel.. .

Is there any reason why you can't reuse a delegate object instance versus
creating a new one each time?

A delegate contains a reference to an object and a reference to a
function. If neither changes, you can reuse the same delegate.

Your object is DataPoint, and the function is DataPoint_Chang ed. So I
think in your case it's safe te reuse the same delegate.

Confusingly, your "DataPoint" class contains an array of 64 "datapoint" s.
Now if you were to create a delegate to call a "datapoint" member
function, the object would differ for each delegate. In which case you'd
have to create a new delegate each time.

Greetings,
Wessel

[Wessel Troost]

> What I am

trying to accomplish is that when any of the 64 datapoint instances fires
it's changed event, my client instance receives notification of this.

That will work using the single delegate.

If efficiency is really an issue, you might want to work around having
arrays of objects fire events. You could define the change function in
the DataPoints object, like:

class DataPoints
{
public ChangeDataPoint ( int iDatapointNumbe r, int iNewValue );
}

When the ChangeDataPoint function is called, the DataPoints class knows a
change is about to happen. In that way you are avoiding the overhead of
64+ events.

Greetings,
Wessel