C#

    textBox.Text = "";

    Thread.CurrentThread.Name = "UI Thread";

    IScheduler thread1 = new NewThreadScheduler(x => new Thread(x) { Name = "Thread1" });

    TimeSpan RetryMaxTime = new TimeSpan(0, 0, 0,0,5);
    Observable.Create<int>(o =>
    {
        Console.WriteLine("Created on " + Thread.CurrentThread.Name);
        o.OnNext(1);
        o.OnError(new Exception("Something random just happened"));
        o.OnCompleted();
        return Disposable.Create(() => { });
    })
    .SubscribeOn(thread1)
    .Retry(RetryMaxTime)
    .ObserveOnDispatcher()
    .Subscribe(
        x =>
        {
            textBox.Text += x.ToString() + Environment.NewLine;
        }
        , ex => textBox.Text += ex.Message
        , () => { textBox.Text += "Completed on " + Thread.CurrentThread.Name; }
        );
}

public static class MyExtensions
{

    public static IObservable<TItem> Retry<TItem>(this IObservable<TItem> collection,TimeSpan ExceptionTimeout)
    {
        return Observable.Create<TItem>(obs =>
        {
            var weakSubscription = new WeakSubscription<TItem>(collection, obs, ExceptionTimeout);
            return () =>
            {
                weakSubscription.Dispose();
            };
        });
    }

    public class WeakSubscription<T> : IDisposable, IObserver<T>
    {
        private readonly WeakReference reference;
        private readonly IDisposable subscription;
        private Exception LastError;
        private bool EndRetry = false;
        private bool disposed;

      private System.Windows.Threading.DispatcherTimer dispatcherTimer = new System.Windows.Threading.DispatcherTimer();

        public WeakSubscription(IObservable<T> observable, IObserver<T> observer, TimeSpan ExceptionTimeout)
        {
            this.reference = new WeakReference(observer);

            var interval = Observable.Interval(ExceptionTimeout);
            interval.SubscribeOn(Scheduler.CurrentThread).Subscribe(x =>
            EndRetry = true);
            this.subscription = observable.Retry()//.Subscribe(this);
                .Catch<T>(e=>e)
                //{
                    //LastError = error;
                  //  return Observable.Return("test");
                  //  })
            .Subscribe(this);

        }

        IObservable<T> ExceptionHappened(Exception ex)
        {
            return null;
        }

        void IObserver<T>.OnCompleted()
        {
            var observer = (IObserver<T>)this.reference.Target;
            if (observer != null)
                observer.OnCompleted();

            if (this.EndRetry)
                this.Dispose();

        }

        void IObserver<T>.OnError(Exception error)
        {
            var observer = (IObserver<T>)this.reference.Target;
            LastError = error;

            if (observer != null)
                observer.OnError(error);
            if (this.EndRetry)
                this.Dispose();
        }

        void IObserver<T>.OnNext(T value)
        {
            var observer = (IObserver<T>)this.reference.Target;

            if (observer != null)
                observer.OnNext(value);
            if (this.EndRetry)
                this.Dispose();

        }

        public void Dispose()
        {
            if (!this.disposed)
            {
                this.disposed = true;
                this.subscription.Dispose();
            }
        }
    }

}

private void pictureBox1_VisibleChanged(object sender, EventArgs e)
        {
            pictureBox1.SizeMode = PictureBoxSizeMode.StretchImage;
            

        }
       
        private void pictureBox1_Click(object sender, EventArgs e)
        {
            MouseEventArgs me = (MouseEventArgs)e;
            if (me.Button == System.Windows.Forms.MouseButtons.Right)
            {
                switch (clickProgress)
                {
                    case 1:
                        pts[2] = pts[0];
                        pts[1] = pts[0];
                        clickProgress--;
                        break;
                    case 2:
                        pts[2] = pts[0];
                        clickProgress--;
                        break;
                    case 3:
                        clickProgress--;
                        break;
                }
            }
            if (me.Button == System.Windows.Forms.MouseButtons.Left)
            {
                if (clickProgress < 3)
                {
                    pts[clickProgress] = me.Location;
                    if (clickProgress == 0)
                    {
                        pts[1] = pts[0];
                        pts[2] = pts[0];
                    }
                    clickProgress++;
                }
            }

            updateBitmap();
        }

        private void pictureBox1_MouseMove(object sender, MouseEventArgs e)
        {
            if (clickProgress > 0 && clickProgress < 3)
                pts[clickProgress] = e.Location;

            updateBitmap();
        }


        private void updateBitmap()
        {
            if (pictureBox1.Image == null)
            {
                Bitmap bmp = new Bitmap(pictureBox1.Width, pictureBox1.Height);
                
                pictureBox1.Image = bmp;
                
            }

            using (Graphics g = Graphics.FromImage(pictureBox1.Image))
            {
                g.Clear(Color.Black);
                
               
                if (pic != null)
                {
                    int width = pictureBox1.Width;
                    int height = pictureBox1.Height;

                    float scaleW = pictureBox1.Width * 1.0f / width;
                    float scaleH = pictureBox1.Height * 1.0f / height;
                    float scale = scaleW;
                    if (scale > scaleH)
                        scale = scaleH;

                    int nw = (int)(scale * width);
                    int nh = (int)(scale * height);

                    if (picScaled == null)
                    {
                        RectangleF sourceRect = new RectangleF(0, 0, width, height);
                        RectangleF destinationRect = new RectangleF(0, 0, nw, nh);
                        picScaled = new Bitmap(nw, nh);

                        Graphics gi = Graphics.FromImage(picScaled);
                        gi.DrawImage(
                            pic,
                            destinationRect,
                            sourceRect,
                            GraphicsUnit.Pixel);
                        gi.Dispose();
                    }
                    {
                        RectangleF sourceRect = new RectangleF(0, 0, nw, nh);

                        RectangleF destinationRect = new RectangleF(
                            pictureBox1.Width / 2 - nw / 2,
                            pictureBox1.Height / 2 - nh / 2,
                            nw,
                            nh);

                        g.DrawImage(
                            picScaled,
                            destinationRect,
                            sourceRect,
                            GraphicsUnit.Pixel);
                    }
                }

                Pen greenPen = new Pen(Brushes.Green);
                greenPen.Width = 3.0F;
                Pen redPen = new Pen(Brushes.Red);
                redPen.Width = 3.0F;

                if (clickProgress > 0)
                    g.DrawLine(greenPen, pts[0], pts[1]);

                if (clickProgress > 1)
                    g.DrawLine(redPen, pts[0], pts[2]);

                redPen.Dispose();
                greenPen.Dispose();
            }
            pictureBox1.Invalidate();

            if (clickProgress > 1)
            {

                Point p0 = new Point(pts[1].X - pts[0].X, pts[1].Y - pts[0].Y);
                Point p1 = new Point(pts[2].X - pts[0].X, pts[2].Y - pts[0].Y);

                ///make these doubles to not overflow
                double l0 = (p0.X * p0.X + p0.Y * p0.Y);
                double l1 = (p1.X * p1.X + p1.Y * p1.Y);

                double d = ((double)p0.X * p1.X + (double)p0.Y * p1.Y) / Math.Sqrt(l0 * l1);

                if (d > +1) d = +1;//limit against roundoff errors
                if (d < -1) d = -1;//limit against roundoff errors

                if (l0 > 0 && l1 > 0)
                    label1.Text = (Math.Acos(d) * 180 / Math.PI).ToString("0.0", System.Globalization.CultureInfo.InvariantCulture);
            }
            else
            {
                label1.Text = "";
            }
        }