Iterating on Outlook COM objects - vsto

Question

I have a doubt about when iterating over Outlook COM objects and whether I need always to release them or not.
What is the difference between below two for loops?
(suppose recipients is of type Outlook.Recipients)
foreach (Outlook.Recipient recipient in recipients)
{
// Do things here
// Release Outlook COM object (Is it necessary to release it?)
Marshal.ReleaseComObject(recipient);
}
for (int i = 1; i <= recipients.Count; i++)
{
// Do things here
Outlook.Recipient recipient = recipients[i];
// Release Outlook COM object (Is it necessary to release it?)
Marshal.ReleaseComObject(recipient);
}
And is it necessary to release Outlook.Recipient object in both cases?
I have heard that it is recommended that you rather use a for loop since a for-each might cause some unexpected behavior and your code to hang.
Using a foreach loop to loop through the Recipients collection automatically generates the enumerator behind the foreach statement that uses an internal COM object, which needs to be released.

Answer 1

Unless you are running into a specific problem, don't call Marshal.ReleaseComObject().
The first loop checks (at compile time) that the object implements _NewEnum property with the dispid of -4. At run-time, .Net reads that property and casts it to the IEnumVariant interface that is used to loop through the collection items. .Net run-time version of the enumerator tends to keep all accessed items referenced, so Marshal.ReleaseComObject won't have any effect until the loop exits and the enumerator is released.
The second one is just a good old for loop. Marshal.ReleaseComObject would work as expected.

Answer 2

There are two main ways for releasing underlying COM objects in .net based applications:
The first one is based on the garbage collector which swipes the heap and could also automatically release hanging objects. But to properly release COM objects you would need to call the GC twice:
GC.Collect
GC.WaitForPendingFinalizers
GC.Collect
GC.WaitForPendingFinalizers
Use the Marshal.ReleaseComObject method in the code to release underlying COM objects instantly in the code. I prefer using this way because it allows releasing objects where they were created and don't wait until GC finishes its work which is un-deterministically.
In that case the foreach loop is not recommended because it doesn't allow releasing COM objects that way. I always use an old approach with the for loop:
for (int i = 1; i <= recipients.Count; i++)
{
// Do things here
Outlook.Recipient recipient = recipients[i];
// Release Outlook COM object (Is it necessary to release it?)
Marshal.ReleaseComObject(recipient);
recipient = null;
}
Don't forget to set the source object to null.