Unsubscribing from events (VSTO, C#)

  • Thread starter Thread starter pavel.gz
  • Start date Start date
P

pavel.gz

In my add-in I have a method that unsubcribes from delete event
handler(it was previously subscribed to) in the begining and subscribes
to it again at the end like:

public void SynchronizeTasks(...)
{
tasksItems.ItemRemove -= OnTasksDelete;

....
foreach (Outlook.TaskItem task in tasksItems)
{
task.Delete();
}
....

tasksItems.ItemRemove += new
Outlook.ItemsEvents_ItemRemoveEventHandler(OnTasksDelete);
}

However, for every task deleted in this method I catch an ItemRemove
event in OnTasksDelete. Is there any way to completely unsubscribe from
this event?

Thanks in advance.
 
See if it helps if your code unsubscribes like this:

tasksItems.ItemRemove -= new
Outlook.ItemsEvents_ItemRemoveEventHandler(OnTasksDelete);

If that doesn't help you might have to call the garbage collector and wait
for finality before you proceed with your deletion code.

You also should use a count down for loop or other type of loop where you
check for the count of items rather than a foreach loop. The count is
essentially being decremented within the loop as you delete items in a count
up for loop or foreach loop and that messes with things. Often you only get
every other item deleted.
 
Ken, thanks for your suggestion, but it didn't work. I've changed the
unsubscription code and I've implemented a call of GC.Collect(); right
after unsubscription and just before subscription. Besides, I've
changed iteration through the collection to iteration through the
EntryIDs (I have them saved in my add-in). But the handler keeps
catching an event on every item deleted. It appears I'll have to check
in handler that event wasn't caught right after my cleaning...

"""Ken Slovak - [MVP - Outlook] ÐÉÓÁÌ(Á):
"""
 
Did you just call the GC or did you do that and wait for finalization of
garbage collection? You might also have to release the COM object that has
the event handler before GC and instantiate a new object. I'd probably try
that as a belt and suspenders test to see if that works.

System.Runtime.InteropServices.Marshal.ReleaseComObject(tasksItems);
tasksItems = null;
GC.Collect();
GC.WaitForPendingFinalizers();

Then re-instantiate the tasksItems collection. See if that helps.
 
Ken, thanks a lot, that was it! After adding
System.Runtime.InteropServices.Marshal.ReleaseComObject(tasksItems);
tasksItems = null;
GC.Collect();
Click to expand...

after unsubscription, Handler finally began no to catch delete event.
There was a problem when I also add GC.WaitForPendingFinalizers(); -
after executing this string outlook just stops responding, but without
it everything works just great.

"""Ken Slovak - [MVP - Outlook] ÐÉÓÁÌ(Á):
"""
 
Good.

The problem with the GC is that's it's non-deterministic. So you can release
something but the garbage collector might not get around to actually
releasing the references and cleaning things up for a while. In computer
code that seems like forever. Forcing collection releases things and gets
rid of those pesky event handlers.
 
Back
Top