C# Collect garbage of object with memory leak

I am using a 3rd-party object I didn't create that over time consumes a lot of resources. This object shouldn't in any way contain a state, it simply performs a calculation. Despite this fact, everytime I call a specific function of this object a little more memory is consumed. A few hours later, and my program is sitting at gigabytes of allocated memory.

The object was origionaly initialized as a static member of my Program class in my command-line application. I have found that if I wrap my entire program in an class, and reinitialize it every now and again, the older (and bloate开发者_运维知识库d) object is unallocated by GC and a new smaller object replaces it.

My issue is this method is quite clumsy and ruins the flow of my Program.

Is there any other way you can dispose of an object? I am lead to believe GC.Collect() will only dispose unreachable code. Is there anyway I can make an object 'unreachable'?

Edit: As requested, the code:

static ILexicon lexicon = new Lexicon();

...

lexicon.LoadDataFromFile(@"lexicon.dat", null);

...

    byte similarityScore(string w1, string w2, PartOfSpeech pos, SimilarityMeasure measure)
    {
        if (w1 == w2)
            return 255;
        if (pos != PartOfSpeech.Noun && pos != PartOfSpeech.Verb)
            return 0;

        IList<ILemma> w1_lemmas = lexicon.FindSenses(w1, pos);
        IList<ILemma> w2_lemmas = lexicon.FindSenses(w2, pos);
        byte result;
        byte score = 0;

        foreach (ILemma w1_lemma in w1_lemmas)
        {
            foreach (ILemma w2_lemma in w2_lemmas)
            {
                result = (byte) (w1_lemma.GetSimilarity(w2_lemma, measure) * 255);
                if (result > score)
                    score = result;
            }
        }

        return score;
    }

As similarityScore is called, more memory is allocated to a private member of lexicon. It does not implement IDisposable and there are no obvious functions to clear the memory. The library is based on WordNet, and uses an algorithm to find path lengths in the hypernym tree to calculate the similarity of two words. Unless there is caching, I can't see why it would need to store any memory. What is for sure, is I can't change it. I'm almost certain there is nothing wrong with my code. I just need to dispose of lexicon when it gets too large (N.B. it takes a second or two to load the lexicon from file to memory)

If the object doesn't implement IDisposable and you want to push it out of scope you can set all references to it to null and then the force garbage collection with GC.Collect().

GC.Collect() is very expensive. If you're going to have to do this frequently, you might want to consider contacting the vendor.

Find out:

1. If you are using their library correctly, or is there something you're doing wrong that's causing the memory leak.
2. If their library is leaking memory even when used as intended, can they fix the leak?

Additional note: If the 3rd party library is native and you're having to use interop, you can use Marshal.ReleaseComObject to free unmanaged memory.

you could try calling the Dispose() method. This would make the object unusable, so you would have to instantiate another one. I assume your program is in a loop, so it can be a loop variable with the call to dispose at the bottom.

I would suggest that if you can get your hands on a memory profiler, you use it. A memory profiler will let you pause your program, click on a class, and and see a list of objects of that class. One can then click on an object and see how it was created, and the "path" to that object from a root (e.g. there's a static class foo, which holds a reference to a bar, which holds a reference to a boz, which holds a reference to a reallybigthing). Often, seeing that will make it clear what needs to be done to break the chain.

you might be able to download the source from wordnet repository and modify the code since it is an opensource.