Este artigo foi traduzido por máquina. Para visualizar o arquivo em inglês, marque a caixa de seleção Inglês. Você também pode exibir o texto Em inglês em uma janela pop-up, movendo o ponteiro do mouse sobre o texto.
Tradução
Inglês
Esta documentação foi arquivada e não está sendo atualizada.

Classe MemoryFailPoint

Verifique se há recursos suficientes de memória anteriores para execução. Esta classe não pode ser herdada.

Namespace:  System.Runtime
Assembly:  mscorlib (em mscorlib.dll)

public sealed class MemoryFailPoint : CriticalFinalizerObject, 
	IDisposable

ObservaçãoObservação:

Isso classe é destinado ao uso no desenvolvimento de avançadas.

Criando uma instância de um MemoryFailPoint classe cria um portão de memória. Um portão de memória é uma verificação de recursos suficientes antes de iniciar uma atividade que exigem uma grande quantidade de memória.Falhar na verificação lança um InsufficientMemoryException evita que iniciar uma operação, reduzindo a possibilidade de um aplicativo falha durante a execução devido ao falta de recursos. Isso permite que um aplicativo diminuir seu desempenho em um esforço para evitar um OutOfMemoryException e qualquer dano de estado pode ser resultado de Tratamento impróprio de uma OutOfMemoryException em locais arbitrários no código.

Lançando uma InsufficientMemoryException, um aplicativo pode distinguir entre uma estimativa recuperável uma operação não poderá concluir em oposição a uma OutOfMemoryException durante uma operação parcialmente concluída pode corromper o estado. Isso permite que um aplicativo reduzir a freqüência de uma diretiva de escalonamento pessimista, que pode exigir a descarregar o corrente AppDomain ou o processo de reciclagem.

MemoryFailPoint verifica se suficiente memória e o endereço virtual consecutivo espaço está disponível em todas as coleções de lixo heaps e pode aumentar o arquivo de permuta, se necessário. The MemoryFailPoint torna há garantias sobre a disponibilidade a longo prazo de memória durante o ciclo de vida de entrada mas chamadores sempre devem chamar Dispose para garantir recursos associados a MemoryFailPoint são liberados.

Para utilizar um portão de memória, você deve criar um MemoryFailPoint objeto, especificando o número de megabytes de memória que a operação deve usar. Se não estiver disponível, memória insuficiente um InsufficientMemoryException é gerado.

O parâmetro do construtor deve ser um inteiro positivo.Um valor negativo gera uma ArgumentOutOfRangeException.

MemoryFailPoint foi projetado para permitir que um aplicativo diminuir a mesmo para evitar a falta de memória de maneira corrompida. Ele deve ser usado em um escopo léxico.O exemplo de código a seguir inicia threads para processar os itens em uma fila de trabalho.Antes de cada thread é iniciado os recursos de memória disponível são verificados usando MemoryFailPoint. Se uma exceção é lançada, o principal método aguardará até que a memória esteja disponível antes de iniciar o próximo segmento.

using System;
using System.Runtime;
using System.IO;
using System.Threading;
using System.Collections.Generic;
using System.Collections;

class MemoryFailPointExample
{
    // Allocate in chunks of 64 megabytes.privateconst uint chunkSize = 64 << 20;
    // Use more than the total user-available address space (on 32 bit machines)// to drive towards getting an InsufficientMemoryException.privateconst uint numWorkItems = 1 + ((1U << 31) / chunkSize);
    static Queue workQueue = new Queue(50);

    // This value can be computed separately and hard-coded into the application.// The method is included to illustrate the technique.privatestaticint EstimateMemoryUsageInMB()
    {
        int memUsageInMB = 0;

        long memBefore = GC.GetTotalMemory(true);
        int numGen0Collections = GC.CollectionCount(0);
        // Execute a test version of the method to estimate memory requirements.// This test method only exists to determine the memory requirements.
        ThreadMethod();
        // Includes garbage generated by the worker function.
        long memAfter = GC.GetTotalMemory(false);
        // If a garbage collection occurs during the measuring, you might need a greater memory requirement.
        Console.WriteLine("Did a GC occur while measuring?  {0}", numGen0Collections == GC.CollectionCount(0));
        // Set the field used as the parameter for the MemoryFailPoint constructor.
        long memUsage = (memAfter - memBefore);
        if (memUsage < 0)
        {
            Console.WriteLine("GC's occurred while measuring memory usage.  Try measuring again.");
            memUsage = 1 << 20;
        }

        // Round up to the nearest MB.
        memUsageInMB = (int)(1 + (memUsage >> 20));
        Console.WriteLine("Memory usage estimate: {0} bytes, rounded to {1} MB", memUsage, memUsageInMB);
        return memUsageInMB;
    }

