WebBrowserUtil

using mshtml;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Threading;

namespace ConsoleApplication8
{
    class WebBrowserUtil
    {
        public static TimeSpan DefaultConfig_BrowserLoadTimeout = TimeSpan.FromSeconds(30);
        public static TimeSpan DefaultConfig_BrowserRenderTime = TimeSpan.FromSeconds(5);
        public static TimeSpan DefaultConfig_SyncContextPostCheckInterval = TimeSpan.FromMilliseconds(10);
        public static TimeSpan DefaultConfig_ActiveXInstanceInitTime = TimeSpan.FromMilliseconds(200);

        public enum WebBrowserTypeEnum { Forms, Wpf }
        public class WebBrowserContext : IDisposable
        {
            private Thread StaThread { get; set; }

            public WebBrowserTypeEnum WebBrowserType { get; private set; }
            public SynchronizationContext SyncContext { get; set; }

            private object WebBrowser { get; set; }
            public System.Windows.Forms.WebBrowser GetWebBrowserAsFormsType()
            {
                EnsureWebBrowserType(WebBrowserTypeEnum.Forms);
                return WebBrowser as System.Windows.Forms.WebBrowser;
            }
            public System.Windows.Controls.WebBrowser GetWebBrowserAsWpfType()
            {
                EnsureWebBrowserType(WebBrowserTypeEnum.Wpf);
                return WebBrowser as System.Windows.Controls.WebBrowser;
            }

            public WebBrowserContext(WebBrowserTypeEnum browserType)
            {
                WebBrowserType = browserType;
                switch (browserType)
                {
                    case WebBrowserTypeEnum.Forms:
                        {
                            StaThread = new Thread(() =>
                            {
                                SynchronizationContext.SetSynchronizationContext(new DispatcherSynchronizationContext(Dispatcher.CurrentDispatcher));
                                SyncContext = SynchronizationContext.Current;
                                System.Windows.Forms.Application.Run();
                            });
                            StaThread.SetApartmentState(ApartmentState.STA);
                            StaThread.IsBackground = true;
                            StaThread.Start();
                            while (null == SyncContext) Thread.Sleep(DefaultConfig_SyncContextPostCheckInterval);
                            SyncContext.Post(state => { WebBrowser = new System.Windows.Forms.WebBrowser(); }, null);
                            while (null == WebBrowser) Thread.Sleep(DefaultConfig_SyncContextPostCheckInterval);
                        }
                        break;

                    case WebBrowserTypeEnum.Wpf:
                        {
                            StaThread = new Thread(() =>
                            {
                                SynchronizationContext.SetSynchronizationContext(new DispatcherSynchronizationContext(Dispatcher.CurrentDispatcher));
                                SyncContext = SynchronizationContext.Current;
                                new System.Windows.Application().Run();
                            });
                            StaThread.SetApartmentState(ApartmentState.STA);
                            StaThread.IsBackground = true;
                            StaThread.Start();
                            while (null == SyncContext) Thread.Sleep(DefaultConfig_SyncContextPostCheckInterval);
                            SyncContext.Post(state =>
                            {
                                WebBrowser = new System.Windows.Controls.WebBrowser();
                                var window = new System.Windows.Window();
                                window.Content = WebBrowser;
                                window.Visibility = System.Windows.Visibility.Hidden;
                                window.Show();
                            }, null);
                            while (null == WebBrowser) Thread.Sleep(DefaultConfig_SyncContextPostCheckInterval);
                        }
                        break;

                    default: throw new ArgumentException("unknown browser type", browserType.ToString());
                }
            }

            private void EnsureWebBrowserType(WebBrowserTypeEnum browserType) { if (browserType != WebBrowserType) throw new ArgumentException(string.Format("web browser is of [{0}] type", WebBrowserType.ToString())); }

            public void Dispose()
            {
                switch (WebBrowserType)
                {
                    case WebBrowserTypeEnum.Forms:
                        SyncContext.Post(state => System.Windows.Forms.Application.ExitThread(), null);
                        break;

                    case WebBrowserTypeEnum.Wpf:
                        SyncContext.Post(state => System.Windows.Application.Current.Shutdown(), null);
                        break;

                    default: throw new ArgumentException("unknown browser type", WebBrowserType.ToString());
                }
            }
        }

