C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;

namespace howto_list_desktop_windows
{
    static class DesktopWindowsStuff
    {
        [DllImport("user32.dll")]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool IsWindowVisible(IntPtr hWnd);
         [DllImport("user32.dll")]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool IsIconic(IntPtr hWnd);
         [DllImport("user32.dll", EntryPoint = "GetWindowText",
        ExactSpelling = false, CharSet = CharSet.Auto, SetLastError = true)]
              private static extern int GetWindowText(IntPtr hWnd,
            StringBuilder lpWindowText, int nMaxCount);
        [DllImport("user32.dll", EntryPoint = "EnumDesktopWindows",
        ExactSpelling = false, CharSet = CharSet.Auto, SetLastError = true)]
        private static extern bool EnumDesktopWindows(IntPtr hDesktop,
            EnumDelegate lpEnumCallbackFunction, IntPtr lParam);
        // Define the callback delegate's type.
        private delegate bool EnumDelegate(IntPtr hWnd, int lParam);
        // Save window titles and handles in these lists.
        private static List<IntPtr> WindowHandles;
        private static List<string> WindowTitles;
        // Return a list of the desktop windows' handles and titles.
        public static void GetDesktopWindowHandlesAndTitles(
            out List<IntPtr> handles, out List<string> titles)
        {
            WindowHandles = new List<IntPtr>();
            WindowTitles = new List<string>();
            if (!EnumDesktopWindows(IntPtr.Zero, FilterCallback, IntPtr.Zero))
            {
                handles = null;
                titles = null;
            }
            else
            {
              //  handles = null;
              handles = WindowHandles;
              titles = WindowTitles;
            }
        }
        // We use this function to filter windows.
        // This version selects visible windows that have titles.
        private static bool FilterCallback(IntPtr hWnd, int lParam)
        {
            // Get the window's title.
            StringBuilder sb_title = new StringBuilder(1024);
            int length = GetWindowText(hWnd, sb_title, sb_title.Capacity);
            string title = sb_title.ToString();           
            // If the window is visible and has a title, save it.
            if (IsWindowVisible(hWnd) && string.IsNullOrEmpty(title) == false)
            {
           //exclude minimized windows
                if (IsIconic(hWnd) == false)
                { 
                    {
                        WindowHandles.Add(hWnd);
                        WindowTitles.Add(title);
                    }
                }
            }

            // Return true to indicate that we
            // should continue enumerating windows.
            return true;
        }
    }
}

    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();
            }
        }
    }

}