C#

How to call the load runner (LR) controller from visual studio

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Diagnostics;

namespace Simple_BW_Timing_with_Winforms
{
    public partial class Form1 : Form
    {
        Stopwatch systemTimer;
        long time1 = 0, time2 = 0;
        public long timeBetweenCalls;
        int count;
        BackgroundWorker updateInfoBW;

        public delegate void _writeForm();

        public readonly MicroLibrary.MicroTimer _microTimer;
//        public BackgroundWorker updateInfoBW;

        public Form1()
        {
            updateInfoBW = new BackgroundWorker();
            updateInfoBW.DoWork += updateInfoDoWork;
            updateInfoBW.RunWorkerCompleted += updateInfoWorkCompleted;

            InitializeComponent();
            systemTimer = new Stopwatch();
            systemTimer.Start();

            _microTimer = new MicroLibrary.MicroTimer();
            _microTimer.MicroTimerElapsed +=
                new MicroLibrary.MicroTimer.MicroTimerElapsedEventHandler(tmrCallBW_tick);
            _microTimer.Interval = 20000;
            _microTimer.Start();


        }
        void tmrCallBW_tick(object sender, EventArgs e)
        {

            time1 = time2;
            time2 = systemTimer.ElapsedMilliseconds;
            timeBetweenCalls = time2 - time1;

            updateInfoBW.RunWorkerAsync();

// QUESTION - HOW CAN I GET updateInfoWorkCompleted to execute in the UI thread


        }


        void updateInfoDoWork(object sender, EventArgs e)
        {
            return;
        }

        void updateInfoWorkCompleted(object sender, EventArgs e)
        {
            count++;
            BeginInvoke((MethodInvoker)delegate
            {
                CallTime.Text = string.Format("{0}", timeBetweenCalls);
                CountBox.Text = string.Format("{0}", count);
            });
        }

        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            _microTimer.Abort();
        }

 
    }
}

<pre>using System;

namespace MicroLibrary
{
    /// <summary>
    /// MicroStopwatch class
    /// </summary>
    public class MicroStopwatch : System.Diagnostics.Stopwatch
    {
        readonly double _microSecPerTick =
            1000000D / System.Diagnostics.Stopwatch.Frequency;

        public MicroStopwatch()
        {
            if (!System.Diagnostics.Stopwatch.IsHighResolution)
            {
                throw new Exception("On this system the high-resolution " +
                                    "performance counter is not available");
            }
        }

        public long ElapsedMicroseconds
        {
            get
            {
                return (long)(ElapsedTicks * _microSecPerTick);
            }
        }
    }

    /// <summary>
    /// MicroTimer class
    /// </summary>
    public class MicroTimer
    {
        public delegate void MicroTimerElapsedEventHandler(
                             object sender,
                             MicroTimerEventArgs timerEventArgs);
        public event MicroTimerElapsedEventHandler MicroTimerElapsed;

        System.Threading.Thread _threadTimer = null;
        long _ignoreEventIfLateBy = long.MaxValue;
        long _timerIntervalInMicroSec = 0;
        bool _stopTimer = true;

        public MicroTimer()
        {
        }

        public MicroTimer(long timerIntervalInMicroseconds)
        {
            Interval = timerIntervalInMicroseconds;
        }

        public long Interval
        {
            get
            {
                return System.Threading.Interlocked.Read(
                    ref _timerIntervalInMicroSec);
            }
            set
            {
                System.Threading.Interlocked.Exchange(
                    ref _timerIntervalInMicroSec, value);
            }
        }

        public long IgnoreEventIfLateBy
        {
            get
            {
                return System.Threading.Interlocked.Read(
                    ref _ignoreEventIfLateBy);
            }
            set
            {
                System.Threading.Interlocked.Exchange(
                    ref _ignoreEventIfLateBy, value <= 0 ? long.MaxValue : value);
            }
        }

        public bool Enabled
        {
            set
            {
                if (value)
                {
                    Start();
                }
                else
                {
                    Stop();
                }
            }
            get
            {
                return (_threadTimer != null && _threadTimer.IsAlive);
            }
        }

        public void Start()
        {
            if (Enabled || Interval <= 0)
            {
                return;
            }

            _stopTimer = false;

            System.Threading.ThreadStart threadStart = delegate()
            {
                NotificationTimer(ref _timerIntervalInMicroSec,
                                  ref _ignoreEventIfLateBy,
                                  ref _stopTimer);
            };

            _threadTimer = new System.Threading.Thread(threadStart);
            _threadTimer.Priority = System.Threading.ThreadPriority.Highest;
            _threadTimer.Start();
        }

        public void Stop()
        {
            _stopTimer = true;
        }

        public void StopAndWait()
        {
            StopAndWait(System.Threading.Timeout.Infinite);
        }

        public bool StopAndWait(int timeoutInMilliSec)
        {
            _stopTimer = true;

            if (!Enabled || _threadTimer.ManagedThreadId ==
                System.Threading.Thread.CurrentThread.ManagedThreadId)
            {
                return true;
            }

            return _threadTimer.Join(timeoutInMilliSec);
        }

        public void Abort()
        {
            _stopTimer = true;

            if (Enabled)
            {
                _threadTimer.Abort();
            }
        }