        #region GetActiveXInstance
        public static object GetActiveXInstance(WebBrowserContext browserContext)
        {
            object axi = null;
            var finished = false;
            switch (browserContext.WebBrowserType)
            {
                case WebBrowserTypeEnum.Forms:
                    {
                        var browser = browserContext.GetWebBrowserAsFormsType();
                        browserContext.SyncContext.Post(state =>
                        {
                            axi = GetActiveXInstance(browser);
                            finished = true;
                        }, null);
                    }
                    break;

                case WebBrowserTypeEnum.Wpf:
                    {
                        var browser = browserContext.GetWebBrowserAsWpfType();
                        browserContext.SyncContext.Post(state =>
                        {
                            axi = GetActiveXInstance(browser);
                            finished = true;
                        }, null);
                    }
                    break;

                default: throw new ArgumentException("unknown browser type", browserContext.WebBrowserType.ToString());
            }
            while (!finished) Thread.Sleep(DefaultConfig_SyncContextPostCheckInterval);

            return axi;
        }
        public static object GetActiveXInstance(System.Windows.Forms.WebBrowser browser) { return browser.ActiveXInstance; }
        public static object GetActiveXInstance(System.Windows.Controls.WebBrowser browser) { return GetActiveXInstance_ByProperty(browser); }
        private static object GetActiveXInstance_ByProperty(System.Windows.Controls.WebBrowser browser)
        {
            var propertyName = "ActiveXInstance";
            var axiPi = typeof(System.Windows.Controls.WebBrowser).GetProperty(propertyName, BindingFlags.Instance | BindingFlags.NonPublic);
            if (null == axiPi) throw new ArgumentException("failed to get property info of WebBrowser", propertyName);

            var axi = axiPi.GetValue(browser, null);
            return axi;
        }
        private static object GetActiveXInstance_ByField(System.Windows.Controls.WebBrowser browser)
        {
            var fieldName = "_axIWebBrowser2";
            var fiComWebBrowser = typeof(System.Windows.Controls.WebBrowser).GetField(fieldName, BindingFlags.Instance | BindingFlags.NonPublic);
            if (fiComWebBrowser == null) throw new ArgumentException("failed to get field info of WebBrowser", fieldName);

            var objComWebBrowser = fiComWebBrowser.GetValue(browser);
            return objComWebBrowser;
        }
        #endregion

        #region GetDocumentHtml
        public static string GetDocumentHtml(WebBrowserContext browserContext)
        {
            string docHtml = null;
            var finished = false;
            switch (browserContext.WebBrowserType)
            {
                case WebBrowserTypeEnum.Forms:
                    {
                        var browser = browserContext.GetWebBrowserAsFormsType();
                        browserContext.SyncContext.Post(state =>
                        {
                            docHtml = GetDocumentHtml(browser);
                            finished = true;
                        }, null);
                    }
                    break;

                case WebBrowserTypeEnum.Wpf:
                    {
                        var browser = browserContext.GetWebBrowserAsWpfType();
                        browserContext.SyncContext.Post(state =>
                        {
                            docHtml = GetDocumentHtml(browser);
                            finished = true;
                        }, null);
                    }
                    break;

                default: throw new ArgumentException("unknown browser type", browserContext.WebBrowserType.ToString());
            }
            while (!finished) Thread.Sleep(DefaultConfig_SyncContextPostCheckInterval);

            return docHtml;
        }
        public static string GetDocumentHtml(System.Windows.Forms.WebBrowser browser)
        {
            var doc = (IHTMLDocument3)browser.Document.DomDocument;
            return GetDocumentHtml(doc);
        }
        public static string GetDocumentHtml(System.Windows.Controls.WebBrowser browser)
        {
            var doc = (IHTMLDocument3)browser.Document;
            return GetDocumentHtml(doc);
        }
        private static string GetDocumentHtml(IHTMLDocument3 document)
        {
            if (null == document) return null;
            else if (null == document.documentElement) return null;
            else return document.documentElement.outerHTML;
        }
        #endregion

