C# Schleife in zeitl. Abhängigkeit ausführen lassen

Timer t1 = new Timer();
t1.Interval = 500; // 500 ms = 0,5 Sekunden
t1.Tick+=new EventHandler(t1_Tick); //Diese Methode wird dann alle 0,5 Sekunden aufgerufen
t1.Start(); // Timer starten

int timerCount = 0;
void t1_Tick(object sender, EventArgs e)
{
   timerCount++;
   if (timerCount > 10) {
        t1.Stop(); //beendet den Timer nach 10 durchgängen (also 10 Sekunden)
        return;
   }

   //Hier dein Code zum auslesen des COM Values..
}

class blub
    {
        System.Windows.Threading.DispatcherTimer timer = new System.Windows.Threading.DispatcherTimer();

        public blub()
        {
            timer.Interval = TimeSpan.FromSeconds(0.1);
            timer.Tick += timer_Tick;
        }

        public void startTimer()
        {
            timer.Start();
        }

        int counter;
        void timer_Tick(object sender, EventArgs e)
        {
            counter++;
            if (counter == 10)
            {
                timer.Stop();
            }
            //todo
        }
    }

namespace YourNamespace
{
    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Linq;
    
    // .NET < 4.5: System.Runtime.CompilerServices entfernen
    using System.Runtime.CompilerServices;
    using System.Timers;

    internal sealed class MeasureEventArgs : EventArgs
    {
        public double Result { get; private set; }

        public MeasureEventArgs( double result )
        {
            Result = result;
        }
    }

    internal sealed class AverageTimeCalculator : INotifyPropertyChanged, IDisposable
    {
        #region Fields

        private readonly Timer _timer;

        private uint _iterations;

        private readonly List<double> _extensions;

        private double _average;

        private Func<double> _doMeasure;

        #endregion

        #region Constructor

        public AverageTimeCalculator()
        {
            _extensions = new List<double>();
            _timer = new Timer();
            _timer.Elapsed += OnTimerTick;
        }

        #endregion
        
        #region Events

        public delegate void MeasureEventhandler( object sender, MeasureEventArgs e );

        public event MeasureEventhandler Measured;

        public event PropertyChangedEventHandler PropertyChanged;

        #endregion

        #region Properties

        public double Average
        {
            get
            {
                return _average;
            }

            private set
            {
                if ( !_average.Equals( value ) )
                {
                    _average = value;

                    // .NET >= 4.5
                    RaisePropertyChanged();
                    
                    // .NET < 4.5
                    //RaisePropertyChanged( "Average" );
                }
            }
        }

        public bool IsActive { get { return _timer.Enabled; } }

        #endregion

        #region Public Methods

        public void Dispose()
        {
            if ( _timer.Enabled )
            {
                _timer.Stop();
            }

            _timer.Dispose();
        }

        public void Run( double interval, uint iterations, Func<double> measure )
        {
            if ( _timer.Enabled )
            {
                _extensions.Clear();
                Average = 0;
                _timer.Stop();
            }

            _doMeasure = measure;
            _timer.Interval = interval;
            _iterations = iterations;
            _timer.Start();

            RaisePropertyChanged( "IsActive" );
        }

        #endregion

        #region Methods

        private void OnTimerTick( object sender, ElapsedEventArgs e )
        {
            _extensions.Add( _doMeasure.Invoke() );
            Average = _extensions.Average();
            _iterations--;

            if ( _iterations < 1 )
            {
                _timer.Stop();
                RaiseMeasured( new MeasureEventArgs( Average ) );
                RaisePropertyChanged( "IsActive" );
            }
        }

        private void RaiseMeasured( MeasureEventArgs e )
        {
            MeasureEventhandler handler = Measured;
            if ( handler != null )
            {
                handler( this, e );
            }
        }

        // .NET < 4.5
        // public void RaisePropertyChanged( string propertyName )
        // .NET >= 4.5
        private void RaisePropertyChanged( [CallerMemberName] string propertyName = null )
        {
            PropertyChangedEventHandler handler = PropertyChanged;
            if ( handler != null )
            {
                PropertyChangedEventArgs e = new PropertyChangedEventArgs( propertyName );
                handler( this, e );
            }
        }

        #endregion
    }
}

public MainWindow()
{
    InitializeComponent();

    AverageTimeCalculator calculator = new AverageTimeCalculator();
    calculator.Measured += OnAverageReceived;
            
    // zwischenergebnis kann über calculator.Average abgefragt werden.


    Func<double> calculateAverage = () =>
                                        {
                                            double time = 0;
                                            // calculate time
                                            return time;
                                        };

    calculator.Run( 500, 10, calculateAverage );
}

private void OnAverageReceived( object sender, MeasureEventArgs e )
{
    double averageTime = e.Result;
    // average irgendwo anzeigen...
}