OffScreen - SelfHost BrowserSubProcess for .Net 5.0 PublishSingleFile

CefSharp.MinimalExample.OffScreen/CefSharp.MinimalExample.OffScreen.netcore.csproj

@@ -21,6 +21,20 @@
         https://github.com/dotnet/docs/issues/12237
         -->
     <RollForward>Major</RollForward>
+    <StartupObject>CefSharp.MinimalExample.OffScreen.Program</StartupObject>
+  </PropertyGroup>
+
+  <!--
+  .Net 5.0 Publish Settings for PublishSingleFile
+  https://docs.microsoft.com/en-us/dotnet/core/deploying/single-file
+  Defaults differ compared to .Net Core 3.1
+  -->
+  <PropertyGroup Condition="'$(TargetFramework)' == 'net5.0-windows' AND '$(PublishSingleFile)' == 'true'">
+    <!-- Extract all files to disk at runtime -->
+    <IncludeAllContentForSelfExtract>true</IncludeAllContentForSelfExtract>
+    <!-- Include our native files in the resulting exe -->
+    <IncludeNativeLibrariesForSelfExtract>true</IncludeNativeLibrariesForSelfExtract>
+    <StartupObject>CefSharp.MinimalExample.OffScreen.ProgramPublishSingleFile</StartupObject>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(PlatformTarget)' == 'x86'">

CefSharp.MinimalExample.OffScreen/Program.PublishSingleFile.cs.cs

@@ -0,0 +1,118 @@
+// Copyright © 2021 The CefSharp Authors. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
+
+using CefSharp.OffScreen;
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CefSharp.MinimalExample.OffScreen
+{
+    /// <summary>
+    /// For .Net 5.0 Publishing Single File exe requires using your own applications executable to
+    /// act as the BrowserSubProcess. See https://github.com/cefsharp/CefSharp/issues/3407
+    /// for further details. <see cref="Program.Main(string[])"/> for the default main application entry point
+    /// </summary>
+    public class ProgramPublishSingleFile
+    {
+        private static ChromiumWebBrowser browser;
+
+        public static int Main(string[] args)
+        {
+            //To support High DPI this must be before CefSharp.BrowserSubprocess.SelfHost.Main so the BrowserSubprocess is DPI Aware
+            Cef.EnableHighDPISupport();
+
+            //Self Hosting the BrowserSucProcess
+            var exitCode = CefSharp.BrowserSubprocess.SelfHost.Main(args);
+
+            if (exitCode >= 0)
+            {
+                return exitCode;
+            }
+
+            const string testUrl = "https://www.google.com/";
+
+            Console.WriteLine("This example application will load {0}, take a screenshot, and save it to your desktop.", testUrl);
+            Console.WriteLine("You may see Chromium debugging output, please wait...");
+            Console.WriteLine();
+
+            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"),
+                BrowserSubprocessPath = System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName
+            };
+
+            //Perform dependency check to make sure all relevant resources are in our output directory.
+            Cef.Initialize(settings, performDependencyCheck: false);
+
+            // Create the offscreen Chromium browser.
+            browser = new ChromiumWebBrowser(testUrl);
+
+            // An event that is fired when the first page is finished loading.
+            // This returns to us from another thread.
+            browser.LoadingStateChanged += BrowserLoadingStateChanged;
+
+            // We have to wait for something, otherwise the process will exit too soon.
+            Console.ReadKey();
+
+            // Clean up Chromium objects.  You need to call this in your application otherwise
+            // you will get a crash when closing.
+            Cef.Shutdown();
+
+            return 0;
+        }
+
+        private static void BrowserLoadingStateChanged(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
+            // (rather than an iframe within the main frame).
+            if (!e.IsLoading)
+            {
+                // Remove the load event handler, because we only want one snapshot of the initial page.
+                browser.LoadingStateChanged -= BrowserLoadingStateChanged;
+
+                var scriptTask = browser.EvaluateScriptAsync("document.querySelector('[name=q]').value = 'CefSharp Was Here!'");
+
+                scriptTask.ContinueWith(t =>
+                {
+                    //Give the browser a little time to render
+                    Thread.Sleep(500);
+                    // Wait for the screenshot to be taken.
+                    var task = browser.ScreenshotAsync();
+                    task.ContinueWith(x =>
+                    {
+                        // Make a file to save it to (e.g. C:\Users\jan\Desktop\CefSharp screenshot.png)
+                        var screenshotPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Desktop), "CefSharp screenshot.png");
+
+                        Console.WriteLine();
+                        Console.WriteLine("Screenshot ready. Saving to {0}", screenshotPath);
+
+                        // Save the Bitmap to the path.
+                        // The image type is auto-detected via the ".png" extension.
+                        task.Result.Save(screenshotPath);
+
+                        // We no longer need the Bitmap.
+                        // Dispose it to avoid keeping the memory alive.  Especially important in 32-bit applications.
+                        task.Result.Dispose();
+
+                        Console.WriteLine("Screenshot saved.  Launching your default image viewer...");
+
+                        // Tell Windows to launch the saved image.
+                        Process.Start(new ProcessStartInfo(screenshotPath)
+                        {
+                            // UseShellExecute is false by default on .NET Core.
+                            UseShellExecute = true
+                        });
+
+                        Console.WriteLine("Image viewer launched.  Press any key to exit.");
+                    }, TaskScheduler.Default);
+                });
+            }
+        }
+    }
+}