16

Can anyone please tell me how I can free objects in C#? For example, I have an object: 

Object obj1 = new Object();
//Some code using obj1
/*
Here I would like to free obj1, 
after it is no longer required 
and also more importantly 
its scope is the full run time of the program.
*/

Thanks for all your help

Pratik Deoghare
  • 35,497
  • 30
  • 100
  • 146
assassin
  • 19,899
  • 10
  • 30
  • 43

9 Answers9

21

You don't have to. The runtime's garbage collector will come along and clean it up for you. That is why you are using C# and not unmanaged C++ in the first place :)

Christopher
  • 10,409
  • 13
  • 73
  • 97
  • 1
    Will GC clean it up only if there are no references (or links) to the object anymore, or will it also free the object when GC detects that after a point the object is not used by the code at all (even if its scope is say the whole man method, because of which its lifetime will be the full run time of the program)? – assassin Mar 09 '10 at 06:19
  • 2
    @assasin: It collects when there are no references, period. GC doesn't do compiler's job. So it can't collect if there is a reference, even if it won't be used in the future. That's why we have to be careful about static objects. But in your main method example, it depends. References from stack have main scope. But the objects they point to may or may not depending on whether your references get reassigned. – Fakrudeen Mar 09 '10 at 08:21
9

You don't have to. You simply stop referencing them, and the garbage collector will (at some point) free them for you.

You should implement IDisposable on types that utilise unmanaged resources, and wrap any instance that implements IDisposable in a using statement.

Mitch Wheat
  • 295,962
  • 43
  • 465
  • 541
  • 3
    or just use C++/CLI instead, so you don't have to remember which types implement IDisposable and which don't, it will automatically call Dispose when the object goes out of scope (if not declared as a handle) – Ben Voigt Mar 09 '10 at 05:23
  • 8
    hardly a compelling reason to use C++/CLI! :) – Mitch Wheat Mar 09 '10 at 05:37
  • @Ben Voigt If you implement IDisposable correctly then the Dispose function will be called when it goes out of scope in C# also. – Thanos Papathanasiou Mar 09 '10 at 07:33
  • @Thanos: nonsense. A little code example will demonstrate: C# void fn(void) { FileStream s = new FileStream("in.dat"); } s.Dispose is not called. C++ void fn(void) { FileStream s("in.dat"); } s.Dispose is called. Note that "put a using block in" isn't at all equivalent, the C++ syntax is identical for IDisposable and non-IDisposable objects, where C# doesn't allow using for non-IDisposable types, resulting in a huge maintenance if a type ever begins to implement IDisposable in a later version. – Ben Voigt Mar 09 '10 at 13:32
  • 1
    @Ben Voig: check this first: http://msdn.microsoft.com/en-us/library/system.idisposable.aspx when you have the using command its translated to try{x = new x() }finally{ x.Dispose() } and in the other case when it goes out of scope the destructor calls the private Dispose(bool disposing). In any case, Microsoft's correct implementation is what you can see in the link I provided. – Thanos Papathanasiou Mar 09 '10 at 14:28
  • @Thanos: MSDN documentation, unfortunately, isn't 100% accurate. That page says "It is a version-breaking change to add the IDisposable interface to an existing class, because it changes the semantics of the class." That's true in C# but not in C++/CLI. In C++/CLI your stack semantic variables get Disposed if they're IDisposable, no change to the client source code is needed if IDisposable is added. And you can make a smart pointer that calls delete on a handle, Dispose will get called if possible but you don't need special code to handle the difference between IDisposable and not. – Ben Voigt Mar 10 '10 at 00:54
  • @Thanos: Were you talking about C++/CLI or C#? C# has no destructor so it can't call Dispose from the destructor when the variable goes out of scope. – Ben Voigt Mar 10 '10 at 00:56
  • I was talking about C# and it does have destructors. – Thanos Papathanasiou Mar 10 '10 at 06:35
