Does Garbage Collector disposes instance of an object defined within a loop?

A new instance will be created at the beginning of each iteration. The old instance will be available for garbage collection once the new instance is assigned to the variable. It's a bit like this scenario:

// First instance.
BlaBla MyInstance = new BlaBla("First Instance");
// As soon as this is assigned, the first instance will be available for garbage collection.
MyInstance = new BlaBla("Second Instance");
// As soon as this is assigned, the second instance will be available for garbage collection.
MyInstance = new BlaBla("Third Instance");
// As soon as this is assigned, the third instance will be available for garbage collection.
MyInstance = new BlaBla("Fourth Instance");
MyInstance = null;
// The fourth instance is now available for garbage collection.

Each new assignment makes the previous instance no longer referenced. Once an instance is no longer referenced, it is available for garbage collection. Basically, you shouldn't come across any memory problems.

I think you may be a tad confused with the answers you got here specially since there's been some arguing in the comments. SA is right, garbage collection and the Dispose pattern are two different things. That said, if you are doing this in a loop, and your object is an IDisposable type with non trivial dispose-requirements, you absolute must call Dispose (or use the using-block) inside the loop. Once again this is independent of GC but something you need to do.

Now, if your class is not an IDisposable but is a type that involves non-trivial initialization, it may be a good idea to redesign the class so that you can create just a single instance, and then reuse it. As an example, if you are appending to a file in a loop, it does not make any sense to open the file, write to it, and close it in each iteration. Open it once outside the loop, do the writes in the loop and close it once you exit the loop. I just used that as an example, your scenario may not be similar.

But the mere fact that you were concerned about memory piling up set off a signal that perhaps the class you are creating may not be a light type, which is why I thought I'd throw in my 2 cents.

You can use the "using" syntax. Take a look at this solution:

while (true)
{
     using(BlaBla myInstance = new BlaBla())
     {
          // do something with this instance
     }
}

"using" calls Dispose() when execution is out of the "using" block. "using" is better because it guarantees the execution of Dispose(), no matter if an exception occurs. "using" is translated to a try-finally block and Dispose() is called in the finally block.

I hope it helps.

Both parts of your last sentence are possible.

The GC will deal with previous instances of BlaBla, provided there are no references to them from elsewhere in your code,
Because it cannot be determined when GC will occur it is possible that there could be memory problems.

To help the GC, BlaBla should implement IDisposable and then

BlaBla MyInstance = null;
while(true)
{
  if (MyInstance != null)
  {
    MyInstance.Dispose();
  }
  MyInstance = new BlaBla();

  //do something with this instance...
}

Here are links to a two part article on GC from MSDN Magazine
Part 1[^]
Part 2[^]