        #region SuppressScriptErrors
        public static void SuppressScriptErrors(WebBrowserContext browserContext, bool suppress)
        {
            ForceInitActiveXInstance(browserContext);

            var finished = false;
            switch (browserContext.WebBrowserType)
            {
                case WebBrowserTypeEnum.Forms:
                    {
                        var browser = browserContext.GetWebBrowserAsFormsType();
                        browserContext.SyncContext.Post(state =>
                        {
                            SuppressScriptErrors(browser, suppress);
                            finished = true;
                        }, null);
                    }
                    break;

                case WebBrowserTypeEnum.Wpf:
                    {
                        var browser = browserContext.GetWebBrowserAsWpfType();
                        browserContext.SyncContext.Post(state =>
                        {
                            SuppressScriptErrors(browser, suppress);
                            finished = true;
                        }, null);
                    }
                    break;

                default: throw new ArgumentException("unknown browser type", browserContext.WebBrowserType.ToString());
            }
            while (!finished) Thread.Sleep(DefaultConfig_SyncContextPostCheckInterval);
        }
        public static void SuppressScriptErrors(System.Windows.Forms.WebBrowser browser, bool suppress)
        {
            browser.ScriptErrorsSuppressed = suppress;
        }
        public static void SuppressScriptErrors(System.Windows.Controls.WebBrowser browser, bool suppress)
        {
            var objComWebBrowser = GetActiveXInstance(browser);
            if (objComWebBrowser == null)
            {
                browser.Loaded += (o, s) => SuppressScriptErrors(browser, suppress);        // in case we are too early
                return;
            }
            objComWebBrowser.GetType().InvokeMember("Silent", BindingFlags.SetProperty, null, objComWebBrowser, new object[] { suppress });
        }
        #endregion

        #region BlockNewWindows
        public static void BlockNewWindows(WebBrowserContext browserContext, bool block)
        {
            ForceInitActiveXInstance(browserContext);

            var finished = false;
            switch (browserContext.WebBrowserType)
            {
                case WebBrowserTypeEnum.Forms:
                    {
                        var browser = browserContext.GetWebBrowserAsFormsType();
                        browserContext.SyncContext.Post(state =>
                        {
                            BlockNewWindows(browser, block);
                            finished = true;
                        }, null);
                    }
                    break;

                case WebBrowserTypeEnum.Wpf:
                    {
                        var browser = browserContext.GetWebBrowserAsWpfType();
                        browserContext.SyncContext.Post(state =>
                        {
                            BlockNewWindows(browser, block);
                            finished = true;
                        }, null);
                    }
                    break;

                default: throw new ArgumentException("unknown browser type", browserContext.WebBrowserType.ToString());
            }
            while (!finished) Thread.Sleep(DefaultConfig_SyncContextPostCheckInterval);
        }

        public static void BlockNewWindows(System.Windows.Forms.WebBrowser browser, bool block)
        {
            if (block) browser.NewWindow += OnNewWindow;
            else browser.NewWindow -= OnNewWindow;
        }
        private static void OnNewWindow(object sender, System.ComponentModel.CancelEventArgs e) { e.Cancel = true; }

        public static void BlockNewWindows(System.Windows.Controls.WebBrowser browser, bool block)
        {
            var axi = GetActiveXInstance(browser);
            if (null == axi)
            {
                browser.Loaded += (o, s) => BlockNewWindows(browser, block);        // in case we are too early
                return;
            }

            var iwb = axi as SHDocVw.IWebBrowser2;
            if (null == iwb) throw new ArgumentException("failed to cast WebBrowser to IWebBrowser2");

            var wbEvents = iwb as SHDocVw.DWebBrowserEvents_Event;
            if (null == wbEvents) throw new ArgumentException("failed to cast IWebBrowser2 to DWebBrowserEvents_Event");

            var wbEvents2 = iwb as SHDocVw.DWebBrowserEvents2_Event;
            if (null == wbEvents2) throw new ArgumentException("failed to cast IWebBrowser2 to DWebBrowserEvents2_Event");

            if (block)
            {
                wbEvents.NewWindow += OnNewWindow;
                wbEvents2.NewWindow2 += OnNewWindow2;
                wbEvents2.NewWindow3 += OnNewWindow3;
            }
            else
            {
                wbEvents.NewWindow -= OnNewWindow;
                wbEvents2.NewWindow2 -= OnNewWindow2;
                wbEvents2.NewWindow3 -= OnNewWindow3;
            }
        }
        private static void OnNewWindow(string url, int flags, string targetFrameName, ref object postData, string headers, ref bool processed) { processed = true; }
        private static void OnNewWindow2(ref object ppDisp, ref bool cancel) { cancel = true; }
        private static void OnNewWindow3(ref object ppDisp, ref bool cancel, uint flags, string urlContext, string url) { cancel = true; }
        #endregion

