如何在C＃中销毁COM对象？

Question

What are the methods to destroy Excel COM Interop objects in C#, besides these:

object_instance = null;
System.GC.collect();
&
System.Runtime.InteropServices.Marshal.ReleaseComObject(object);

Please suggest only inbuilt techniques, not other tools like bigcannon, etc.

Answer 1

The kicker is that if you haven't dropped all references to the object, even GC.Collect won't destroy it.

The rule in C# (or .NET generally) is that you can't destory an object. Dispose() won't do it. A finalizer won't do it (rule number 2, don't use a finalizer unless you know why you need it, and don't ever call it directly).

For .NET, these are the things you need to do:

1. If an object holds references to unmanaged objects, implement IDispose pattern. And implement it fully; it's more than just providing a Dispose() method.
2. The only reason to have a finalizer is to release unmanaged objects, and only in the event that your object hasn't been properly disposed. Once your dispose method is called, it should do the cleanup, then "kill" the finalizer by calling GC.SuppressFinalize.
3. If you are using an object that implements a Dispose() method, call Dispose() when you're done with that object. Best practices is to allocate that object with a using block. Exit from the using block will call Dispose() automatically.
4. When you are done with an object, drop all references to the object, including event handlers, delegates, etc.
5. Beyond that, trust the garbage collector to do its job. Don't mess with the garbage collector; you're only likely to make things worse, unless you really, really, really know what you're doing and why.

Answer 2

The garbage collector is the only mechanism that can destroy a managed object , but you usually don't invoke it explicitly. You just let it do its thing.

Just like you never take your own trash to the depot, you just leave it sitting on the corner. It's always the garbage man's responsibility.

You can release references to things and clean them up with IDisposable, finalizers and destructors but not destroy them.

By using System.GC you can ask the garbage man to do things early - request a custom run just for yourself - but this usually screws up his schedule and he has a lot more trash to deal with than just yours so it's not recommended.

Answer 3

For the most part, you have to remove all references to an object. Only then will the garbage collector see it and destroy it.

Be aware of this:

object_instance = null;

All this does is kill the object_instance reference. This works if it's the only reference. If there are other references, then it won't be collected.

var skywalker = new Person();
var object_instance = skywalker;

...

object_instance = null;
//It's still alive and won't be collected because skywalker lives...

Answer 4

If your object allocates significant resources, it's best to implement IDisposable and explicitly call Dispose. If you can't call Dispose for some reason and your class reserves unmanaged memory, you can use GC.AddMemoryPressure (with a matching GC.RemoveMemoryPressure in the finalizer) to tell the GC your class is heavier than it looks, prioritizing it for earlier cleanup.

Answer 5

如果你真的需要明确释放一个对象所占用的内存，并且你确定你会选择比GC更好地消除它的那一刻，那么唯一合理的选择就是在堆栈上分配它并让它在你返回时死掉分配它的方法。

Answer 6

If you want control so that you can manage resources of the object, then implement the IDisposable interface.

http://msdn.microsoft.com/en-us/library/system.idisposable.aspx

If resources are not the reason why you want to explicitly control object destruction, I can't fathom why you want that level of control... Do you use object pooling?