C# The 'new' keyword on existing objects

I was wondering as to what happens to an object (in C#), once its reference becomes reassigned. Example:

Car c = new Car("Red Car");
c = new Car("Blue Car");

Since the reference was re开发者_如何学编程used, does the garbage collector dispose / handle the 'Red Car' after it's lost its reference? Or does a separate method need to be implemented to dispose of the 'red car'?

I'm primarily wondering because there's a relatively large object that I'm going to recycle, and need to know if there is anything that should be done when it gets recreated.

In your example, the Red Car instance of c will become eligible for garbage collection when c is assigned to Blue Car. You don't need to do anything.

Check out this (old, but still relevant) MSDN article about the .NET garbage collector. http://msdn.microsoft.com/en-us/magazine/bb985010.aspx

The first paragraph says it all:

Garbage collection in the Microsoft .NET common language runtime environment completely absolves the developer from tracking memory usage and knowing when to free memory.

Since the reference was reused, does the garbage collector dispose / handle the 'Red Car' after it's lost it's reference?

You're looking at this in perhaps the wrong way:

c [*] ----> [Car { Name = "Red Car" }]  // Car c = new Car("Red Car")

Then your next step:

c [*]       [Car { Name = "Red Car"  }] // No chain of references to this object
   \------> [Car { Name = "Blue Car" }] // c = new Car("Blue Car")

The GC will come along and "collect" any of these objects which have no chain of references to a live object at some point in the future. For most tasks, as long as you're using managed data, you should not worry about large objects versus small objects.

For most tasks you only worry about deterministic memory management when dealing with IDisposable. As long as you follow the best practice of using-blocks, you will generally be fine.

You create a new object and assign a reference to it to your variable c. At the same time the previous object (the "red car") is now not referenced anymore and may be garbage collected.

If there are no other references to Red car, it will be collected by the GC on its next cycle. You don't need anything extra (unless it's a class that has streams etc. that need to be disposed)

The garbage collector will handle cleanup for the red car when it is not longer rooted (not reachable). You, the developer, don't generally have to worry about cleaning up memory in .Net.

There are three caveats that need to be mentioned:

1. It won't happen right away. Garbage collection will happen when it happens. You can't predict it.
2. If the type implements IDisposable, it's up to you to make sure the .Dispose() method is called. A using statement is a good way to accomplish this.
3. You mentioned it's a large object. If it's more than 85000 bytes it will stored in a place called the Large Object Heap, which has very different rules for garbage collection. Allowing this kind of object to be recycled frequently can cause problems.

Garbage collector will take care of disposing of Car object

The GC will pick up your Red Car object and dispose of it.

You can call a custom destructor or implement IDisposable if you have resources that need to be released when the original object is no longer used.

In case Car holds some native resources you'll want to implement IDisposable and dispose of it properly before reusing the variable.

I think you should implement the IDispose interface to clean up unmanaged resources

public class car : IDispose