Quando é aceitável chamar GC.A cobrar?

Só uso {[1] } quando escrevo plataformas de teste de desempenho/perfil em bruto; ou seja, tenho dois (ou mais) blocos de código para testar-algo como:

GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
TestA(); // may allocate lots of transient objects
GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
TestB(); // may allocate lots of transient objects
GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
...

Para que TestA() e TestB() corram com o estado mais semelhante possível - isto é, TestB() não se embebedem só porque TestA o deixaram muito perto do ponto de viragem.

Um exemplo clássico seria um simples consola exe( um método de ordenação Main - o suficiente para ser publicado aqui, por exemplo), que mostra a diferença entre cadeia de caracteres em looped concatenação e StringBuilder.

Se eu precisar de algo preciso, então esta seria dois completamente independentes de testes, mas muitas vezes isso é suficiente se nós apenas queremos minimizar (ou normalizar) o GC durante os testes para obter uma sensação áspera para o comportamento.

Durante o código de produção? Ainda não o usei; - p

A melhor prática é não forçar uma coleta de lixo na maioria dos casos.(Todos os sistemas em que trabalhei que forçaram coleções de lixo, tiveram problemas que se resolvidos teriam removido a necessidade de forçar a coleta de lixo, e aceleraram muito o sistema.)

Há um poucos casos Quando você Sabe mais sobre o uso da memória do que o coletor de lixo sabe. É pouco provável que isso seja verdade em uma aplicação multi-usuário, ou um serviço que está a responder a mais do que um pedido de cada vez.

No entanto, em algum processamento do tipo de lote {[3] } você sabe mais do que o GC. Por exemplo, considere uma aplicação que.

• é dada uma lista de nomes de ficheiros na linha de comandos
• processa um único ficheiro e depois escreve o resultado para um ficheiro de resultados.
• ao processar o ficheiro, cria um monte de objectos interligados que não podem ser recolhidos até que o processamento do ficheiro esteja completo (por exemplo, uma análise comparativa). árvore)
• não mantém o estado de correspondência entre os ficheiros que processou .

Você Pode ser capaz de fazer um caso (depois de cuidadoso) testando que você deve forçar uma coleção completa de lixo depois de ter processado cada arquivo.

A única vez que consideraria forçar uma coleção é quando eu sei que muito do objecto foi criado recentemente e muito poucos objetos são atualmente relacionar.

Ver também "As tidbits de desempenho de Rico Mariani"

Um caso é quando se está a tentar usar o código de teste unitário que usa O WeakReference.

Em grandes sistemas 24/7 ou 24/6 -- sistemas que reagem a mensagens, solicitações de RPC ou que pesquisam um banco de dados ou processo continuamente -- é útil ter uma maneira de identificar vazamentos de memória. Para isso, eu tendem a adicionar um mecanismo à aplicação para suspender temporariamente qualquer processamento e, em seguida, realizar a coleta completa de lixo. Isto coloca o sistema em um estado quiescente, onde a memória restante é ou a memória legitimamente longa (caches, configuração, & C.) ou então é 'vazada' (objetos que não são esperados ou desejados para ser enraizado, mas na verdade são).

Ter este mecanismo torna muito mais fácil a utilização da memória de perfil, uma vez que os relatórios não serão toldados com o ruído do processamento activo.

GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();

Como a primeira coleção fará com que todos os objetos com finalizadores sejam finalizados (mas não na verdade lixo coletar esses objetos). O segundo GC vai recolher lixo estes finalizados objecto.

O melhor exemplo que consigo pensar de onde poderá ter alguma informação extra é uma aplicação que circula entre períodos de inactividade e muito ocupada periodo. Você quer o melhor desempenho possível para os períodos ocupados e, portanto, quer usar o tempo ocioso para fazer alguma limpeza.

Quando ligar para a GC.Recolher()

Estava a fazer alguns testes de desempenho no array e na lista:

