The GC collects when memory reaches a critical mass. While it is not optimal
for all situations, it is a good balance of performance for cleanup versus
performance of running apps. You can attempt to force a Collect(), but it is
marginal, at best, unless you want to take over complete control of the CLR.
I would not advise that tack.

If the underlying data is not changing, you should consider caching the data
rather than retrieving every time the form is brought up. Also, since a user
cannot go through 140,000 records in one sitting, much less one page view,
consider filtering before placing on the form. Reporting is the only thing I
can see that might break this, and aggregating on the data server is a
better option here, in most cases, rather than churning records in your .NET
app.

One speculation on this topic:

Based on what you have said and with the following assumption, this makes
sense.

Create a dataset containing 140,000 records.

Hold a reference to the dataset either directly or indirectly.
 Directly:    Keep it in a variable or in one of you class instance.
Indirectly:  A reference is kept in hashtable or arraylist or WinForm
control and etc.

Now when you retrive the data for the second time, due to lack of space in
the heap, GC might get kicked in.
But GC can not reclaim the space consumed by the previous dataset because
someone is holding an reference to it.
So then why it takes long time? It takes long time because everytime the GC
kicks in, it has to traverse the entire objects refered directly or
indirectly by your program. Since the dataset has 140000 records, it needs
to visit these records. On top of it, if these records has reference to
string or byte[] fields then it needs to visit those objects as well. At the
end it would have found comparatively only few objects for which the space
can be reclaimed.

From now on the GC will get kick in more often till the heap space use
comes down below the critical limit.

So, do a code-walk-through of your application to make sure that the
dataset is not referenced by anyone.

You can validate whether you have the above said problem or not by doing the
following few steps.

1. Before you retrieve and store a dataset in a variable, clear the variable
to null. This will ensure that always you clear the reference to the
existing dataset before you create a new dataset.

2. If you still experiencing the problem, remove all records from the
existing dataset before you clear the variable to null. This will ensure
that even if someone is holding a reference to your existing dataset, the
dataset will not have any records thereby letting GC to traverse few objects
and reclaim almost all the spaces.

After the above change, if the program performs as good as the first one,
the you know that someone is holding a reference to the existing dataset
which is not cleared at all. Now, just findout the culprit and clean it up.

-
S N