Weakeventhandler: avoiding GC problem by strong reference of an event)

Using System;
Using System. Collections. Generic;
Using System. text;

namespace testweakreference
{< br> class weakeventhandler T : weakreference where T: eventargs
{< br> Public weakeventhandler (): base ( null ) {}

Public weakeventhandler (eventhandler T > handler ): base (handler) {}

PublicWeakeventhandler (eventhandler<T>Target,BoolTrackresurrection ):Base(Target, trackresurrection ){}

Public   New Eventhandler < T > Target
{
Get
{
Return (Eventhandler < T > ) Base . Target;
}
Set
{
Base . Target = Value;
}
}

Public   Static   Explicit   Operator Eventhandler < T > (Weakeventhandler < T > Weakeventhandler)
{
Return Weakeventhandler. target;
}
}

class eventhost
{< br> private weakeventhandler eventargs > _ event = New weakeventhandler eventargs > ();

Public EventEventhandler<Eventargs>Event
{
Add {_ event. Target+ =Value ;}
Remove {_ event. Target-=Value ;}
}

Public   Void Fireevent ()
{
If (_ Event. Target ! =   Null )
{
_ Event. Target ( This , eventargs. Empty);
}< BR >}

class eventclient
{< br> Public void sayhello ( Object OBJ, eventargs ARGs)
{< br> console. writeline ( " Hello ~ " );
}

~Eventclient ()
{
Console. writeline ("Client dies!");
}
}

Class Program
{
Static   Void Main ( String [] ARGs)
{
Eventhost host =   New Eventhost ();
Eventclient Client =   New Eventclient ();
Host. Event + = Client. sayhello;
Host. fireevent (); // Client will say "Hello ~ ";

Client =   Null ;
GC. Collect (); // Client dies here!

Host. fireevent (); // Oops, nothing happen
}
}
}