private static int count = 100000000;
private static List<int> GetSomeNumbers_List_int()
{
    var lstNumbers = new List<int>();
    for(var i = 1; i <= count; i++)
    {
        lstNumbers.Add(i);
    }
    return lstNumbers;
}
private static int[] GetSomeNumbers_Array()
{
    var lstNumbers = new int[count];
    for (var i = 1; i <= count; i++)
    {
        lstNumbers[i-1] = i + 1;
    }
    return lstNumbers;
}
private static int[] GetSomeNumbers_Enumerable_Range()
{
    return  Enumerable.Range(1, count).ToArray();
}

static void performance_100_Million()
{
    var sw = new Stopwatch();

    sw.Start();
    var numbers1 = GetSomeNumbers_List_int();
    sw.Stop();
    //numbers1 = null;
    //GC.Collect();
    Console.WriteLine(String.Format("\"List<int>\" took {0} milliseconds", sw.ElapsedMilliseconds));

    sw.Reset();
    sw.Start();
    var numbers2 = GetSomeNumbers_Array();
    sw.Stop();
    //numbers2 = null;
    //GC.Collect();
    Console.WriteLine(String.Format("\"int[]\" took {0} milliseconds", sw.ElapsedMilliseconds));

    sw.Reset();
    sw.Start();
//getting System.OutOfMemoryException in GetSomeNumbers_Enumerable_Range method
    var numbers3 = GetSomeNumbers_Enumerable_Range();
    sw.Stop();
    //numbers3 = null;
    //GC.Collect();

    Console.WriteLine(String.Format("\"int[]\" Enumerable.Range took {0} milliseconds", sw.ElapsedMilliseconds));
}

E eu tenho {[2] } no método GetSomeNumbers_Enumerable_Range a única solução é desligar a memória por:

numbers = null;
GC.Collect();

Ao programar usando o Interop, cada COM o objeto deve ser liberado manualmente, geralmente através do uso de Marshal.ReleseComObject(). Além disso, chamar a coleta de lixo manualmente pode ajudar a "limpar" um pouco. Chamar o seguinte código quando você terminar com objetos Interop parece ajudar bastante:

GC.Collect()
GC.WaitForPendingFinalizers()
GC.Collect()

Na minha experiência pessoal, usar uma combinação de ReleaseComObject e chamar manualmente a recolha de lixo reduz grandemente o uso de memória de produtos de escritório, especificamente o Excel.

Se você vai acordar em intervalos, (definir horas) então o seu programa deve ser criado para uma única execução (executar a tarefa uma vez) e, em seguida, terminar. Em seguida, você configura o programa como uma tarefa agendada para executar nos intervalos agendados.

Http://blogs.msdn.com/ricom/archive/2004/11/29/271829.aspx

É possível autor de umnão gerido DLL em C# usando a reescrita IL (porque existem situações em que isso é necessário).

Suponha agora, por exemplo, que o DLL cria um array de bytes ao nível da classe - porque muitas das funções exportadas precisam de acesso a tal. O que acontece quando o DLL é descarregado? É o coletor de lixo chamado automaticamente em esse ponto? Não sei, mas sendo um não gerido, é possível que o GC não seja chamado. E seria um grande problema se não fosse chamado. Quando o DLL é descarregado assim também seria o coletor de lixo - então quem vai ser responsável pela coleta de qualquer lixo possível e como eles fariam isso? É melhor contratar o cobrador de lixo da c#. Ter uma função de Limpeza (disponível para o cliente DLL) onde as variáveis de nível de classe são definidas como nulas e o coletor de lixo conhecer.

Um lugar útil para chamar GC.O Collect () está num teste de unidade quando quer verificar que não está a criar uma fuga de memória (por exemplo, se está a fazer alguma coisa com referências fracas ou um código Condicionalweaktable, dinamicamente gerado, etc.).

WeakReference w = CodeThatShouldNotMemoryLeak();
Assert.IsTrue(w.IsAlive);
GC.Collect();
GC.WaitForPendingFinalizers();
Assert.IsFalse(w.IsAlive);

A entrada no blog de Scott Holden sobre quando (e quando não) ligar para a GC.O Collect é específico do . Net Compact Framework , mas as regras aplicam-se geralmente a todo o desenvolvimento gerido.

using(var stream = new MemoryStream())
{
   bitmap.Save(stream, ImageFormat.Png);
   techObject.Last().Image = Image.FromStream(stream);
   bitmap.Dispose();

   // Without this code, I had an OutOfMemory exception.
   GC.Collect();
   GC.WaitForPendingFinalizers();
   //
}