        void NotificationTimer(ref long timerIntervalInMicroSec,
                               ref long ignoreEventIfLateBy,
                               ref bool stopTimer)
        {
            int  timerCount = 0;
            long nextNotification = 0;

            MicroStopwatch microStopwatch = new MicroStopwatch();
            microStopwatch.Start();

            while (!stopTimer)
            {
                long callbackFunctionExecutionTime =
                    microStopwatch.ElapsedMicroseconds - nextNotification;

                long timerIntervalInMicroSecCurrent =
                    System.Threading.Interlocked.Read(ref timerIntervalInMicroSec);
                long ignoreEventIfLateByCurrent =
                    System.Threading.Interlocked.Read(ref ignoreEventIfLateBy);

                nextNotification += timerIntervalInMicroSecCurrent;
                timerCount++;
                long elapsedMicroseconds = 0;

                while ( (elapsedMicroseconds = microStopwatch.ElapsedMicroseconds)
                        < nextNotification)
                {
                    System.Threading.Thread.SpinWait(10);
                }

                long timerLateBy = elapsedMicroseconds - nextNotification;

                if (timerLateBy >= ignoreEventIfLateByCurrent)
                {
                    continue;
                }

                MicroTimerEventArgs microTimerEventArgs =
                     new MicroTimerEventArgs(timerCount,
                                             elapsedMicroseconds,
                                             timerLateBy,
                                             callbackFunctionExecutionTime);
                MicroTimerElapsed(this, microTimerEventArgs);
            }

            microStopwatch.Stop();
        }
    }

    /// <summary>
    /// MicroTimer Event Argument class
    /// </summary>
    public class MicroTimerEventArgs : EventArgs
    {
        // Simple counter, number times timed event (callback function) executed
        public int  TimerCount { get; private set; }

        // Time when timed event was called since timer started
        public long ElapsedMicroseconds { get; private set; }

        // How late the timer was compared to when it should have been called
        public long TimerLateBy { get; private set; }

        // Time it took to execute previous call to callback function (OnTimedEvent)
        public long CallbackFunctionExecutionTime { get; private set; }

        public MicroTimerEventArgs(int  timerCount,
                                   long elapsedMicroseconds,
                                   long timerLateBy,
                                   long callbackFunctionExecutionTime)
        {
            TimerCount = timerCount;
            ElapsedMicroseconds = elapsedMicroseconds;
            TimerLateBy = timerLateBy;
            CallbackFunctionExecutionTime = callbackFunctionExecutionTime;
        }
    }
}

public class ClipboardMetafileHelper
   {
       [DllImport("user32.dll", EntryPoint = "OpenClipboard", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
       public static extern bool OpenClipboard(IntPtr hWnd);
       [DllImport("user32.dll", EntryPoint = "EmptyClipboard", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
       public static extern bool EmptyClipboard();
       [DllImport("user32.dll", EntryPoint = "SetClipboardData", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
       public static extern IntPtr SetClipboardData(int uFormat, IntPtr hWnd);
       [DllImport("user32.dll", EntryPoint = "GetClipboardData", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
       public static extern IntPtr GetClipboardData(int uFormat);
       [DllImport("user32.dll", EntryPoint = "CloseClipboard", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
       public static extern bool CloseClipboard();
       [DllImport("gdi32.dll", EntryPoint = "CopyEnhMetaFileA", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
       public static extern IntPtr CopyEnhMetaFile(IntPtr hemfSrc, IntPtr hNULL);
       [DllImport("gdi32.dll", EntryPoint = "DeleteEnhMetaFile", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
       public static extern bool DeleteEnhMetaFile(IntPtr hemfSrc);

       // Metafile mf is set to a state that is not valid inside this function.
       public static bool PutEnhMetafileOnClipboard(IntPtr hWnd, Metafile mf)
       {
           bool bResult = new bool();
           bResult = false;
           IntPtr hEMF = default(IntPtr);
           IntPtr hEMF2 = default(IntPtr);
           hEMF = mf.GetHenhmetafile();
           // invalidates mf
           if (!hEMF.Equals(new IntPtr(0)))
           {
               hEMF2 = CopyEnhMetaFile(hEMF, new IntPtr(0));
               if (!hEMF2.Equals(new IntPtr(0)))
               {
                   if (OpenClipboard(hWnd))
                   {
                       if (EmptyClipboard())
                       {
                           IntPtr hRes = default(IntPtr);
                           hRes = SetClipboardData(14, hEMF2);
                           // 14 == CF_ENHMETAFILE
                           bResult = hRes.Equals(hEMF2);
                           CloseClipboard();
                       }
                   }
               }
               DeleteEnhMetaFile(hEMF);
           }
           return bResult;
       }

       public static Image GetEnhMetafileFromClipboard(IntPtr hWnd)
       {
           OpenClipboard(hWnd);
           // IntPtr.Zero
           IntPtr hemf = GetClipboardData(14);
           // 14 == CF_ENHMETAFILE
           CloseClipboard();
           if (hemf != IntPtr.Zero)
           {
               Metafile mf = new Metafile(hemf, true);
               Bitmap b = new Bitmap(mf.Width, mf.Height);
               Graphics g = Graphics.FromImage(b);
               g.FillRectangle(Brushes.White, 0, 0, 1000, 1000);
               GraphicsUnit unit = GraphicsUnit.Millimeter;
               RectangleF rsrc = mf.GetBounds(ref unit);
               g.DrawImage(mf, new Rectangle(0, 0, mf.Width, mf.Height), rsrc, unit);
               return b;
           }


           return null;
       }


   }