    staticvoid Main()
    {
        Console.WriteLine("Attempts to allocate more than 2 GB of memory across worker threads.");
        int memUsageInMB = EstimateMemoryUsageInMB();

        // For a production application consider using the threadpool instead.
        Thread[] threads = new Thread[numWorkItems];
        // Create a work queue to be processed by multiple threads.int n = 0;
        for (n = 0; n < numWorkItems; n++)
            workQueue.Enqueue(n);
        // Continue to launch threads until the work queue is empty.while (workQueue.Count > 0)
        {
            Console.WriteLine(" GC heap (live + garbage): {0} MB", GC.GetTotalMemory(false) >> 20);
            MemoryFailPoint memFailPoint = null;
            try
            {
                // Check for available memory.
                memFailPoint = new MemoryFailPoint(memUsageInMB);
                n = (int)workQueue.Dequeue();
                threads[n] =
                    new Thread(new ParameterizedThreadStart(ThreadMethod));
                WorkerState state = new WorkerState(n, memFailPoint);
                threads[n].Start(state);
                Thread.Sleep(10);
            }
            catch (InsufficientMemoryException e)
            {
                // MemoryFailPoint threw an exception, handle by sleeping for a while,  then // continue processing the queue.
                Console.WriteLine("Expected InsufficientMemoryException thrown.  Message: " + e.Message);
                // We could optionally sleep until a running worker thread // has finished, like this:  threads[joinCount++].Join();
                Thread.Sleep(1000);
            }
        }

        Console.WriteLine("WorkQueue is empty - blocking to ensure all threads quit (each thread sleeps for 10 seconds)");
        foreach (Thread t in threads)
            t.Join();
        Console.WriteLine("All worker threads are finished - exiting application.");
    }

    // Test version of the working code to determine memory requirements.staticvoid ThreadMethod()
    {
        byte[] bytes = new byte[chunkSize];
    }

    internalclass WorkerState
    {
        internalint _threadNumber;
        internal MemoryFailPoint _memFailPoint;

        internal WorkerState(int threadNumber, MemoryFailPoint memoryFailPoint)
        {
            _threadNumber = threadNumber;
            _memFailPoint = memoryFailPoint;
        }

        internalint ThreadNumber
        {
            get { return _threadNumber; }
        }

        internal MemoryFailPoint MemoryFailPoint
        {
            get { return _memFailPoint; }
        }
    }

    // The method that does the work.staticvoid ThreadMethod(Object o)
    {
        WorkerState state = (WorkerState)o;
        Console.WriteLine("Executing ThreadMethod, " +
            "thread number {0}.", state.ThreadNumber);
        byte[] bytes = null;
        try
        {
            bytes = new byte[chunkSize];
            // Allocated all the memory needed for this workitem.// Now dispose of the MemoryFailPoint, then process the workitem.
            state.MemoryFailPoint.Dispose();
        }
        catch (OutOfMemoryException oom)
        {
            Console.Beep();
            Console.WriteLine("Unexpected OutOfMemory exception thrown: " + oom);
        }

        // Do work here, possibly taking a lock if this app needs // synchronization between worker threads and/or the main thread.// Keep the thread alive for awhile to simulate a running thread.
        Thread.Sleep(10000);

        // A real thread would use the byte[], but to be an illustrative sample,// explicitly keep the byte[] alive to help exhaust the memory.
        GC.KeepAlive(bytes);
        Console.WriteLine("Thread {0} is finished.", state.ThreadNumber);

    }
}


Quaisquer membros static (Shared no Visual Basic) públicos deste tipo são thread-safe. Não há garantia de que qualquer membro de instância seja thread-safe.

Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98

o.NET Framework e.NET Compact Framework não oferecem suporte a todas as versões de cada plataforma. Para obter uma lista de versões suportadas, consulte Requisitos de sistema do .NET framework.

.NET Framework

Compatível com: 3.5, 3.0, 2.0
Mostrar: