11

I'm in the middle of converting some code from C++/CLI to C#. One of the objects has a destructor in the C++/CLI version. Some other C++/CLI code calls "delete" on this object after use.

Which method do I need to implement in the C# version of this object so those "delete"s continue to function the same (IDisposable.Dispose, the finalizer, or something else that I'm missing)?

Daniel Gabriel
  • 3,939
  • 2
  • 26
  • 37

4 Answers4

17

I would say the IDisposable interface is what you look for if you need deterministic disposal of resources. This is usually the case with unmanaged resources, such as unmanaged handles that need to be closed, streams or database connections.

In C++/CLI, if you declare a managed type (ref class and the like), IDisposable is implemented using the destructor syntax, and Dispose() is called by using the delete keyword. If you declare such an object of a managed type locally (without using the ^ operator or gcnew), C++/CLI even automatically calls Dispose() for you when the object goes out of scope. In that way, C++/CLI is more convenient than C#.

You won't be able to call delete on the object when using C#, you'll need to call Dispose() manually on it instead. Another way to dispose of IDisposable objects is the using block.

The finalizer (implemented in C# by using destructor syntax) is not the same as a C++ destructor, since it is not deterministic when it will be called. Objects with a finalizer are basically queued until the finalizer thread decides to call their finalizer, so effectively you never know exactly when that is called.

The best approach for dealing with unmanaged resources is probably a combination of the two. See here for the recommended approach:
http://msdn.microsoft.com/en-us/library/b1yfkh5e(v=vs.100).aspx

Note, however that when using IDisposable, even though you can dispose of unmanaged resources deterministically, managed objects still need to be collected by the garbage collector (non-deterministically).

I just found an article explaining the differences of this between C++/CLI and C#. You might find it interesting:
http://weblogs.thinktecture.com/cnagel/2006/04/ccli-finalize-and-dispose.html

Botz3000
  • 39,020
  • 8
  • 103
  • 127
  • 1
    C++/CLI stack semantics also work on class members, not just locals. There's no simple way to duplicate this in C#. – Ben Voigt Apr 19 '12 at 22:18
  • Didn't know that (not using C++/CLI very often). Thanks for the info :) – Botz3000 Apr 19 '12 at 23:55
  • I just re-read the answer and there is something I need clarification on: if my class is defined in C# (and implements IDisposable), will I be able to call "delete" on it when using it from another C++/CLI class? Thanks! – Daniel Gabriel Apr 23 '12 at 20:19
  • @DanielGabriel Yes, calling `delete` on objects implementing `IDisposable` calls their `Dispose()` method. It's just C++/CLI's special syntax for it. – Botz3000 Apr 24 '12 at 06:45
4

There's a terminology mismatch between C++/CLI and C#. The C++/CLI destructor (~Foo) is the IDisposable.Dispose() method implementation. A C++/CLI class doesn't explicitly implement IDisposable, it is automatic from just the presence of a destructor.

The C++/CLI finalizer (!Foo) is the C# destructor.

So the C++/CLI delete operator is equivalent to calling the Dispose() method. Beware of stack semantics in C++/CLI, triggered by a local variable of a reference type without the ^ hat. The compiler generates a hidden call to Dispose() at the end of the scope block. Which is equivalent to the C# using keyword. Hard to see from the source code so pay extra attention or look at the generated IL with ildasm.exe

Hans Passant
  • 922,412
  • 146
  • 1,693
  • 2,536
  • 1
    Just a clarification: Although the C# documentation talks about "destructors", C# really doesn't have destructors. Using destructor notation in C# creates a finalizer. And C++/CLI stack semantics are much more powerful than C# `using` blocks. – Ben Voigt Apr 19 '12 at 22:17
1

C# doesn't provide the same tools, but it does provide patterns for you: If your dtor is closing a stream, unlinking pointers, or setting states appropriately then I feel the IDisposable interface is a good fit:

// C#
void Dispose()
{
  _stream.Close();
  _ptr = null;
  _running = false;
}

// with

obj.Dispose();

You can't really force GC to keep memory open. There are ways to help the GC know what can and should be freed, Read http://msdn.microsoft.com/en-us/library/ee787088.aspx for more info.

Keep in mind that using IDisposable expects you to call the Dispose() method appropriately. So in place of each delete, you would want to use Dispose(). The safe part of a finalizer is that when the GC is actually freeing it, it'll be called. However, you can't call the finalizer yourself (so if timing on delete/dispose is important, that isn't the right solution.)

payo
  • 4,501
  • 1
  • 24
  • 32
  • 1
    He's converting from C++/CLI, which already is a managed language with non-deterministic garbage collection. But .NET adds a deterministic disposal pattern, which has excellent language support in C++/CLI, and he's asking how to translate that to C#. C# also has language support for disposal, but not nearly as elegant. – Ben Voigt Apr 20 '12 at 02:54
  • Thanks for pointing that out - yes, it has a pattern and I was pointing him to that pattern with appropriate cases. I'll fix my answer to reflect that he's coming from C++/CLI – payo Apr 20 '12 at 06:16
0

To me, it really depends on what the destructor is doing. If it's doing something like releasing an unmanaged resource (SQL or file connections, for example), then I would implement IDispose and close the connection in the Dispose() method.

If it's destroying other objects that do not require any explicit cleanup, then I would just leave the destructor out and let the GC handle it.

duraz0rz
  • 387
  • 1
  • 2
  • 10