CefSharp проксификация. Как можно повторно поменять прокси после инициализации настроек?

using System;
using System.Text;
using System.Threading.Tasks;
using System.Threading;
using System.IO;
using CefSharp.OffScreen;
using CefSharp;
using System.Runtime.InteropServices;

class Program
    {
 
        static async Task Main(string[] args)
        {
            string path = Directory.GetCurrentDirectory();
 
            string id;
 
            string url;
 
            string pathreturn;
 
            string myipaddress;
 
            string myport;
 
            string myusername;
 
            string mypassword;
 
            id = Ini.Read(@path + @"\запрос.ini", "steam", "Id", "NotFound");
 
            url = Ini.Read(@path + @"\запрос.ini", "steam", "Adress", "NotFound");
 
            pathreturn = Ini.Read(@path + @"\запрос.ini", "steam", "Path", "NotFound");
 
            myipaddress = Ini.Read(@path + @"\запрос.ini", "steam", "myipaddress", "NotFound");
 
            myport = Ini.Read(@path + @"\запрос.ini", "steam", "myport", "NotFound");
 
            myusername = Ini.Read(@path + @"\запрос.ini", "steam", "myusername", "NotFound");
 
            mypassword = Ini.Read(@path + @"\запрос.ini", "steam", "mypassword", "NotFound");
 
 
            string LocalesDirPath = @path + @"\locales";
            string Locale = "ru";
 
            CefSharpSettings.Proxy = new ProxyOptions(ip: myipaddress, port: myport, username: myusername, password: mypassword);
 
            Browser _browser = new Browser(LocalesDirPath, Locale);
              
            _browser.OpenUrl(url);
            
            string source = "";
     
            source = await _browser.Page.GetSourceAsync();
            
 
            File.Delete(pathreturn + id + ".html");
            File.AppendAllText(pathreturn + id + ".html", source);
 
        }
    }

public class Browser
    {
       
        /// <summary>
        /// The browser page
        /// </summary>
        public ChromiumWebBrowser Page { get; private set; }
        /// <summary>
        /// The request context
        /// </summary>
        public RequestContext RequestContext { get; private set; }
 
        // chromium does not manage timeouts, so we'll implement one
        private ManualResetEvent manualResetEvent = new ManualResetEvent(false);
 
        public Browser(string LocalesDirPath, string Locale)
        {
            var settings = new CefSettings()
            {
                //By default CefSharp will use an in-memory cache, you need to     specify a Cache Folder to persist data
                CachePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "CefSharp\\Cache"),
 
            };
            settings.LocalesDirPath = LocalesDirPath;
            settings.Locale = Locale;
            
 
            //Autoshutdown when closing
            CefSharpSettings.ShutdownOnExit = true;
 
            //Perform dependency check to make sure all relevant resources are in our     output directory.
            Cef.Initialize(settings, performDependencyCheck: true, browserProcessHandler: null);
 
            RequestContext = new RequestContext();
            Page = new ChromiumWebBrowser("", null, RequestContext);
            PageInitialize();
        }
 
        /// <summary>
        /// Open the given url
        /// </summary>
        /// <param name="url">the url</param>
        /// <returns></returns>
        public void OpenUrl(string url)
        {
            try
            {
                Page.LoadingStateChanged += PageLoadingStateChanged;
                if (Page.IsBrowserInitialized)
                {
                    Page.Load(url);
 
                    //create a 60 sec timeout 
                    bool isSignalled = manualResetEvent.WaitOne(TimeSpan.FromSeconds(60));
                    manualResetEvent.Reset();
 
                    //As the request may actually get an answer, we'll force stop when the timeout is passed
                    if (!isSignalled)
                    {
                        Page.Stop();
                    }
                }
            }
            catch (ObjectDisposedException)
            {
                //happens on the manualResetEvent.Reset(); when a cancelation token has disposed the context
            }
            Page.LoadingStateChanged -= PageLoadingStateChanged;
        }
 
        /// <summary>
        /// Manage the IsLoading parameter
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void PageLoadingStateChanged(object sender, LoadingStateChangedEventArgs e)
        {
            // Check to see if loading is complete - this event is called twice, one when loading starts
            // second time when it's finished
            if (!e.IsLoading)
            {
                manualResetEvent.Set();
            }
        }
 
        /// <summary>
        /// Wait until page initialization
        /// </summary>
        private void PageInitialize()
        {
            SpinWait.SpinUntil(() => Page.IsBrowserInitialized);
        }
    }