7

You do not. This is what a garbage collector does automatically - basically when the .NET runtime needs memory, it will go around and delete objects that are not longer in use.

What you have to do for this to work is to remove all linnks to the object.

In your case....

obj1=null;

at the end, then the object is no longer referenced and can be claimed from the garbage collector.

You can check http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) for more details.

Note that if the object has references to unmanaged ressources (like open files etc.) it should implement the Disposable pattern (IDisposable interface) and you should explicitely release those references when you dont need the object anymore.

TomTom
  • 61,059
  • 10
  • 88
  • 148
  • 2
    There is no need to perform obj1=null; – Mitch Wheat Mar 09 '10 at 05:13
  • 2
    I was going to suggest assigning to null but a little reading says that can actually *delay* garbage collection in C#. How interesting. See this article for more on why you shouldn't assign to null in C#: http://blogs.msdn.com/csharpfaq/archive/2004/03/26/97229.aspx – Ian C. Mar 09 '10 at 05:13
  • One problem with this is when you are invoking COM objects housed in another process. The other process will then get the classical "COM server warning" dialog because C# allows the reference to linger. Im pretty sure setting the reference to null would have an impact when dealing with that. – Jon Lennart Aasenden Sep 10 '13 at 12:32
  • @MitchWheat You do if the object's scope is the whole program and you want the GC to clean it up. Otherwise a reference will always exist. – Clonkex Aug 30 '22 at 00:55
  • @Clonkex: I'd suggest re-reading what you wrote. – Mitch Wheat Aug 30 '22 at 02:16
  • @MitchWheat What's wrong with it? The OP said the scope is the whole program (so probably in Main). If you don't remove the reference by setting the variable to `null`, the reference will exist for the entire runtime of the program and won't get GC'd. Am I missing something? – Clonkex Aug 30 '22 at 02:30
5

It's not recommended, but if you really need to, you can force garbage collection via: 

GC.Collect();
bkaid
  • 51,465
  • 22
  • 112
  • 128
3

You stop referencing them and let the garbage collector take them.

When you want to free the object, add the following line:

obj1 = null;

The the garbage collector if free to delete the object (provided there are no other pointer to the object that keeps it alive.)

Arve
  • 7,284
  • 5
  • 37
  • 41
  • @BrianRasmussen Well the question is about an object whose scope is the entire program so this is the correct answer. – Clonkex Aug 30 '22 at 00:57
2

You can use the using statement. After the scope the reference to the object will be removed and garbage collector can collect it at a later time.

rahul
  • 184,426
  • 49
  • 232
  • 263
  • 5
    This only applies to objects implementing IDisposable – Arve Mar 09 '10 at 05:13
  • This is unnecessary for regular managed objects. Only objects that implement IDisposable and hold references to unmanaged data should be used with `using`. – Clonkex Aug 30 '22 at 00:56
1

As others have mentioned you don't need to explicitly free them; however something that hasn't been mentioned is that whilst it is true the inbuilt garbage collector will free them for you, there is no guarantee of WHEN the garbage collector will free it.

All you know is that when it has fallen out of scope it CAN be cleaned up by the GC and at some stage will be.

Michael Shimmins
  • 19,961
  • 7
  • 57
  • 90
0

As Chris pointed out C# does most of the garbage collection for you. Instances where you would need to consider garbage collection is with the implementation of the IDisposable interface and when using WeakReference. See http://msdn.microsoft.com/en-us/library/system.idisposable.aspx and http://msdn.microsoft.com/en-us/library/system.idisposable.aspx for more information.

Cornelius
  • 3,526
  • 7
  • 37
  • 49
0

GC will collect all but unmanaged resources.

The unmanaged resources should implement IDisposable. If you are using an object that implements IDisposable, then you should either call the object's Dispose() method when it is no longer needed or wrap its instance in a using statement.

Xpleria
  • 5,472
  • 5
  • 52
  • 66