        #region DisableFileDownload
        public static void DisableFileDownload(WebBrowserContext browserContext, bool disable)
        {
            ForceInitActiveXInstance(browserContext);

            var finished = false;
            switch (browserContext.WebBrowserType)
            {
                case WebBrowserTypeEnum.Forms:
                    {
                        var browser = browserContext.GetWebBrowserAsFormsType();
                        browserContext.SyncContext.Post(state =>
                        {
                            DisableFileDownload(browser, disable);
                            finished = true;
                        }, null);
                    }
                    break;

                case WebBrowserTypeEnum.Wpf:
                    {
                        var browser = browserContext.GetWebBrowserAsWpfType();
                        browserContext.SyncContext.Post(state =>
                        {
                            DisableFileDownload(browser, disable);
                            finished = true;
                        }, null);
                    }
                    break;

                default: throw new ArgumentException("unknown browser type", browserContext.WebBrowserType.ToString());
            }
            while (!finished) Thread.Sleep(DefaultConfig_SyncContextPostCheckInterval);
        }
        public static void DisableFileDownload(System.Windows.Forms.WebBrowser browser, bool disable)
        {
            var axi = GetActiveXInstance(browser);
            DisableFileDownload(axi, disable);
        }
        public static void DisableFileDownload(System.Windows.Controls.WebBrowser browser, bool disable)
        {
            var axi = GetActiveXInstance_ByProperty(browser);
            if (null == axi)
            {
                browser.Loaded += (o, s) => DisableFileDownload(browser, disable);        // in case we are too early
                return;
            }

            DisableFileDownload(axi, disable);
        }
        private static void DisableFileDownload(object activexInstance, bool disable)
        {
            var iwb = activexInstance as SHDocVw.IWebBrowser2;
            if (null == iwb) throw new ArgumentException("failed to cast WebBrowser to IWebBrowser2");

            var wbEvents2 = iwb as SHDocVw.DWebBrowserEvents2_Event;
            if (null == wbEvents2) throw new ArgumentException("failed to cast IWebBrowser2 to DWebBrowserEvents2_Event");

            if (disable)
            {
                wbEvents2.FileDownload += OnFileDownload;
            }
            else
            {
                wbEvents2.FileDownload -= OnFileDownload;
            }
        }
        static void OnFileDownload(bool activeDocument, ref bool cancel) { cancel = true; }
        #endregion

        #region DoEvents *do NOT use these methods anymore*
        public static void DoEvents(System.Windows.Forms.WebBrowser browser) { DoEvents(); }
        public static void DoEvents(System.Windows.Controls.WebBrowser browser) { DoEvents(); }
        private static void DoEvents()      // do NOT use this function anymore because it creates weird problems
        {
            var frame = new DispatcherFrame();
            Dispatcher.CurrentDispatcher.BeginInvoke(DispatcherPriority.Background,
                new DispatcherOperationCallback(ExitFrame), frame);
            Dispatcher.PushFrame(frame);
        }
        private static object ExitFrame(object f)
        {
            ((DispatcherFrame)f).Continue = false;

            return null;
        }
        #endregion