CefSharpSettings.Proxy = new ProxyOptions(ip: myipaddress, port: myport, username: myusername, password: mypassword);
 Browser _browser = new Browser(LocalesDirPath, Locale);
 _browser.OpenUrl(url);
CefSharpSettings.Proxy = new ProxyOptions(ip: myipaddress2, port: myport2, username: myusername2, password: mypassword2);
 _browser.OpenUrl(url);

Browser _browser = new Browser(LocalesDirPath, Locale);
 
 CefSharpSettings.Proxy = new ProxyOptions(ip: myipaddress, port: myport, username: myusername, password: mypassword);
 
var settings = new CefSettings()
            {
                //By default CefSharp will use an in-memory cache, you need to     specify a Cache Folder to persist data
                CachePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "CefSharp\\Cache"),
 
            };
            settings.LocalesDirPath = LocalesDirPath;
            settings.Locale = Locale;
 
            Cef.Initialize(settings);

//Create a new RequestContext that users a specific proxy server
//By default an in memory cache is used
var requestContext = RequestContext
    .Configure()
    .WithProxyServer("127.0.0.1", 8080)
    .Create();
 
//Create a RequestContext with a proxy and cache path
//Making sure that CachePath is equal to or a child of CefSettings.RootCachePath
//See https://github.com/cefsharp/CefSharp/issues/3111#issuecomment-629713608 for more info on cache path
var requestContext = RequestContext
    .Configure()
    .WithProxyServer("127.0.0.1", 8080)
    .WithCachePath(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "CefSharp\\Cache"))
    .Create();
 
//Set the proxy at runtime, the RequestContext must be initialized
Cef.UIThreadTaskFactory.StartNew(delegate
{
    string errorMessage;
 
    if (!requestContext.CanSetPreference("proxy"))
    {
        //Unable to set proxy, if you set proxy via command line args it cannot be modified.
    }
 
    success = requestContext.SetProxy("127.0.0.1", 8080, out errorMessage);
});

public class ChromeTest
    {
        public static ChromiumWebBrowser Create(WebProxy proxy = null, Action<ChromiumWebBrowser> onInited = null)
        {
            var result = default(ChromiumWebBrowser);
            var settings = new CefSharp.OffScreen.CefSettings();
            result = new ChromiumWebBrowser("about:blank");
            if (proxy != null)
                result.RequestHandler = new _requestHandler(proxy?.Credentials as NetworkCredential);
 
            result.IsBrowserInitializedChanged += (s, e) =>
            {
                if (!e.IsBrowserInitialized)
                    return;
 
                var br = (ChromiumWebBrowser)s;
                if (proxy != null)
                {
                    var v = new Dictionary<string, object>
                    {
                        ["mode"] = "fixed_servers",
                        ["server"] = $"{proxy.Address.Scheme}://{proxy.Address.Host}:{proxy.Address.Port}"
                    };
                    if (!br.GetBrowser().GetHost().RequestContext.SetPreference("proxy", v, out string error))
                        MessageBox.Show(error);
                }
 
                onInited?.Invoke(br);
            };
 
            return result;
        }
 
        private class _requestHandler : DefaultRequestHandler
        {
            private NetworkCredential _credential;
 
            public _requestHandler(NetworkCredential credential = null) : base()
            {
                _credential = credential;
            }
 
            public override bool GetAuthCredentials(IWebBrowser browserControl, IBrowser browser, IFrame frame, bool isProxy, string host, int port, string realm, string scheme, IAuthCallback callback)
            {
                if (isProxy == true)
                {
                    if (_credential == null)
                        throw new NullReferenceException("credential is null");
 
                    callback.Continue(_credential.UserName, _credential.Password);
                    return true;
                }
 
                return false;
            }
        }
    }

 if (!br.GetBrowser().GetHost().RequestContext.SetPreference("proxy", v, out string error))