[C#] Incremento di memoria fuori controllo

[cyberfido]

Ciao a tutti,
uilizzio Visual Studio 2008 e uso Windows 7.
In un'applicazione che sto sviluppando un metodo mi incrementa l'utilizzo di memoria del software di molti MB, alcune decine a chiamata.
Non riesco a capire come mai lo faccia, però il metodo è questo

public static void route_list_sort(ref List<routedetail> plist)
        {
            routedetail laux;
            int n = plist.Count;
            /// ordina per distanza dalla base
            while (n > 0)
            {
                for (int i = 0; i < n - 1; i++)
                {
                    if (plist[i].tobase != null && plist[i + 1].tobase != null)
                    {
                        if (plist[i].tobase.value() > plist[i + 1].tobase.value())
                        {
                            laux = !plist[i];
                            plist[i] = !plist[i + 1];
                            plist[i + 1] = !laux;
                        }
                    }
                }
                n--;
            }
          [...]
        }

L'oggetto routedetail l'ho creato io e la funziona value() esegue una semplice somma di un intero e un float, mentre tobase è un altro oggetto stupido che contiene il metodo value() e l'int e il float di cui sopra.
con circa 200 oggetti incrementa di 20 MB ogni volta che esegue il while.
l'oggetto plist che passo al metodo è un oggetto globale utilizzato dal programma in questione che non termina la propria esistenza poco al di fuori del metodo.
ho provato ad aggiungere alla fine del metodo le sguenti righe, ma non cambia assolutamente niente.

plist = null;
plist.Clear();
GC.Collect();

Solo terminando il programma la memoria si libera.
Non so cosa fare, perciò vi chiedo aiuto.
Grazie mille in anticipo.
Ciao
cyb

[gugoXX]

Ma a parte tutto, ma cosa vorresti fare con quel metodo?
Ordinare la lista in modo decrescente secondo il campo tobase ?

plist.OrderByDescending(el => el.tobase).ToList();

Comunque direi che la colpa non e' del metodo che hai scritto, se non dovuto a meccanismi indirittamente nascosti la cui colpa sarebbe quindi loro, e anche di scrittura.

Ad esempio cosa e' il ! in
laux = !plist[i];

e cosa e' value() in
plist[i].tobase.value()

perche' in assenza di delegate l'unico modo per occupare memoria heap in C# e' quello di eseguire direttamente o indirettamente la direttiva new
che qui non e' presente, quindi o e' nascosta in mezzo a qualcosa (che e' male dal punto di vista della programmazione) o la colpa non e' di questo pezzo di codice.

Non so quale sia il modo che tu abbia usato per capire la colpa o la complessità del codice, ma e' generalmente abbastanza complesso andare alla ricerca del colpevole.

[cyberfido]

ciao,
grazie per la risposta.
A parte tutto con quel metodo vorrei ordinare in modo crescente, cioè dal più vicino al più lontano.
ora provo con qualcosa di diverso, come suggerisci tu magari.
Poi: il ! è la sovrascrittura di un operatore unario che effettua una clonazione dell'oggetto, mentre value() come ho scritto prima ritorna la somma tra un int e un float.
Il modo che io ho usato per vedere che il problema secondo me è stato di vedere la RAM occupata dal programma prima e dopo l'esecuzione di questo blocco di codice e constatare che la differenza era un incremento di circa 20 MB.

L'operatore unario !
esegue questo

public static routedetail operator !(routedetail a)
        {
            routedetail b = new routedetail();
            b.id = a.id;
            b.ddt = !a.ddt;
            b.geo = a.geo;
            b.dquote = a.dquote;
            b.rquote = a.rquote;
            b.dhquote = a.dhquote;
            b.rhquote = a.rhquote;
            b.time = a.time;
            b.timeannouncedfrom = a.timeannouncedfrom;
            b.timeannouncedto = a.timeannouncedto;
            b.minutesstop0 = a.minutesstop0;
            b.minutesstop1 = a.minutesstop1;
            b.minutesrun = a.minutesrun;
            b.appointment = !a.appointment;
            b.km = a.km;
            b.priority = a.priority;
            b.currentquote = a.currentquote;
            b.calls = !a.calls;
            if(a.listviewitem != null)
                b.listviewitem = (ListViewItem)a.listviewitem.Clone();
            if (a.nts != null)
                b.nts = a.nts;
            if (a.gasoline != null)
                b.gasoline = !a.gasoline;
            if (a.tobase != null)
                b.tobase = !a.tobase;
            if (a.totry != null)
                b.totry = !a.totry;
            b.join = lib.refclone(ref a.join); //list_clone
            return b;
        }

qui c'è un new.
forse è questo che ciclato crea nuova allocazione di memoria. giusto?
ma come mai non viene mai rilasciata questa memoria nonostante siano oggetti locali?

[cyberfido]

forse ho parzialmente risolto.
sicuramente la creazione di nuovi oggetti ciclicamente "riempiva" la RAM e
facendo un ordinamento semplicemente come hai suggerito tu, previa estensione dell'interfaccia IComparer da parte dell'oggetto routedetail, con annessa sovrascrittura di Compare(object, object) ha sicuramente migliorato la cosa.
Adesso infatti aumenta di 800KB/1MB a chiamata al posto dei precedenti 20MB.
Il problema non è stato risolto, ma è stato sicuramente minimizzato.
Cerco di capire come mai non vengano rilasciate le risorse inizializzate però.
Visto che tratto contestualmente anche oggetti grafici,
può darsi che il problema sia questo?

Grazie.
Ciao.

[gugoXX]

Originariamente inviato da cyberfido

ciao,
grazie per la risposta.
A parte tutto con quel metodo vorrei ordinare in modo crescente, cioè dal più vicino al più lontano.
ora provo con qualcosa di diverso, come suggerisci tu magari.
Poi: il ! è la sovrascrittura di un operatore unario che effettua una clonazione dell'oggetto, mentre value() come ho scritto prima ritorna la somma tra un int e un float.
Il modo che io ho usato per vedere che il problema secondo me è stato di vedere la RAM occupata dal programma prima e dopo l'esecuzione di questo blocco di codice e constatare che la differenza era un incremento di circa 20 MB.

L'operatore unario !
esegue questo

public static routedetail operator !(routedetail a)
        {
            routedetail b = new routedetail();
            b.id = a.id;
            b.ddt = !a.ddt;
            b.geo = a.geo;
            b.dquote = a.dquote;
            b.rquote = a.rquote;
            b.dhquote = a.dhquote;
            b.rhquote = a.rhquote;
            b.time = a.time;
            b.timeannouncedfrom = a.timeannouncedfrom;
            b.timeannouncedto = a.timeannouncedto;
            b.minutesstop0 = a.minutesstop0;
            b.minutesstop1 = a.minutesstop1;
            b.minutesrun = a.minutesrun;
            b.appointment = !a.appointment;
            b.km = a.km;
            b.priority = a.priority;
            b.currentquote = a.currentquote;
            b.calls = !a.calls;
            if(a.listviewitem != null)
                b.listviewitem = (ListViewItem)a.listviewitem.Clone();
            if (a.nts != null)
                b.nts = a.nts;
            if (a.gasoline != null)
                b.gasoline = !a.gasoline;
            if (a.tobase != null)
                b.tobase = !a.tobase;
            if (a.totry != null)
                b.totry = !a.totry;
            b.join = lib.refclone(ref a.join); //list_clone
            return b;
        }

qui c'è un new.
forse è questo che ciclato crea nuova allocazione di memoria. giusto?
ma come mai non viene mai rilasciata questa memoria nonostante siano oggetti locali?

ma non sono locali. Li restituisci al chiamante.
Poi c'e' una ricorsione, esegui di nuovo il metodo ! all'interno.
E c'e' anche un qualcosa che clona!!!
Ma tutto cio' per ordinare?
Comunque IComparer non e' necessario. E' sufficiente quello che hai ed un po' di Linq per ordinare.

plist.OrderByDescending(el => el.tobase.Value()).ToList();

[cyberfido]

ciao,
ancora grazie.
sì ora ci sono diverse cose che non sto nemmeno a spiegare perché si andrebbe fuori tema, comunque sì avevo visto anche io alcune delle cose che mi avevi segnalato.

comunque la riga di codice che mi hai indicato in fondo al post l'ho adottata, ma non funziona senza IComparer.
Non conosco LINQ e ne approfitto per andare a vedere cosa sia.

Comunque direi che il problema è risolto.
Ti ringrazio ancora.
Ciao.
cyb