        #region NavigateLoadAndRender
        public static bool NavigateLoadAndRender(WebBrowserContext browserContext, string url) { string errMsg; return NavigateLoadAndRender(browserContext, url, out errMsg); }
        public static bool NavigateLoadAndRender(WebBrowserContext browserContext, string url, TimeSpan loadTimeout, TimeSpan renderTime)
        {
            string errMsg = null;
            return NavigateLoadAndRender(browserContext, url, loadTimeout, renderTime, out errMsg);
        }
        public static bool NavigateLoadAndRender(WebBrowserContext browserContext, string url, out string errMsg)
        {
            return NavigateLoadAndRender(browserContext, url,
                DefaultConfig_BrowserLoadTimeout,
                DefaultConfig_BrowserRenderTime,
                out errMsg);
        }
        public static bool NavigateLoadAndRender(WebBrowserContext browserContext, string url, TimeSpan loadTimeout, TimeSpan renderTime, out string errMsg)
        {
            ForceInitActiveXInstance(browserContext);

            object axi = null;
            Func<Uri> getBrowserUri = null;
            Action<Uri> navigateBrowser = null;
            Func<IHTMLDocument2> getBrowserDoc = null;
            switch (browserContext.WebBrowserType)
            {
                case WebBrowserTypeEnum.Forms:
                    {
                        var browser = browserContext.GetWebBrowserAsFormsType();
                        getBrowserUri = () => browser.Url;
                        navigateBrowser = u =>
                        {
                            var finished = false;
                            browserContext.SyncContext.Post(state =>
                            {
                                browser.Navigate(u);
                                finished = true;
                            }, null);
                            while (!finished) Thread.Sleep(DefaultConfig_SyncContextPostCheckInterval);
                        };
                        getBrowserDoc = () =>
                        {
                            IHTMLDocument2 doc = null;
                            bool finished = false;
                            browserContext.SyncContext.Post(state =>
                            {
                                doc = (IHTMLDocument2)browser.Document.DomDocument;
                                finished = true;
                            }, null);
                            while (!finished) Thread.Sleep(DefaultConfig_SyncContextPostCheckInterval);

                            return doc;
                        };
                        axi = GetActiveXInstance(browserContext);
                    }
                    break;

                case WebBrowserTypeEnum.Wpf:
                    {
                        var browser = browserContext.GetWebBrowserAsWpfType();
                        axi = GetActiveXInstance(browser);
                        getBrowserUri = () => browser.Source;
                        navigateBrowser = u =>
                        {
                            var finished = false;
                            browserContext.SyncContext.Post(state =>
                            {
                                browser.Navigate(u);
                                finished = true;
                            }, null);
                            while (!finished) Thread.Sleep(DefaultConfig_SyncContextPostCheckInterval);
                        };
                        getBrowserDoc = () =>
                        {
                            IHTMLDocument2 doc = null;
                            bool finished = false;
                            browserContext.SyncContext.Post(state =>
                            {
                                doc = (IHTMLDocument2)browser.Document;
                                finished = true;
                            }, null);
                            while (!finished) Thread.Sleep(DefaultConfig_SyncContextPostCheckInterval);

                            return doc;
                        };
                        axi = GetActiveXInstance(browserContext);
                    }
                    break;

                default: throw new ArgumentException("unknown browser type", browserContext.WebBrowserType.ToString());
            }

            var success = NavigateLoadAndRender(
                axi, url,
                getBrowserUri,
                navigateBrowser,
                //() => DoEvents(browser),
                getBrowserDoc,
                loadTimeout, renderTime, out errMsg);
            return success;
        }
        private static bool NavigateLoadAndRender(object activexInstance, string url,
            Func<Uri> getBrowserUri, Action<Uri> navigateBrowser, /*Action doEvents,*/ Func<IHTMLDocument2> getBrowserDoc,
            TimeSpan loadTimeout, TimeSpan renderTime, out string errMsg)
        {
            errMsg = null;
            var eventHandlerAdded_OnError = false;
            var eventHandlerAdded_OnComlete = false;
            SHDocVw.DWebBrowserEvents2_Event wbEvents2 = null;
            SHDocVw.DWebBrowserEvents2_NavigateErrorEventHandler onError = null;
            SHDocVw.DWebBrowserEvents2_DocumentCompleteEventHandler onComplete = null;
            try
            {
                if (null == activexInstance) throw new ArgumentException("activex instance is null");
                if (string.IsNullOrWhiteSpace(url)) throw new ArgumentException("url is null or whitespace", url);


                var iwb = activexInstance as SHDocVw.IWebBrowser2;
                if (null == iwb) throw new ArgumentException("failed to cast WebBrowser to IWebBrowser2");

                wbEvents2 = iwb as SHDocVw.DWebBrowserEvents2_Event;
                if (null == wbEvents2) throw new ArgumentException("failed to cast IWebBrowser2 to DWebBrowserEvents2_Event");

                var completed = false;
                var success = true;
                var stateLock = new object();
                onError = delegate(object ppDisp, ref object objUrl, ref object frame, ref object statusCode, ref bool cancel)
                {
                    var errUrl = (string)objUrl;
                    var browserUri = getBrowserUri();
                    var browserUrl = null == browserUri ? null : browserUri.AbsoluteUri;
                    if (null == errUrl || null == browserUrl) return;
                    if (errUrl.Trim().ToLower() == browserUrl.Trim().ToLower())
                    {
                        lock (stateLock)
                        {
                            success = false;
                            completed = true;
                        }
                    }
                };
                onComplete = delegate(object ppDisp, ref object objUrl)
                {
                    var completeUrl = (string)objUrl;
                    var browserUri = getBrowserUri();
                    var browserUrl = null == browserUri ? null : browserUri.AbsoluteUri;
                    if (null == completeUrl || null == browserUrl) return;
                    if (completeUrl.Trim().ToLower() == browserUrl.Trim().ToLower())
                    {
                        lock (stateLock)
                        {
                            completed = true;
                        }
                    }
                };
                wbEvents2.NavigateError += onError; eventHandlerAdded_OnError = true;
                wbEvents2.DocumentComplete += onComplete; eventHandlerAdded_OnComlete = true;

                navigateBrowser(new Uri(url));

                // wait page load completing
                var startTime = DateTime.UtcNow;
                while (!completed)
                {
                    //doEvents();
                    if (DateTime.UtcNow - startTime > loadTimeout) break;
                    Thread.Sleep(DefaultConfig_SyncContextPostCheckInterval);
                }
                if (!success) return success;

                // give rendering a little time, letting scripts/flash load
                startTime = DateTime.UtcNow;
                while (DateTime.UtcNow - startTime < renderTime)
                {
                    //doEvents();
                    Thread.Sleep(DefaultConfig_SyncContextPostCheckInterval);
                }

                var doc = getBrowserDoc();
                return ("complete" == doc.readyState.Trim().ToLower() || "interactive" == doc.readyState.Trim().ToLower()) && success;
            }
            catch (Exception e)
            {
                //errMsg = Logger.WriteLog("WebBrowserUtil.NavigateLoadAndRender", "failed to navigate, load and render.", e);
                return false;
            }
            finally
            {
                if (null != wbEvents2)
                {
                    if (eventHandlerAdded_OnError) wbEvents2.NavigateError -= onError;
                    if (eventHandlerAdded_OnComlete) wbEvents2.DocumentComplete -= onComplete;
                }
            }
        }
        #endregion

