Hi Ying-Shen

I will try and describe my implementation in as much detail as
possible if this will be of help.

On the managed side of things, I have declared an interface which will
be the source of events. I am using the InterfaceType attribute to
mark the interface as a dispatch interface, also the DispId attribute
is used on each method so that GetIDsOfNames is not called on the sink
for each event invocation.

[InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
public interface IClass1Events
{
    [DispId(1)]
    void TextChanged();
}

The class which uses this interface is what I was referring to in the
other posts as the managed event source. I have used the
ComSourceInterfaces attribute on this class to indicate that the
IClass1Events interface is the COM source interface. An instance of
this class is created when the application first starts up and remains
alive until the application closes.

public delegate void TextChangedEvent();

[ComSourceInterfaces("CSDemo.IClass1Events")]
public class Class1
{
    public event TextChangedEvent TextChanged;

    public string Text
    {
        ...
        set
        {
            ...
            TextChanged();
        }
    }
}

The unmanaged component is an ActiveX control which I have placed onto
a Windows Form, this generated a RCW that I am using to call methods
on the ActiveX control from within managed code. One of the methods of
the ActiveX control takes an IDispatch pointer to an automation object
and then starts sinking all events from this object. The RCW expects
an object to be passed rather than an IDpsiatch pointer and so I can
easily pass an instance of my class (Class1) instead.

Inside the ActiveX control, the connection to the event source is made
using AtlAdvise (which calls IConnectionPoint::Advise internally).

if(!SUCCEEDED(AtlAdvise(m_spSourceDispatch,
    (IUnknown*)this,m_SourceEventInterfaceGuid,&m_Cookie)))
{
    *This error never occurs.
}

m_spSourceDispatch = the IDispatch interface for Class1.
this = the event sink.
m_SourceEventInterfaceGuid = the GUID of IClass1Events (obtained
dynamically from type information).
m_Cookie = the connection cookie.

To disconnect from the event source, AtlUnadvise is used (which calls
IConnectionPoint::Undvise internally).

if(!SUCCEEDED(AtlUnadvise(
m_spSourceDispatch,m_SourceEventInterfaceGuid,m_Cookie)))
{
    *This error never occurs.
}

If I set a breakpoint on the disconnection line, I can see the
reference count of the sink remains exactly the same after AtlUnadvise
has been called as it was before, but for normal COM objects, the
reference count is decremented as part of the unadvise call. The
reference count of the sink does finally get decremented, but only
when the application exits (maybe because of garbage collection?).

I hope this is enough information, Ying-Shen, if you need anymore,
then I can post some additional code.

Many Thanks
David Shepherd.