How to manage COM objects runtime in RAII style in C# programs?

Question

My C# program uses a COM component that has a ton of various interfaces and subobjects. The problem is each time I retrieve some COM interface an RCW is created and that RCW exists for unknown time (until collected by GC). Each RCW holds some object in the COM server.

The COM component is an out-proc server, so its objects reside in a separate quite heavy-weight process that won't terminate until all objects residing in it are released. I want all object to be releases ASAP so that I know for sure that once I released the last object the out-proc server process terminates and no longer consumes system resources. That's not my paranoia - having several heavyweight processes consuming system resources, especially memory, is really bad for performance.

So far I crafted a generic class that implements IDisposable, accepts a reference to the object (RCW in fact) and calls Marshal.FinalReleaseComObject in Dispose implementation.

For the sake of this question let's temporarily ignore possible problems arising from using FinalReleaseComObject() - I'm aware of them and can tolerate them.

The real problem is I'm forced to either use using for all objects or to write finally clauses and call Dispose() there. It works, but code gets rather cluttered with lots of extra wiring and that bothers me big time.

For example, I need to assign a string to someObject.Params.ColorParams.Hint property - I can't just write

someObject.Params.ColorParams.Hint = whatever;

because for each accessor there will be a COM object that I need to get released, so I have this instead:

using( MyWrapper<IParams> params = new MyWrapper<IParams>( someObject.Params ) ) {
    using( MyWrapper<IColorParams> colorParams =
         new MyWrapper<IColorParams>( params.Controlled ) )
    {
        colorParams.Controlled.Hint = whatever;
    }
}

and that's the most trivial example - sometimes I need to access something five levels deep and then I write a set of using statements five level deep.

Is there a more elegant solution to the problem?

Have at look at the answer to this question http://stackoverflow.com/questions/2191489/releasing-temporary-com-objects. I haven't actually tried this myself, though I plan to, but it looks like an elegant solution. — Phil Devaney, Aug 08 '11 at 11:41
The using statement is as close to RAII you're going to get. Invoke the finalizers you want to run to release the RCWs with GC.Collect + GC.WaitForPendingFinalizers. If the EXE doesn't exit then hunt down any stored references. — Hans Passant, Aug 08 '11 at 12:33

score 1 · Answer 1 · edited May 23 '17 at 10:34

1

Please see this answer to Clean up Excel Interop Objects with IDisposable by Hans Passant.

In summary, you don't need IDisposable at all. Just explicitly invoke garbage collection after all of your COM references have gone out of scope – i.e. not from the function that uses them but from the caller of that function.

edited May 23 '17 at 10:34

Community

1
1

answered Oct 06 '16 at 08:55

Ian Goldby

5,609
1
45
81

Forcing GC just to get rid of COM objects? That has risk of negatively affecting performance, hasn't it? – sharptooth Oct 07 '16 at 06:58
@sharptooth My understanding is that in most cases the GC will take care of itself, but this is a rare case where intervention is justified. I would not be concerned about performance unless I were doing it repeatedly in a tight loop. Anyway, if Hans Passant says in this case that it's OK then it's OK. :-) – Ian Goldby Oct 07 '16 at 07:28

score 0 · Answer 2 · answered Aug 08 '11 at 11:37

I'm not sure I fully understand the problem, but if I do (code clutter) there are 2 possible solutions:

A wrapper method - You could define a simple method:

TResult Exec<TResult>(Func<TResult> func, params MarshalByRefObject comObjects)
{
  TResult res = default(TResult);
  try
  {
    res = func.Invoke();
  }
  catch (Exception e) { /* Log? */ }
  finally
  {
    foreach (MarshalByRefObject combObj in comObjects)
    {    /* release resources using common interface or reflection */ }
  }
}

Very much like the previous method, only using one of the many AOP frameworks to do it (e.g PostSharp)

I added an example - I don't have same level objects, I have chains of subobjects. — sharptooth, Aug 08 '11 at 12:04

score 0 · Answer 3 · answered Aug 08 '11 at 13:25

c# and deterministic release of resources is generally troublesome at best.
Release of out of process COM objects is one example of the problem.

If you are happy to write some C++/cli code it at least has the option of stack semantics for managed heap objects. This avoids the need for using or finally wrapping as the compiler calls dispose for you when the object drops out of scope.

Of course it does bring you an otherwise noisier language than c#, header files ., ->, :: etc.

As a rule if your code is able to create and release the COM objects at local scope within a using block, I would stay in C# and put up with the using hassle.

If your code needs to keep COM objects as member variables I would move just those classes to c++/cli and take advantage of stack semantics for member variables that will automatically chain dispose calls for you.

How to manage COM objects runtime in RAII style in C# programs?

3 Answers3