MemoryFailPoint MemoryFailPoint MemoryFailPoint MemoryFailPoint Class

Definition

Überprüfungen auf ausreichende Speicherressourcen, bevor ein Vorgang ausgeführt wird.Checks for sufficient memory resources before executing an operation. Diese Klasse kann nicht vererbt werden.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
Vererbung
Implementiert

Beispiele

MemoryFailPoint ermöglicht einer Anwendung, um zu vermeiden, dass der Speicher auf eine Beschädigung Weise langsamer.MemoryFailPoint enables an application to slow itself to avoid running out of memory in a corrupting manner. Es sollte in einen lexikalischen Gültigkeitsbereich verwendet werden.It should be used within a lexical scope. Im folgende Beispiel wird gestartet, Threads, um Elemente in eine Warteschlange zu verarbeiten.The following example launches threads to process items in a work queue. Vor jeder Thread gestartet wird, die verfügbaren Speicherressourcen werden überprüft, mit MemoryFailPoint.Before each thread is launched, the available memory resources are checked using MemoryFailPoint. Wenn eine Ausnahme ausgelöst wird, wartet die main-Methode erst Arbeitsspeicher verfügbar ist, bevor der nächste Thread gestartet.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);

    }
}

Hinweise

Hinweis

Diese Klasse ist für die erweiterte Entwicklung vorgesehen.This class is intended for use in advanced development.

Erstellen einer Instanz der MemoryFailPoint -Klasse erstellt ein Arbeitsspeicher-Gate.Creating an instance of the MemoryFailPoint class creates a memory gate. Ein Arbeitsspeicher-Gate überprüft über ausreichende Ressourcen vor dem Initiieren einer Aktivität, die eine große Menge an Arbeitsspeicher benötigt.A memory gate checks for sufficient resources before initiating an activity that requires a large amount of memory. Fehler bei der Überprüfung führt zu einer InsufficientMemoryException ausgelöste Ausnahme.Failing the check results in an InsufficientMemoryException exception being thrown. Diese Ausnahme wird verhindert, dass einen Vorgang gestartet wird, und verringert die Möglichkeit von Fehlern aufgrund von unzureichenden Ressourcen aufgetreten.This exception prevents an operation from being started and reduces the possibility of failure due to lack of resources. So können Sie beeinträchtigen die Leistung aus, um zu vermeiden einer OutOfMemoryException Ausnahme- und Beschädigungen Zustand, der durch nicht ordnungsgemäße Behandlung der Ausnahme an beliebigen Standorten in Ihrem Code entstehen kann.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.

Wichtig

Dieser Typ implementiert die IDisposable-Schnittstelle.This type implements the IDisposable interface. Nach Abschluss der Verwendung sollten Sie den Typ entweder direkt oder indirekt löschen.When you have finished using the type, you should dispose of it either directly or indirectly. Zum direkten Löschen des Typs rufen Sie seine Dispose-Methode in einem try/catch-Block auf.To dispose of the type directly, call its Dispose method in a try/catch block. Zum indirekten Löschen verwenden Sie ein Sprachkonstrukt wie using (in C#) oder Using (in Visual Basic).To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Weitere Informationen finden Sie im Abschnitt „Verwenden eines Objekts, das IDisposable implementiert“ des Themas „Die IDisposable-Schnittstelle“.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

Durch das Auslösen einer InsufficientMemoryException Ausnahme eine Anwendung kann unterscheiden, eine Schätzung, die ein Vorgang nicht abgeschlossen werden, oder ein teilweise abgeschlossenen Vorgang, der Zustand der Anwendung möglicherweise beschädigt.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. Dies ermöglicht einer Anwendung, damit weniger häufig eine eingeschränkte Eskalationsrichtlinie, was erfordern kann Entladen der aktuellen AppDomain oder recycling des Prozesses.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 überprüft, ob ausreichend Arbeitsspeicher und aufeinander folgende virtuelle Adressraum heaps in allen Garbagecollection verfügbar sind und können die Größe der Auslagerungsdatei erhöhen.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 keine Garantien in Bezug auf die langfristige Verfügbarkeit des Arbeitsspeichers während der Lebensdauer des Gate, aber das Aufrufer sollte immer verwendet die Dispose Methode, um sicherzustellen, dass die zugeordneten Ressourcen mit MemoryFailPoint freigegeben werden.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.

Um ein Arbeitsspeicher-Gate zu verwenden, müssen Sie erstellen eine MemoryFailPoint Objekt, und geben Sie die Anzahl der Megabytes (MB) des Arbeitsspeichers, der der nächste Vorgang verwenden soll.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. Wenn ausreichend Arbeitsspeicher nicht verfügbar ist, ist ein InsufficientMemoryException Ausnahme ausgelöst.If enough memory is not available, an InsufficientMemoryException exception is thrown.

Der Parameter des Konstruktors muss eine positive ganze Zahl sein.The parameter of the constructor must be a positive integer. Ein negativer Wert löst eine ArgumentOutOfRangeException Ausnahme.A negative value raises an ArgumentOutOfRangeException exception.

MemoryFailPoint arbeitet mit einer Granularität von 16 MB.MemoryFailPoint operates at a granularity of 16 MB. Alle Werte, die kleiner als 16 MB sind als 16 MB und andere Werte als das größte Vielfache von 16 MB behandelt werden.Any values smaller than 16 MB are treated as 16 MB, and other values are treated as the next largest multiple of 16 MB.

Konstruktoren

MemoryFailPoint(Int32) MemoryFailPoint(Int32) MemoryFailPoint(Int32) MemoryFailPoint(Int32)

Initialisiert eine neue Instanz der MemoryFailPoint-Klasse und gibt die zur erfolgreichen Ausführung erforderlichen Arbeitsspeichergröße an.Initializes a new instance of the MemoryFailPoint class, specifying the amount of memory required for successful execution.

Methoden

Dispose() Dispose() Dispose() Dispose()

Gibt alle vom MemoryFailPoint verwendeten Ressourcen frei.Releases all resources used by the MemoryFailPoint.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.Determines whether the specified object is equal to the current object.

(Inherited from Object)
Finalize() Finalize() Finalize() Finalize()

Stellt das Freigeben von Ressourcen und das Ausführen anderer Garbage Collector-Vorgänge sicher, wenn der Garbage Collector das MemoryFailPoint-Objekt verarbeitet.Ensures that resources are freed and other cleanup operations are performed when the garbage collector reclaims the MemoryFailPoint object.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fungiert als Standardhashfunktion.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.Returns a string that represents the current object.

(Inherited from Object)

Sicherheit

SecurityPermission
zum Aufrufen von nicht verwaltetem Code.for calling unmanaged code. Zugeordnete Enumeration: UnmanagedCodeAssociated enumeration: UnmanagedCode. Security-Aktion: LinkDemandSecurity action: LinkDemand

Gilt für: