MemoryFailPoint Classe

Definizione

Verifica la disponibilità di risorse di memoria sufficienti prima di eseguire un'operazione.Checks for sufficient memory resources before executing an operation. Questa classe non può essere ereditata.This class cannot be inherited.

public ref class MemoryFailPoint sealed : System::Runtime::ConstrainedExecution::CriticalFinalizerObject, IDisposable
public sealed class MemoryFailPoint : System.Runtime.ConstrainedExecution.CriticalFinalizerObject, IDisposable
type MemoryFailPoint = class
    inherit CriticalFinalizerObject
    interface IDisposable
Public NotInheritable Class MemoryFailPoint
Inherits CriticalFinalizerObject
Implements IDisposable
Ereditarietà
Implementazioni

Esempi

MemoryFailPoint consente a un'applicazione di rallentarsi per evitare di esaurire la memoria in modo danneggiato.MemoryFailPoint enables an application to slow itself to avoid running out of memory in a corrupting manner. Deve essere usato in un ambito lessicale.It should be used within a lexical scope. Nell'esempio seguente vengono avviati i thread per elaborare gli elementi in una coda di lavoro.The following example launches threads to process items in a work queue. Prima dell'avvio di ogni thread, le risorse di memoria disponibili vengono controllate utilizzando MemoryFailPoint.Before each thread is launched, the available memory resources are checked using MemoryFailPoint. Se viene generata un'eccezione, il metodo Main attende che la memoria sia disponibile prima di avviare il thread successivo.If an exception is thrown, the main method waits until memory is available before launching the next thread.

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.
    private const uint chunkSize = 64 << 20;
    // Use more than the total user-available address space (on 32 bit machines)
    // to drive towards getting an InsufficientMemoryException.
    private const 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.
    private static int 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;
    }

    static void 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.
    static void ThreadMethod()
    {
        byte[] bytes = new byte[chunkSize];
    }

    internal class WorkerState
    {
        internal int _threadNumber;
        internal MemoryFailPoint _memFailPoint;

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

        internal int ThreadNumber
        {
            get { return _threadNumber; }
        }

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

    // The method that does the work.
    static void 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);

    }
}

Commenti

Nota

Questa classe è destinata all'uso nello sviluppo avanzato.This class is intended for use in advanced development.

Creando un'istanza della classe MemoryFailPoint viene creato un controllo di memoria.Creating an instance of the MemoryFailPoint class creates a memory gate. Un controllo di memoria Cerca risorse sufficienti prima di avviare un'attività che richiede una grande quantità di memoria.A memory gate checks for sufficient resources before initiating an activity that requires a large amount of memory. Se il controllo ha esito negativo, viene generata un'eccezione InsufficientMemoryException.Failing the check results in an InsufficientMemoryException exception being thrown. Questa eccezione impedisce l'avvio di un'operazione e riduce la possibilità di errore a causa di risorse insufficienti.This exception prevents an operation from being started and reduces the possibility of failure due to lack of resources. Ciò consente di ridurre le prestazioni per evitare un'eccezione OutOfMemoryException e qualsiasi danneggiamento dello stato che potrebbe derivare dalla gestione non corretta dell'eccezione in posizioni arbitrarie nel codice.This enables you decrease performance to avoid an OutOfMemoryException exception and any state corruption that may result from improper handling of the exception in arbitrary locations in your code.

Importante

Il tipo implementa l'interfaccia IDisposable.This type implements the IDisposable interface. Dopo aver utilizzato il tipo, è necessario eliminarlo direttamente o indirettamente.When you have finished using the type, you should dispose of it either directly or indirectly. Per eliminare direttamente il tipo, chiamare il metodo Dispose in un blocco try/catch.To dispose of the type directly, call its Dispose method in a try/catch block. Per eliminarlo indirettamente, utilizzare un costrutto di linguaggio come ad esempio using in C# o Using in Visual Basic.To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Per altre informazioni, vedere la sezione "Uso di un oggetto che implementa IDisposable" nell'argomento relativo all'interfaccia IDisposable.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

Generando un'eccezione InsufficientMemoryException, un'applicazione può distinguere tra una stima che non sarà possibile completare un'operazione e un'operazione parzialmente completata che potrebbe aver danneggiato lo stato dell'applicazione.By throwing an InsufficientMemoryException exception, an application can distinguish between an estimate that an operation will not be able to complete and a partially completed operation that may have corrupted the application state. Questo consente a un'applicazione di ridurre la frequenza dei criteri di escalation pessimistici, che possono richiedere lo scaricamento del AppDomain corrente o il riciclo del processo.This allows an application to reduce the frequency of a pessimistic escalation policy, which may require unloading the current AppDomain or recycling the process.

MemoryFailPoint verifica se la memoria sufficiente e lo spazio degli indirizzi virtuali consecutivi sono disponibili in tutti gli heap Garbage Collection e possono aumentare le dimensioni del file di scambio.MemoryFailPoint checks to see whether sufficient memory and consecutive virtual address space are available in all garbage collection heaps, and may increase the size of the swap file. MemoryFailPoint non offre alcuna garanzia relativa alla disponibilità a lungo termine della memoria durante il ciclo di vita del controllo, ma i chiamanti devono sempre usare il metodo Dispose per assicurarsi che le risorse associate a MemoryFailPoint vengano rilasciate.MemoryFailPoint makes no guarantees regarding the long-term availability of the memory during the lifetime of the gate, but callers should always use the Dispose method to ensure that resources associated with MemoryFailPoint are released.

Per utilizzare un controllo di memoria, è necessario creare un oggetto MemoryFailPoint e specificare il numero di megabyte (MB) di memoria che verrà utilizzata dall'operazione successiva.To use a memory gate, you must create a MemoryFailPoint object and specify the number of megabytes (MB) of memory that the next operation is expected to use. Se non è disponibile memoria sufficiente, viene generata un'eccezione InsufficientMemoryException.If enough memory is not available, an InsufficientMemoryException exception is thrown.

Il parametro del costruttore deve essere un numero intero positivo.The parameter of the constructor must be a positive integer. Un valore negativo genera un'eccezione ArgumentOutOfRangeException.A negative value raises an ArgumentOutOfRangeException exception.

MemoryFailPoint funziona a una granularità di 16 MB.MemoryFailPoint operates at a granularity of 16 MB. Qualsiasi valore inferiore a 16 MB viene considerato come 16 MB e gli altri valori vengono considerati come il successivo multiplo più grande di 16 MB.Any values smaller than 16 MB are treated as 16 MB, and other values are treated as the next largest multiple of 16 MB.

Costruttori

MemoryFailPoint(Int32)

Inizializza una nuova istanza della classe MemoryFailPoint, specificando la quantità di memoria richiesta per il completamento dell'esecuzione.Initializes a new instance of the MemoryFailPoint class, specifying the amount of memory required for successful execution.

Metodi

Dispose()

Rilascia tutte le risorse usate da MemoryFailPoint.Releases all resources used by the MemoryFailPoint.

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Ereditato da Object)
Finalize()

Garantisce che le risorse vengano liberate e che vengano eseguite le altre operazioni di pulizia quando l'oggetto MemoryFailPoint viene recuperato da Garbage Collector.Ensures that resources are freed and other cleanup operations are performed when the garbage collector reclaims the MemoryFailPoint object.

GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Ereditato da Object)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Ereditato da Object)

Sicurezza

SecurityPermission
per la chiamata di codice non gestito.for calling unmanaged code. Enumerazione associata: UnmanagedCode.Associated enumeration: UnmanagedCode. Azione di sicurezza: LinkDemandSecurity action: LinkDemand

Si applica a