How to clone event handlers

[Hamed]

Hello

It seems that I should implement ICloneable to implement my own clone
object. the critical point for me is to make a control object based on
another control object that all of its event handlers are set like the old
one. Is there a way to do this job?

For example, is there a way to use EventInfo object to get all event
handlers of the old control in runtime and set my new cloned control events
to the event handlers of the old control?

Any suggestion is appreciated.

Regards
Hamed

Hello

I am developing a utility to be reused in other programs. It

I have an object of type Control (a TextBox, ComboBox, etc.) that other
programmers use it in applications. they may set some of properties or
assign event handlers. I need to be able to clone the manipulated control
at runtime.

I could use the Clone method of some objects (like Font, Style, String,
etc..) but the controls like Button, TextBox, ListBox doesn't have this
kind
of method.
How can I create a clone of an object instance for controls like TextBox,
ListBox, ListViews, CheckBox ??
Any help is appreciated,

[Hamed]

I found the following link in the net. But it seems it has left the solution
unfinished.

http://www.dotnet247.com/247referenc...58/293131.aspx

This message was discovered on microsoft.publi c.dotnet.langua ges.csharp.

the question is if we know that we want to find all subscribed methods of
Click event how could we do the job?

(Take a look to the following code)

public class MyTextBox : TextBox, ICloneable
{
public object Clone()
{
MyTextBox clone = new MyTextBox();
clone.Click += this.Click; //compiler error!
The event '....Click' can only appear on the left hand side of += or -=
}
}

"Hamed" <ha***@raymehr. comwrote in message
news:O7******** ******@TK2MSFTN GP04.phx.gbl...

Nicholas

The method that is creating the clone is a member of the class being
cloned. I want for example to assign the Click event of the control of my
own to the new cloned object. but when I tried your solution I got
compiler error. for example:

public class MyTextBox : TextBox, ICloneable
{
public object Clone()
{
MyTextBox clone = new MyTextBox();
clone.Click += this.Click; //compiler error!
The event '....Click' can only appear on the left hand side of += or -=
}
}

Would you kindly describe your suggestion more?

Best Regards
Hamed
"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c omwrote
in message news:Ox******** ******@TK2MSFTN GP04.phx.gbl...

>Hamed,

Ultimately, you can't do it reliably.

If the method that is creating the clone is a member of the class
being cloned, then you can simply do:

// Inside clone method.
MyClass clone = new MyClass();
clone.MyEven t += this.MyEvent;

This assumes that you are declaring an event using the event keyword,
and not using add/remove handlers. It works because the C# compiler
creates a backing field of the same name (MyEvent).

However, if you declare your event like this:

private EventHandler myEventHandler;

public event EventHandler MyEvent
{
add
{
myEventHandler += value;
}
remove
{
myEventHandler -= value;
}
}

Then the call to assign the event will fail, because the compiler will
not see the backing field that has the delegate in it, and revert to
that.

Even if you are making the call from outside the type, the same
problem exists, since there is nothing on the metadata that links the
event to the backing field. There is nothing in the metadata that says
that the backing field has to be connected to the event. It's like
asking for metadata on a property, and then asking what the backing field
is (or multiple backing fields, since properties can really return
anything they want, just like event handlers).

So, that being said, there really isn't a reliable way to do this.
The best you could do is have an interface (if you plan on doing this
across multiple types) which would return a mapping of events to
handlers, and then when you clone the object, you would get those
delegates and then perform the clone.

Hope this helps.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

[Nicholas Paldino [.NET/C# MVP]]

Hamed,

You can't copy the events reliably. If you look at the definition of
the Click event in the TextBoxBase class, you will see the reason it fails
when you try and assign the event to the new clone (it defines custom event
handlers).
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"Hamed" <ha***@raymehr. comwrote in message
news:O7******** ******@TK2MSFTN GP04.phx.gbl...

Nicholas

The method that is creating the clone is a member of the class being
cloned. I want for example to assign the Click event of the control of my
own to the new cloned object. but when I tried your solution I got
compiler error. for example:

public class MyTextBox : TextBox, ICloneable
{
public object Clone()
{
MyTextBox clone = new MyTextBox();
clone.Click += this.Click; //compiler error!
The event '....Click' can only appear on the left hand side of += or -=
}
}

Would you kindly describe your suggestion more?

Best Regards
Hamed
"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c omwrote
in message news:Ox******** ******@TK2MSFTN GP04.phx.gbl...

>Hamed,

Ultimately, you can't do it reliably.

If the method that is creating the clone is a member of the class
being cloned, then you can simply do:

// Inside clone method.
MyClass clone = new MyClass();
clone.MyEven t += this.MyEvent;

This assumes that you are declaring an event using the event keyword,
and not using add/remove handlers. It works because the C# compiler
creates a backing field of the same name (MyEvent).

However, if you declare your event like this:

private EventHandler myEventHandler;

public event EventHandler MyEvent
{
add
{
myEventHandler += value;
}
remove
{
myEventHandler -= value;
}
}

Then the call to assign the event will fail, because the compiler will
not see the backing field that has the delegate in it, and revert to
that.

Even if you are making the call from outside the type, the same
problem exists, since there is nothing on the metadata that links the
event to the backing field. There is nothing in the metadata that says
that the backing field has to be connected to the event. It's like
asking for metadata on a property, and then asking what the backing field
is (or multiple backing fields, since properties can really return
anything they want, just like event handlers).

So, that being said, there really isn't a reliable way to do this.
The best you could do is have an interface (if you plan on doing this
across multiple types) which would return a mapping of events to
handlers, and then when you clone the object, you would get those
delegates and then perform the clone.

Hope this helps.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m
"Hamed" <ha*******@yaho o.comwrote in message
news:uF******* *******@TK2MSFT NGP03.phx.gbl.. .

>>Hello

It seems that I should implement ICloneable to implement my own clone
object. the critical point for me is to make a control object based on
another control object that all of its event handlers are set like the
old one. Is there a way to do this job?

For example, is there a way to use EventInfo object to get all event
handlers of the old control in runtime and set my new cloned control
events to the event handlers of the old control?

Any suggestion is appreciated.

Regards
Hamed

Hello

I am developing a utility to be reused in other programs. It

I have an object of type Control (a TextBox, ComboBox, etc.) that other
programmer s use it in applications. they may set some of properties or
assign event handlers. I need to be able to clone the manipulated
control at runtime.

I could use the Clone method of some objects (like Font, Style, String,
etc..) but the controls like Button, TextBox, ListBox doesn't have this
kind
of method.
How can I create a clone of an object instance for controls like
TextBox,
ListBox, ListViews, CheckBox ??
Any help is appreciated,

[Nicholas Paldino [.NET/C# MVP]]

Hamed,

Actually, this thread and that thread are pretty much exactly the same.
There is no reliable way to do this.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"Hamed" <ha***@raymehr. comwrote in message
news:uL******** ******@TK2MSFTN GP05.phx.gbl...

>I found the following link in the net. But it seems it has left the
solution unfinished.

http://www.dotnet247.com/247referenc...58/293131.aspx

This message was discovered on microsoft.publi c.dotnet.langua ges.csharp.

the question is if we know that we want to find all subscribed methods of
Click event how could we do the job?

(Take a look to the following code)

>public class MyTextBox : TextBox, ICloneable
{
public object Clone()
{
MyTextBox clone = new MyTextBox();
clone.Click += this.Click; //compiler
error! The event '....Click' can only appear on the left hand side of +=
or -=
}
}

"Hamed" <ha***@raymehr. comwrote in message
news:O7******** ******@TK2MSFTN GP04.phx.gbl...

>Nicholas

The method that is creating the clone is a member of the class being
cloned. I want for example to assign the Click event of the control of my
own to the new cloned object. but when I tried your solution I got
compiler error. for example:

public class MyTextBox : TextBox, ICloneable
{
public object Clone()
{
MyTextBox clone = new MyTextBox();
clone.Click += this.Click; //compiler
error! The event '....Click' can only appear on the left hand side of +=
or -=
}
}

Would you kindly describe your suggestion more?

Best Regards
Hamed
"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c omwrote
in message news:Ox******** ******@TK2MSFTN GP04.phx.gbl...

>>Hamed,

Ultimately, you can't do it reliably.

If the method that is creating the clone is a member of the class
being cloned, then you can simply do:

// Inside clone method.
MyClass clone = new MyClass();
clone.MyEve nt += this.MyEvent;

This assumes that you are declaring an event using the event keyword,
and not using add/remove handlers. It works because the C# compiler
creates a backing field of the same name (MyEvent).

However, if you declare your event like this:

private EventHandler myEventHandler;

public event EventHandler MyEvent
{
add
{
myEventHandler += value;
}
remove
{
myEventHandler -= value;
}
}

Then the call to assign the event will fail, because the compiler
will not see the backing field that has the delegate in it, and revert
to that.

Even if you are making the call from outside the type, the same
problem exists, since there is nothing on the metadata that links the
event to the backing field. There is nothing in the metadata that says
that the backing field has to be connected to the event. It's like
asking for metadata on a property, and then asking what the backing
field is (or multiple backing fields, since properties can really return
anything they want, just like event handlers).

So, that being said, there really isn't a reliable way to do this.
The best you could do is have an interface (if you plan on doing this
across multiple types) which would return a mapping of events to
handlers, and then when you clone the object, you would get those
delegates and then perform the clone.

Hope this helps.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

[Hamed]

Nicholas,

I appreciate your comments. thanks to pay attention. but:

When you say there is no reliable way, does this mean there may be some
unreliable ways?

Hamed
"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c omwrote in
message news:ez******** *****@TK2MSFTNG P05.phx.gbl...

Hamed,

Actually, this thread and that thread are pretty much exactly the same.
There is no reliable way to do this.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"Hamed" <ha***@raymehr. comwrote in message
news:uL******** ******@TK2MSFTN GP05.phx.gbl...

>>I found the following link in the net. But it seems it has left the
solution unfinished.

http://www.dotnet247.com/247referenc...58/293131.aspx

This message was discovered on microsoft.publi c.dotnet.langua ges.csharp.

the question is if we know that we want to find all subscribed methods of
Click event how could we do the job?

(Take a look to the following code)

>>public class MyTextBox : TextBox, ICloneable
{
public object Clone()
{
MyTextBox clone = new MyTextBox();
clone.Click += this.Click; //compiler
error! The event '....Click' can only appear on the left hand side of +=
or -=
}
}

"Hamed" <ha***@raymehr. comwrote in message
news:O7******* *******@TK2MSFT NGP04.phx.gbl.. .

>>Nicholas

The method that is creating the clone is a member of the class being
cloned. I want for example to assign the Click event of the control of
my own to the new cloned object. but when I tried your solution I got
compiler error. for example:

public class MyTextBox : TextBox, ICloneable
{
public object Clone()
{
MyTextBox clone = new MyTextBox();
clone.Click += this.Click; //compiler
error! The event '....Click' can only appear on the left hand side of +=
or -=
}
}

Would you kindly describe your suggestion more?

Best Regards
Hamed
"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c omwrote
in message news:Ox******** ******@TK2MSFTN GP04.phx.gbl...
Hamed,

Ultimately, you can't do it reliably.

If the method that is creating the clone is a member of the class
being cloned, then you can simply do:

// Inside clone method.
MyClass clone = new MyClass();
clone.MyEven t += this.MyEvent;

This assumes that you are declaring an event using the event
keyword, and not using add/remove handlers. It works because the C#
compiler creates a backing field of the same name (MyEvent).

However, if you declare your event like this:

private EventHandler myEventHandler;

public event EventHandler MyEvent
{
add
{
myEventHandler += value;
}
remove
{
myEventHandler -= value;
}
}

Then the call to assign the event will fail, because the compiler
will not see the backing field that has the delegate in it, and revert
to that.

Even if you are making the call from outside the type, the same
problem exists, since there is nothing on the metadata that links the
event to the backing field. There is nothing in the metadata that says
that the backing field has to be connected to the event. It's like
asking for metadata on a property, and then asking what the backing
field is (or multiple backing fields, since properties can really
return anything they want, just like event handlers).

So, that being said, there really isn't a reliable way to do this.
The best you could do is have an interface (if you plan on doing this
across multiple types) which would return a mapping of events to
handlers, and then when you clone the object, you would get those
delegates and then perform the clone.

Hope this helps.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

[Hamed]

Thanks for your kind attention.

Of course, I found some solutions using Reflection. It works perfectly but
the solution is messy

Thanks a lot and Regards.

-----Original Message-----

From: Nicholas Paldino [.NET/C# MVP] [mailto:ca****** *@caspershouse. com]

Sent: Sunday, August 13, 2006 5:19 PM

To: ha***@raymehr.c om

Subject: Re: How to clone event handlers

Hamed,

Actually, this thread and that thread are pretty much exactly the same.

There is no reliable way to do this.

--

- Nicholas Paldino [.NET/C# MVP]

- mv*@spam.guard. caspershouse.co m

"Hamed" <ha***@raymehr. comwrote in message
news:uL******** ******@TK2MSFTN GP05.phx.gbl...

>I found the following link in the net. But it seems it has left the

>solution unfinished.

>

http://www.dotnet247.com/247referenc...58/293131.aspx

>

This message was discovered on

microsoft.publi c.dotnet.langua ges.csharp.

>

the question is if we know that we want to find all subscribed methods

of

Click event how could we do the job?

>

(Take a look to the following code)

>public class MyTextBox : TextBox, ICloneable {

>public object Clone()

>{

>MyTextBox clone = new MyTextBox();

>clone.Click += this.Click; //compiler

>error! The event '....Click' can only appear on the left hand side of

+=

>or -=

>}

>}

>>

>

>

"Hamed" <ha***@raymehr. comwrote in message

news:O7******** ******@TK2MSFTN GP04.phx.gbl...

>Nicholas

>>

>The method that is creating the clone is a member of the class being

>cloned. I want for example to assign the Click event of the control

of my

>own to the new cloned object. but when I tried your solution I got

>compiler error. for example:

>>

>public class MyTextBox : TextBox, ICloneable {

>public object Clone()

>{

>MyTextBox clone = new MyTextBox();

>clone.Click += this.Click; //compiler

>error! The event '....Click' can only appear on the left hand side of

+=

>or -=

>}

>}

>>

>Would you kindly describe your suggestion more?

>>

>Best Regards

>Hamed

>>

>>

>"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c om>

wrote

>in message news:Ox******** ******@TK2MSFTN GP04.phx.gbl...

>>Hamed,

>>>

>>Ultimately, you can't do it reliably.

>>>

>>If the method that is creating the clone is a member of the class

>>being cloned, then you can simply do:

>>>

>>// Inside clone method.

>>MyClass clone = new MyClass();

>>clone.MyEve nt += this.MyEvent;

>>>

>>This assumes that you are declaring an event using the event

keyword,

>>and not using add/remove handlers. It works because the C# compiler

>>creates a backing field of the same name (MyEvent).

>>>

>>However, if you declare your event like this:

>>>

>>private EventHandler myEventHandler;

>>>

>>public event EventHandler MyEvent

>>{

>>add

>>{

>>myEventHandle r += value;

>>}

>>remove

>>{

>>myEventHandle r -= value;

>>}

>>}

>>>

>>Then the call to assign the event will fail, because the compiler

>>will not see the backing field that has the delegate in it, and

revert

>>to that.

>>>

>>Even if you are making the call from outside the type, the same

>>problem exists, since there is nothing on the metadata that links

the

>>event to the backing field. There is nothing in the metadata that

says

>>that the backing field has to be connected to the event. It's like

>>asking for metadata on a property, and then asking what the backing

>>field is (or multiple backing fields, since properties can really

return

>>anything they want, just like event handlers).

>>>

>>So, that being said, there really isn't a reliable way to do

this.

>>The best you could do is have an interface (if you plan on doing

this

>>across multiple types) which would return a mapping of events to

>>handlers, and then when you clone the object, you would get those

>>delegates and then perform the clone.

>>>

>>Hope this helps.

>>>

>>>

>>--

>>- Nicholas Paldino [.NET/C# MVP]

>>- mv*@spam.guard. caspershouse.co m

>>>

>

>