Muitos componentes de terceiros usaram GC.Quando eles pensaram que era inteligente fazer isto agora. Então um simples grupo de relatórios do Excel bloqueou o servidor de aplicativos para todos os threads várias vezes por minuto.

Ou pelo menos fazer este comportamento como opção configurável, devido às desvantagens do problema de desempenho com o GC.Recolher.

public static TResult ExecuteOOMAware<T1, T2, TResult>(Func<T1,T2 ,TResult> func, T1 a1, T2 a2)
{

    int oomCounter = 0;
    int maxOOMRetries = 10;
    do
    {
        try
        {
            return func(a1, a2);
        }
        catch (OutOfMemoryException)
        {
            oomCounter++;
            if (maxOOMRetries > 10)
            {
                throw;
            }
            else
            {
                Log.Info("OutOfMemory-Exception caught, Trying to fix. Counter: " + oomCounter.ToString());
                System.Threading.Thread.Sleep(TimeSpan.FromSeconds(oomCounter * 10));
                GC.Collect();
            }
        }
    } while (oomCounter < maxOOMRetries);

    // never gets hitted.
    return default(TResult);
}

(Note que o fio.Sono() comportamento é um comportamento apecífico, porque estamos executando um serviço de cache ORM, e o Serviço leva algum tempo para liberar todos os objetos Cache, se a RAM exceder alguns valores pré-definidos. por isso, espera alguns segundos da primeira vez, e aumentou o tempo de espera a cada ocorrência de OOM.)

Deve tentar evitar o uso de GC.Recolher() desde que é muito caro. Aqui está um exemplo:

        public void ClearFrame(ulong timeStamp)
    {
        if (RecordSet.Count <= 0) return;
        if (Limit == false)
        {
            var seconds = (timeStamp - RecordSet[0].TimeStamp)/1000;
            if (seconds <= _preFramesTime) return;
            Limit = true;
            do
            {
                RecordSet.Remove(RecordSet[0]);
            } while (((timeStamp - RecordSet[0].TimeStamp) / 1000) > _preFramesTime);
        }
        else
        {
            RecordSet.Remove(RecordSet[0]);

        }
        GC.Collect(); // AVOID
    }

RESULTADO DO TESTE: UTILIZAÇÃO DO CPU 12%

Quando Mudar para este:

        public void ClearFrame(ulong timeStamp)
    {
        if (RecordSet.Count <= 0) return;
        if (Limit == false)
        {
            var seconds = (timeStamp - RecordSet[0].TimeStamp)/1000;
            if (seconds <= _preFramesTime) return;
            Limit = true;
            do
            {
                RecordSet[0].Dispose(); //  Bitmap destroyed!
                RecordSet.Remove(RecordSet[0]);
            } while (((timeStamp - RecordSet[0].TimeStamp) / 1000) > _preFramesTime);
        }
        else
        {
            RecordSet[0].Dispose(); //  Bitmap destroyed!
            RecordSet.Remove(RecordSet[0]);

        }
        //GC.Collect();
    }

RESULTADO DO TESTE: UTILIZAÇÃO DO CPU 2-3%

De https://stackoverflow.com/a/58810699/8685342:

try
{
    if (port != null)
        port.Close(); //this will throw an exception if the port was unplugged
}
catch (Exception ex) //of type 'System.IO.IOException'
{
    System.GC.Collect();
    System.GC.WaitForPendingFinalizers();
}

port = null;

Isto não é relevante para a questão, mas para o XSLT transforma-se em.Net (XSLCompiledTranform) então você pode não ter escolha. Outro candidato é o controle MSHTML.

Se estiver a usar uma versão do. Net inferior a 4.5, a colecção manual pode ser inevitável (especialmente se estiver a lidar com muitos 'objectos grandes').

Este link descreve o porquê:

Https://blogs.msdn.microsoft.com/dotnet/2011/10/03/large-object-heap-improvements-in-net-4-5/

Uma vez que existem pequenos objectos heap(SOH) e large object heap (LOH)

In .net4. 5, we can also compact LOH by using largeobjecttheapcompactionmode