        private static void ForceInitActiveXInstance(WebBrowserContext browserContext)
        {
            var axi = GetActiveXInstance(browserContext);
            if (null != axi) return;        // activex instance already initiated

            var finished = false;
            var blankPageUri = new Uri(@"about:blank");
            switch (browserContext.WebBrowserType)
            {
                case WebBrowserTypeEnum.Forms:
                    {
                        var browser = browserContext.GetWebBrowserAsFormsType();
                        browserContext.SyncContext.Post(state =>
                        {
                            browser.Navigate(blankPageUri);
                            finished = true;
                        }, null);
                    }
                    break;

                case WebBrowserTypeEnum.Wpf:
                    {
                        var browser = browserContext.GetWebBrowserAsWpfType();
                        browserContext.SyncContext.Post(state =>
                        {
                            browser.Navigate(blankPageUri);
                            finished = true;
                        }, null);
                    }
                    break;

                default: throw new ArgumentException("unknown browser type", browserContext.WebBrowserType.ToString());
            }
            while (!finished) Thread.Sleep(DefaultConfig_SyncContextPostCheckInterval);
            Thread.Sleep(DefaultConfig_ActiveXInstanceInitTime);
        }
    }
}


using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApplication8
{
    class Program
    {
        static void Main(string[] args)
        {
            if (0 == args.Count())
            {
                var selfExecutable = Path.Combine(Path.GetDirectoryName(Environment.GetCommandLineArgs()[0]), @"ConsoleApplication8.exe");
                var threadList = new List<Thread>();
                for (var i = 0; i < 30; i++)
                {
                    var thread = new Thread(() =>
                    {
                        var startInfo = new ProcessStartInfo(selfExecutable, "--runone");
                        var process = new Process();
                        process.StartInfo = startInfo;
                        process.Start();

                        process.WaitForExit();
                    });
                    threadList.Add(thread);
                    thread.Start();
                }
                //foreach (var thread in threadList) thread.Start();
                foreach (var thread in threadList) thread.Join();
            }
            else PrintHtml();
        }

        static void PrintHtml()
        {
            var wbc = new WebBrowserUtil.WebBrowserContext(WebBrowserUtil.WebBrowserTypeEnum.Forms);
            WebBrowserUtil.SuppressScriptErrors(wbc, true);
            WebBrowserUtil.DisableFileDownload(wbc, true);
            WebBrowserUtil.BlockNewWindows(wbc, true);
            Console.WriteLine();
            Console.WriteLine("starting navigation, loading and redering");
            var success = WebBrowserUtil.NavigateLoadAndRender(wbc, @"http://news.yahoo.com/obama-white-house-accuses-israel-spying-undermine-iran-124019932.html");
            if (!success)
            {
                Console.WriteLine("failed to navigate, load and render");
                return;
            }

            var html = WebBrowserUtil.GetDocumentHtml(wbc);
            Console.WriteLine("html:");
            Console.WriteLine(html);
        }
    }
}