klaus_b@.NET

private void CheckSegment(object state)
{
    // den aufrufenden Timer als neue Instanz erzeugen.
    Timer stateTimer = (Timer)state;
    // den aktuellen Wert aus dem Schlüssel-Segment lesen
    int i = this.segment.GetStatus();
    // wenn Rückgabewert 1, würde das Objekt im
    // SharedMemory Segment geändert
    if (i == 1)
    {
        // prüfen ob autoAdjust aktiv ist
        if (this.autoAdjust)
        {
            // prüfen ob die stopWatch läuft.
            if (this.stopWatch.IsRunning)
            {
                // stopWatch anhalten
                this.stopWatch.Stop();
                // und die verstrichene Zeit in Millisekunden an die
                // Optimierungs-Methode übergeben
                this.OptimizeIntervall(this.stopWatch.ElapsedMilliseconds);
                // und die geänderte pollTime einstellen
                stateTimer.Change(0, this.pollTime);
            }
        }
        // das Objekt aus dem SharedMemory-Segment holen
        object data = this.segment.GetObject(true);
        // EventHandler initialisieren
        EventHandler<SharedMemoryNotificationEventArgs> handler = this.OnChanged;
        if (handler != null)
        {
            // Event auslösen
            handler(this, new SharedMemoryNotificationEventArgs(
                data, this.segment.SerializedObjectSize, this.pollTime));
        }
        // Änderung signalisieren
        this.hasChanged = true;
        // wenn autoAdjust aktiv
        if (this.autoAdjust)
        {
            // stopWatch rücksetzen und neu starten.
            this.stopWatch = Stopwatch.StartNew();
        }
    }
    else if (i == -1)
    {
        // Objekt nicht im Speicher vorhanden oder es kann nicht
        // darauf zugegriffen werden.
        // Den aufrufenden Timer zerstören
        stateTimer.Dispose();
        // Überwachung als beendet signalisieren
        this.watching = false;
        // Ausnahme auslösen
        throw new SharedMemoryException(
            "Auf das Schlüssel-Segment im Speicher kann nicht zugegriffen werden.");
    }
}

private void OptimizeIntervall(long intervall)
{
    // prüfen ob der Parameter intervall eine zulässige Größe aufweist.
    if (intervall > (long)int.MaxValue)
    {
        // intervall ist zu groß für einen int32-Wert.
        // auf den größtmöglichen Integerwert setzen.
        intervall = (long)int.MaxValue;
    }
    // intervall in einen int32-Wert casten.
    int tempTime = (int)intervall;
    // temporäre Polltime erstellen mit theoretisch 10 Abfragen
    // zwischen zwei erkannten Änderungen
    int tempPollTime = tempTime / 10;
    // prüfen ob der aktuelle Intervall größer als der minimale Intervall ist
    if (this.pollTime == minPollTime)
    {
        // aktuellen Intervall auf ermittelten Intervall setzen
        this.pollTime = tempPollTime;
    }
    // prüfen ob die temporäre Polltime kleiner als die aktuelle Polltime
    // und größer als der minimal erlaubte Intervall
    if (tempPollTime < this.pollTime && tempPollTime > minPollTime)
    {
        // tempPollTime ist kleiner, pollTime auf aktuellen Wert setzen.
        this.pollTime = tempPollTime;
        // prüfen wie oft der Intervall schon kleiner war
        // als die maxPollTime
        // Wenn der Intervall bereits 3 mal kleiner war,
        if (this.minTimeCounter >= 3)
        {
            // maxPollTime auf aktuellen Wert als neuen Vergleich setzen
            this.maxPollTime = tempPollTime;
            // Counter zurücksetzen
            this.minTimeCounter = 0;
        }
        else
        {
            // Counter erhöhen
            this.minTimeCounter++;
        }
    }
    // prüfen ob der aktuelle Intervall größer ist als
    // der größte gemessene Intervall.
    if (tempPollTime > this.maxPollTime)
    {
        // prüfen wie oft der Intervall schon größer war
        // als die maxPollTime.
        // Wenn der Intervall bereits 3 mal größer war,
        if (this.maxTimeCounter >= 3)
        {
            // maxPollTime auf aktuellen Wert als neuen Vergleich setzen
            this.maxPollTime = tempPollTime;
            // aktuelle pollTime auf aktuellen Wert setzen
            this.pollTime = tempPollTime;
            // Counter zurücksetzen
            this.maxTimeCounter = 0;
        }
        else
        {
            // Counter erhöhen
            this.maxTimeCounter++;
        }
    }
}