Microsoft.Web.WebView2.Core

WebView2 enables you to host web content using the latest Microsoft Edge browser and web technology.

Print the current page to PDF asynchronously with the provided settings.

See for description of settings. Passing null for printSettings results in default print settings used. Use resultFilePath to specify the path to the PDF file. The host should provide an absolute path, including file name. If the path points to an existing file, the file will be overwritten. If the path is not valid, the method fails. The async PrintToPdf operation completes when the data has been written to the PDF file. If the application exits before printing is complete, the file is not saved. Only one `Printing` operation can be in progress at a time. If PrintToPdf is called while a `PrintToPdf` or `PrintToPdfStream` or `Print` operation is in progress, the operation completes and returns false.

Opens the browser print preview dialog to print the current web page

Gets the object contains various modifiable settings for the running WebView.

Gets the URI of the current top level document.

This value potentially changes as a part of the event raised for some cases such as navigating to a different site or fragment navigations. It remains the same for other types of navigations such as page refreshes or history.pushState with the same URL as the current page.

Gets the process ID of the browser process that hosts the WebView.

true if the WebView is able to navigate to a previous page in the navigation history.

If CanGoBack changes value, the event is raised.

true if the WebView is able to navigate to a next page in the navigation history.

If CanGoForward changes value, the event is raised.

Gets the title for the current top-level document.

If the document has no explicit title or is otherwise empty, a default that may or may not match the URI of the document is used. :::code language="csharp" source="../code/sample/SampleApps/WebView2WpfBrowser/MainWindow.xaml.cs" id="DocumentTitle":::

Indicates if the WebView contains a fullscreen HTML element.

NavigationStarting is raised when the WebView main frame is requesting permission to navigate to a different URI.

Redirects raise this event as well, and the navigation id is the same as the original one. You may block corresponding navigations until the event handler returns. :::code language="csharp" source="../code/sample/SampleApps/WebView2WpfBrowser/MainWindow.xaml.cs" id="NavigationStarting":::

ContentLoading is raised before any content is loaded, including scripts added with . ContentLoading is not raised if a same page navigation occurs (such as through fragment navigations or history.pushState navigations).

This operation follows the and events and precedes the and events.

SourceChanged is raised when the property changes.

SourceChanged is raised when navigating to a different site or fragment navigations. It is not raised for other types of navigations such as page refreshes or history.pushState with the same URL as the current page. This event is raised before for navigation to a new document.

HistoryChanged is raised for changes to joint session history, which consists of top-level and manual frame navigations.

Use HistoryChanged to verify that the or value has changed. HistoryChanged is also raised for using or . HistoryChanged is raised after and . CanGoBack is false for navigations initiated through CoreWebView2Frame APIs if there has not yet been a user gesture.

NavigationCompleted is raised when the WebView has completely loaded (body.onload has been raised) or loading stopped with error.

:::code language="csharp" source="../code/sample/SampleApps/WebView2WpfBrowser/MainWindow.xaml.cs" id="NavigationCompleted"::: :::code language="csharp" source="../code/sample/SampleApps/WebView2WpfBrowser/MainWindow.xaml.cs" id="DOMContentLoaded":::

FrameNavigationStarting is raised when a child frame in the WebView requests permission to navigate to a different URI.

Redirects raise this operation as well, and the navigation id is the same as the original one. You may block corresponding navigations until the event handler returns.

FrameNavigationCompleted is raised when a child frame has completely loaded (body.onload has been raised) or loading stopped with error.

ScriptDialogOpening is raised when a JavaScript dialog (alert, confirm, prompt, or beforeunload) displays for the WebView.

This event only is raised if the property is set to false. This event suppresses dialogs or replaces default dialogs with custom dialogs. If a deferral is not taken on the event args, the subsequent scripts are blocked until the event handler returns. If a deferral is taken, the scripts are blocked until the deferral is completed.

PermissionRequested is raised when content in a WebView requests permission to access some privileged resources.

If a deferral is not taken on the event args, the subsequent scripts are blocked until the event handler returns. If a deferral is taken, the scripts are blocked until the deferral is completed.

ProcessFailed is raised when a WebView process ends unexpectedly or becomes unresponsive.

:::code language="csharp" source="../code/sample/SampleApps/WebView2WpfBrowser/MainWindow.xaml.cs" id="ProcessFailed":::

WebMessageReceived is raised when the setting is set and the top-level document of the WebView runs window.chrome.webview.postMessage or window.chrome.webview.postMessageWithAdditionalObjects.

The postMessage function is void postMessage(object) where object is any object supported by JSON conversion. When postMessage is called, the handler's Invoke method will be called with the object parameter postMessage converted to a JSON string. If the same page calls postMessage multiple times, the corresponding WebMessageReceived events are guaranteed to be fired in the same order. However, if multiple frames call postMessage, there is no guaranteed order. In addition, WebMessageReceived events caused by calls to postMessage are not guaranteed to be sequenced with events caused by DOM APIs. For example, if the page runs


            chrome.webview.postMessage("message");
            window.open();

then the event might be fired before the WebMessageReceived event. If you need the WebMessageReceived event to happen before anything else, then in the WebMessageReceived handler you can post a message back to the page and have the page wait until it receives that message before continuing.

NewWindowRequested is raised when content inside the WebView requests to open a new window, such as through window.open().

The app passes a target WebView that is considered the opened window. If a deferral is not taken on the event args, scripts that resulted in the new window that are requested are blocked until the event handler returns. If a deferral is taken, then scripts are blocked until the deferral is completed.

DocumentTitleChanged is raised when the property changes and may be raised before or after the event.

:::code language="csharp" source="../code/sample/SampleApps/WebView2WpfBrowser/MainWindow.xaml.cs" id="DocumentTitleChanged":::

ContainsFullScreenElementChanged is raised when the property changes.

An HTML element inside the WebView may enter fullscreen to the size of the WebView or leave fullscreen. This event is useful when, for example, a video element requests to go fullscreen. The listener of this event may resize the WebView in response.

WebResourceRequested is raised when the WebView is performing a URL request to a matching URL and resource context filter that was added with .

At least one filter must be added for the event to be raised. The web resource requested may be blocked until the event handler returns if a deferral is not taken on the event args. If a deferral is taken, then the web resource requested is blocked until the deferral is completed. If this event is subscribed in the handler it should be called after the new window is set. For more details see . Currently this only supports file, http, and https URI schemes.

WindowCloseRequested is raised when content inside the WebView requested to close the window, such as after window.close() is run.

The app should close the WebView and related app window if that makes sense to the app.

Causes a navigation of the top level document to the specified URI.

The URI to navigate to. For more information, navigate to [Navigation event](/microsoft-edge/webview2/concepts/navigation-events). Note that this operation starts a navigation and the corresponding event is raised sometime after Navigate runs. :::code language="csharp" source="../code/sample/SampleApps/WebView2WpfBrowser/MainWindow.xaml.cs" id="Navigate":::

Initiates a navigation to htmlContent as source HTML of a new document.

A source HTML of a new document. The htmlContent parameter may not be larger than 2 MB (2 * 1024 * 1024 bytes) in total size. The origin of the new page is about:blank.


            webView.CoreWebView2.SetVirtualHostNameToFolderMapping(
                "appassets.example", "assets", CoreWebView2HostResourceAccessKind.DenyCors);
            string htmlContent =
            @"
                
                
                    
                     Click me
                
            ";
            webview.NavigateToString(htmlContent);

Adds the provided JavaScript to a list of scripts that should be run after the global object has been created, but before the HTML document has been parsed and before any other script included by the HTML document is run.

The JavaScript code to be run. A script ID that may be passed when calling . The injected script will apply to all future top level document and child frame navigations until removed with . This is applied asynchronously and you must wait for the returned to complete before you can be sure that the script is ready to execute on future navigations. Note that if an HTML document has sandboxing of some kind via [sandbox](https://developer.mozilla.org/docs/Web/HTML/Element/iframe#attr-sandbox) properties or the [Content-Security-Policy HTTP header](https://developer.mozilla.org/docs/Web/HTTP/Headers/Content-Security-Policy) this will affect the script run here. So, for example, if the allow-modals keyword is not set then calls to the alert function will be ignored.

Removes the corresponding JavaScript added via with the specified script ID.

The ID corresponds to the JavaScript code to be removed from the list of scripts.

Runs JavaScript code from the javaScript parameter in the current top-level document rendered in the WebView.

The JavaScript code to be run in the current top-level document rendered in the WebView. A JSON encoded string that represents the result of running the provided JavaScript. If the result is undefined, contains a reference cycle, or otherwise is not able to be encoded into JSON, the JSON null value is returned as the "null" string. A function that has no explicit return value returns undefined. If the script that was run throws an unhandled exception, then the result is also null. This method is applied asynchronously. If the method is run after the event during a navigation, the script runs in the new document when loading it, around the time is run. This operation works even if is set to false. :::code language="csharp" source="../code/sample/SampleApps/WebView2WpfBrowser/MainWindow.xaml.cs" id="ExecuteScript":::

Captures an image of what WebView is displaying.

The format of the image to be captured. The stream to which the resulting image binary data is written. When CapturePreviewAsync finishes writing to the stream, the Invoke method on the provided handler parameter is called. This method fails if called before the first event. For example if this is called in the event for the first navigation it will fail. For subsequent navigations, the method may not fail, but will not capture an image of a given webpage until the event has been fired for it. Any call to this method prior to that will result in a capture of the page being navigated away from.

Reloads the current page.

This is similar to navigating to the URI of current top level document including all navigation events firing and respecting any entries in the HTTP cache. But, the back or forward history will not be modified.

Posts the specified webMessageAsJson to the top level document in this WebView.

The web message to be posted to the top level document in this WebView. The event args is an instance of MessageEvent. The setting must be true or this method will fail with E_INVALIDARG. The event arg's data property of the event arg is the webMessageAsJson string parameter parsed as a JSON string into a JavaScript object. The event arg's source property of the event arg is a reference to the window.chrome.webview object. For information about sending messages from the HTML document in the WebView to the host, navigate to . The message is sent asynchronously. If a navigation occurs before the message is posted to the page, the message is not be sent. Runs the message event of the window.chrome.webview of the top-level document. JavaScript in that document may subscribe and unsubscribe to the event using the following code:


            window.chrome.webview.addEventListener('message', handler)
            window.chrome.webview.removeEventListener('message', handler)

Posts a message that is a simple string rather than a JSON string representation of a JavaScript object.

The web message to be posted to the top level document in this WebView. This behaves in exactly the same manner as , but the data property of the event arg of the window.chrome.webview message is a string with the same value as webMessageAsString. Use this instead of if you want to communicate using simple strings rather than JSON objects.

Runs an asynchronous DevToolsProtocol method.

The full name of the method in the format {domain}.{method}. A JSON formatted string containing the parameters for the corresponding method. A JSON string that represents the method's return object. For more information about available methods, navigate to [DevTools Protocol Viewer](https://aka.ms/DevToolsProtocolDocs). The returned task is completed when the method asynchronously completes and will return the method's return object as a JSON string. Note even though WebView2 dispatches the CDP messages in the order called, CDP method calls may be processed out of order. If you require CDP methods to run in a particular order, you should await for the previous method call.

Navigates the WebView to the previous page in the navigation history.

Navigates the WebView to the next page in the navigation history.

Gets a DevTools Protocol event receiver that allows you to subscribe to a DevToolsProtocol event.

The full name of the event in the format {domain}.{event}. A Devtools Protocol event receiver. For more information about DevToolsProtocol events description and event args, navigate to [DevTools Protocol Viewer](https://aka.ms/DevToolsProtocolDocs).

Stops all navigations and pending resource fetches.

Does not stop scripts.

Adds the provided host object to script running in the WebView with the specified name.

The name of the host object. The host object to be added to script. Host objects are exposed as host object proxies via window.chrome.webview.hostObjects.{name}. Host object proxies are promises and will resolve to an object representing the host object. Only the COM visible objects/properties/methods can be accessed from script. The app can control which part of .NET objects are exposed using . JavaScript code in the WebView will be able to access appObject as following and then access attributes and methods of appObject. Note that while simple types, IDispatch and array are supported, and IUnknown objects that also implement IDispatch are treated as IDispatch, generic IUnknown, VT_DECIMAL, or VT_RECORD variant is not supported. Remote JavaScript objects like callback functions are represented as an VT_DISPATCH VARIANT with the object implementing IDispatch. The JavaScript callback method may be invoked using DISPID_VALUE for the DISPID. Nested arrays are supported up to a depth of 3. Arrays of by reference types are not supported. VT_EMPTY and VT_NULL are mapped into JavaScript as null. In JavaScript null and undefined are mapped to VT_EMPTY. Additionally, all host objects are exposed as window.chrome.webview.hostObjects.sync.{name}. Here the host objects are exposed as synchronous host object proxies. These are not promises and calls to functions or property access synchronously block running script waiting to communicate cross process for the host code to run. Accordingly this can result in reliability issues and it is recommended that you use the promise based asynchronous window.chrome.webview.hostObjects.{name} API described above. Synchronous host object proxies and asynchronous host object proxies can both proxy the same host object. Remote changes made by one proxy will be reflected in any other proxy of that same host object whether the other proxies and synchronous or asynchronous. While JavaScript is blocked on a synchronous call to native code, that native code is unable to call back to JavaScript. Attempts to do so will fail with HRESULT_FROM_WIN32(ERROR_POSSIBLE_DEADLOCK). Host object proxies are JavaScript Proxy objects that intercept all property get, property set, and method invocations. Properties or methods that are a part of the Function or Object prototype are run locally. Additionally any property or method in the array chrome.webview.hostObjects.options.forceLocalProperties will also be run locally. This defaults to including optional methods that have meaning in JavaScript like toJSON and Symbol.toPrimitive. You can add more to this array as required. There's a method chrome.webview.hostObjects.cleanupSome that will best effort garbage collect host object proxies. The chrome.webview.hostObjects.options object provides the ability to change some functionality of host objects. Options property Details forceLocalProperties This is an array of host object property names that will be run locally, instead of being called on the native host object. This defaults to then, toJSON, Symbol.toString, and Symbol.toPrimitive. You can add other properties to specify that they should be run locally on the JavaScript host object proxy. log This is a callback that will be called with debug information. For example, you can set this to console.log.bind(console) to have it print debug information to the console to help when troubleshooting host object usage. By default this is null. shouldSerializeDates By default this is false, and JavaScript Date objects will be sent to host objects as a string using JSON.stringify. You can set this property to true to have Date objects properly serialize as a System.DateTime when sending to the .NET host object, and have System.DateTime properties and return values create a JavaScript Date object. defaultSyncProxy When calling a method on a synchronous proxy, the result should also be a synchronous proxy. But in some cases, the sync/async context is lost (for example, when providing to native code a reference to a function, and then calling that function in native code). In these cases, the proxy will be asynchronous, unless this property is set. forceAsyncMethodMatches This is an array of regular expressions. When calling a method on a synchronous proxy, the method call will be performed asynchronously if the method name matches a string or regular expression in this array. Setting this value to Async will make any method that ends with Async be an asynchronous method call. If an async method doesn't match here and isn't forced to be asynchronous, the method will be invoked synchronously, blocking execution of the calling JavaScript and then returning the resolution of the promise, rather than returning a promise. ignoreMemberNotFoundError By default, an exception is thrown when attempting to get the value of a proxy property that doesn't exist on the corresponding native class. Setting this property to true switches the behavior to match Chakra WinRT projection (and general JavaScript) behavior of returning undefined with no error. Host object proxies additionally have the following methods which run locally: Method name Details applyHostFunction, getHostProperty, setHostProperty Perform a method invocation, property get, or property set on the host object. You can use these to explicitly force a method or property to run remotely if there is a conflicting local method or property. For instance, proxy.toString() will run the local toString method on the proxy object. But proxy.applyHostFunction('toString') runs toString on the host proxied object instead. getLocalProperty, setLocalProperty Perform property get, or property set locally. You can use these methods to force getting or setting a property on the host object proxy itself rather than on the host object it represents. For instance, proxy.unknownProperty will get the property named unknownProperty from the host proxied object. But proxy.getLocalProperty('unknownProperty') will get the value of the property unknownProperty on the proxy object itself. sync Asynchronous host object proxies expose a sync method which returns a promise for a synchronous host object proxy for the same host object. For example, chrome.webview.hostObjects.sample.methodCall() returns an asynchronous host object proxy. You can use the sync method to obtain a synchronous host object proxy instead: const syncProxy = await chrome.webview.hostObjects.sample.methodCall().sync() async Synchronous host object proxies expose an async method which blocks and returns an asynchronous host object proxy for the same host object. For example, chrome.webview.hostObjects.sync.sample.methodCall() returns a synchronous host object proxy. Calling the async method on this blocks and then returns an asynchronous host object proxy for the same host object: const asyncProxy = chrome.webview.hostObjects.sync.sample.methodCall().async() then Asynchronous host object proxies have a then method. This allows them to be awaitable. then will return a promise that resolves with a representation of the host object. If the proxy represents a JavaScript literal then a copy of that is returned locally. If the proxy represents a function then a non-awaitable proxy is returned. If the proxy represents a JavaScript object with a mix of literal properties and function properties, then the a copy of the object is returned with some properties as host object proxies. All other property and method invocations (other than the above Remote object proxy methods, forceLocalProperties list, and properties on Function and Object prototypes) are run remotely. Asynchronous host object proxies return a promise representing asynchronous completion of remotely invoking the method, or getting the property. The promise resolves after the remote operations complete and the promises resolve to the resulting value of the operation. Synchronous host object proxies work similarly but block JavaScript execution and wait for the remote operation to complete. Setting a property on an asynchronous host object proxy works slightly differently. The set returns immediately and the return value is the value that will be set. This is a requirement of the JavaScript Proxy object. If you need to asynchronously wait for the property set to complete, use the setHostProperty method which returns a promise as described above. Synchronous object property set property synchronously blocks until the property is set. Exposing host objects to script has security risk. Please follow [best practices](/microsoft-edge/webview2/concepts/security). To create a [IDispatch](/windows/win32/api/oaidl/nn-oaidl-idispatch) implementing class in C# use the following attributes on each class you intend to expose.


            // Bridge and BridgeAnotherClass are C# classes that implement IDispatch and works with AddHostObjectToScript.
            [ClassInterface(ClassInterfaceType.AutoDual)]
            [ComVisible(true)]
            public class BridgeAnotherClass
            {
                // Sample property.
                public string Prop { get; set; } = "Example";
            }
            
            [ClassInterface(ClassInterfaceType.AutoDual)]
            [ComVisible(true)]
            public class Bridge
            {
                public string Func(string param)
                {
                    return "Example: " + param;
                }
            
                public BridgeAnotherClass AnotherObject { get; set; } = new BridgeAnotherClass();
            
                // Sample indexed property.
                [System.Runtime.CompilerServices.IndexerName("Items")]
                public string this[int index]
                {
                    get { return m_dictionary[index]; }
                    set { m_dictionary[index] = value; }
                }
                private Dictionary<int, string> m_dictionary = new Dictionary<int, string>();
            }

Then add instances of those classes via :


            webView.CoreWebView2.AddHostObjectToScript("bridge", new Bridge());

And then in script you can call the methods, and access those properties of the objects added via :


            // Find added objects on the hostObjects property
            const bridge = chrome.webview.hostObjects.bridge;
            
            // Call a method and pass in a parameter.
            // The result is another proxy promise so you must await to get the result.
            console.log(await bridge.Func("testing..."));
            
            // A property may be another object as long as its class also implements
            // IDispatch.
            // Getting a property also gets a proxy promise you must await.
            const propValue = await bridge.AnotherObject.Prop;
            console.log(propValue);
            
            // Indexed properties
            let index = 123;
            bridge[index] = "test";
            let result = await bridge[index];
            console.log(result);

Removes the host object specified by the name so that it is no longer accessible from JavaScript code in the WebView.

The name of the host object to be removed. While new access attempts are denied, if the object is already obtained by JavaScript code in the WebView, the JavaScript code continues to have access to that object. Running this method for a name that is already removed or never added fails.

Opens the DevTools window for the current document in the WebView.

Does nothing if run when the DevTools window is already open.

Adds a URI and resource context filter for the event.

An URI to be added to the event. A resource context filter to be added to the event. A web resource request with a resource context that matches this filter's resource context and a URI that matches this filter's URI wildcard string will be raised via the event. The uri parameter value is a wildcard string matched against the URI of the web resource request. This is a glob style wildcard string in which a * matches zero or more characters and a ? matches exactly one character. These wildcard characters can be escaped using a backslash just before the wildcard character in order to represent the literal * or ?. The matching occurs over the URI as a whole string and not limiting wildcard matches to particular parts of the URI. The wildcard filter is compared to the URI after the URI has been normalized, any URI fragment has been removed, and non-ASCII hostnames have been converted to punycode. Specifying a nullptr for the uri is equivalent to an empty string which matches no URIs. For more information about resource context filters, navigate to . URI Filter String Request URI Match Notes * https://contoso.com/a/b/c Yes A single * will match all URIs *://contoso.com/* https://contoso.com/a/b/c Yes Matches everything in contoso.com across all schemes *://contoso.com/* https://example.com/?https://contoso.com/ Yes But also matches a URI with just the same text anywhere in the URI example https://contoso.com/example No The filter does not perform partial matches *example https://contoso.com/example Yes The filter matches across URI parts *example https://contoso.com/path/?example Yes The filter matches across URI parts *example https://contoso.com/path/?query#example No The filter is matched against the URI with no fragment *example https://example No The URI is normalized before filter matching so the actual URI used for comparison is https://example.com/ *example/ https://example Yes Just like above, but this time the filter ends with a / just like the normalized URI https://xn--qei.example/ https://❤.example/ Yes Non-ASCII hostnames are normalized to punycode before wildcard comparison https://❤.example/ https://xn--qei.example/ No Non-ASCII hostnames are normalized to punycode before wildcard comparison

Removes a matching WebResource filter that was previously added for the event.

An URI to at which a web resource filter was added. A previously added resource context filter to be removed. A filter that was never added. If the same filter was added multiple times, then it must need to be removed as many times as it was added for the removal to be effective.

Gets the object associated with this .

Exposes the used to create this .

WebResourceResponseReceived is raised when the WebView receives the response for a request for a web resource (any URI resolution performed by the WebView; such as HTTP/HTTPS, file and data requests from redirects, navigations, declarations in HTML, implicit Favicon lookups, and fetch API usage in the document).

The host app can use this event to view the actual request and response for a web resource. There is no guarantee about the order in which the WebView processes the response and the host app's handler runs. The app's handler will not block the WebView from processing the response. The event args include the as sent by the wire and received, including any additional headers added by the network stack that were not be included as part of the associated event, such as Authentication headers. :::code language="csharp" source="../code/sample/SampleApps/WebView2WpfBrowser/MainWindow.xaml.cs" id="WebResourceResponseReceived":::

DOMContentLoaded is raised when the initial HTML document has been parsed.

This aligns with the the document's DOMContentLoaded event in HTML. :::code language="csharp" source="../code/sample/SampleApps/WebView2WpfBrowser/MainWindow.xaml.cs" id="DOMContentLoaded":::

Navigates using a constructed object.

The constructed web resource object to provide post data or additional request headers during navigation. The headers in the override headers added by WebView2 runtime except for Cookie headers. Method can only be either GET or POST. Provided post data will only be sent only if the method is POST and the uri scheme is HTTP(S). :::code language="csharp" source="../code/sample/SampleApps/WebView2WpfBrowser/MainWindow.xaml.cs" id="NavigateWithWebResourceRequest":::

Whether WebView is suspended.

True when WebView is suspended, from the time when has completed successfully until WebView is resumed.

An app may call this API to have the WebView2 consume less memory.

This is useful when a Win32 app becomes invisible, or when a Universal Windows Platform app is being suspended, during the suspended event handler before completing the suspended event. The property must be false when the API is called. Otherwise, the API throws COMException with error code of HRESULT_FROM_WIN32(ERROR_INVALID_STATE). Suspending is similar to putting a tab to sleep in the Edge browser. Suspending pauses WebView script timers and animations, minimizes CPU usage for the associated browser renderer process and allows the operating system to reuse the memory that was used by the renderer process for other processes. Note that Suspend is best effort and considered completed successfully once the request is sent to browser renderer process. If there is a running script, the script will continue to run and the renderer process will be suspended after that script is done. See [Sleeping Tabs FAQ](https://techcommunity.microsoft.com/t5/articles/sleeping-tabs-faq/m-p/1705434) for conditions that might prevent WebView from being suspended. In those situations, the result of the async task is false. The WebView will be automatically resumed when it becomes visible. Therefore, the app normally does not have to call explicitly. The app can call and then periodically for an invisible WebView so that the invisible WebView can sync up with latest data and the page ready to show fresh content when it becomes visible. All WebView APIs can still be accessed when a WebView is suspended. Some APIs like Navigate will auto resume the WebView. To avoid unexpected auto resume, check property before calling APIs that might change WebView state. :::code language="csharp" source="../code/sample/SampleApps/WebView2WpfBrowser/MainWindow.xaml.cs" id="TrySuspend":::

Resumes the WebView so that it resumes activities on the web page.

This API can be called while the WebView2 controller is invisible. The app can interact with the WebView immediately after . WebView will be automatically resumed when it becomes visible. :::code language="csharp" source="../code/sample/SampleApps/WebView2WpfBrowser/MainWindow.xaml.cs" id="Resume":::

Sets a mapping between a virtual host name and a folder path to make available to web sites via that host name.

A virtual host name. A folder path name to be mapped to the virtual host name. The length must not exceed the Windows MAX_PATH limit. The level of access to resources under the virtual host from other sites. After setting the mapping, documents loaded in the WebView can use HTTP or HTTPS URLs at the specified host name specified by hostName to access files in the local folder specified by folderPath. This mapping applies to both top-level document and iframe navigations as well as subresource references from a document. This also applies to dedicated and shared worker scripts but does not apply to service worker scripts. Due to a current implementation limitation, media files accessed using virtual host name can be very slow to load. As the resource loaders for the current page might have already been created and running, changes to the mapping might not be applied to the current page and a reload of the page is needed to apply the new mapping. Both absolute and relative paths are supported for folderPath. Relative paths are interpreted as relative to the folder where the exe of the app is in. For example, after calling SetVirtualHostNameToFolderMapping("appassets.example", "assets", CoreWebView2HostResourceAccessKind.Deny);, navigating to https://appassets.example/my-local-file.html will show content from my-local-file.html in the assets subfolder located on disk under the same path as the app's executable file. DOM elements that want to reference local files will have their host reference virtual host in the source. If there are multiple folders being used, define one unique virtual host per folder. You should typically choose virtual host names that are never used by real sites. If you own a domain such as example.com, another option is to use a subdomain reserved for the app (like my-app.example.com). [RFC 6761](https://tools.ietf.org/html/rfc6761) has reserved several special-use domain names that are guaranteed to not be used by real sites (for example, .example, .test, and .invalid). Note that using .local as the top-level domain name will work but can cause a delay during navigations. You should avoid using .local if you can. Apps should use distinct domain names when mapping folder from different sources that should be isolated from each other. For instance, the app might use app-file.example for files that ship as part of the app, and book1.example might be used for files containing books from a less trusted source that were previously downloaded and saved to the disk by the app. The host name used in the APIs is canonicalized using Chromium's host name parsing logic before being used internally. For more information see [HTML5 2.6 URLs](https://dev.w3.org/html5/spec-LC/urls.html). All host names that are canonicalized to the same string are considered identical. For example, EXAMPLE.COM and example.com are treated as the same host name. An international host name and its Punycode-encoded host name are considered the same host name. There is no DNS resolution for host name and the trailing '.' is not normalized as part of canonicalization. Therefore example.com and example.com. are treated as different host names. Similarly, virtual-host-name and virtual-host-name.example.com are treated as different host names even if the machine has a DNS suffix of example.com. Specify the minimal cross-origin access necessary to run the app. If there is not a need to access local resources from other origins, use .


            webView.CoreWebView2.SetVirtualHostNameToFolderMapping(
                "appassets.example", "assets", CoreWebView2HostResourceAccessKind.DenyCors);
            webView.Source = new Uri("https://appassets.example/index.html");

This in an example on how to embed a local image. For more information see .


            webView.CoreWebView2.SetVirtualHostNameToFolderMapping(
                "appassets.example", "assets", CoreWebView2HostResourceAccessKind.DenyCors);
            string c_navString = "";
            webview.NavigateToString(c_navString);

Clears a host name mapping for local folder that was added by .

The host name to be removed from the mapping.

FrameCreated is raised when a new iframe is created. Handle this event to get access to objects.

Use the to listen for when this iframe goes away.

DownloadStarting is raised when a download has begun, blocking the default download dialog, but not blocking the progress of the download.

The host can choose to cancel a download, change the result file path, and hide the default download dialog. If download is not handled or canceled, the download is saved to the default path after the event completes with default download dialog shown. :::code language="csharp" source="../code/sample/SampleApps/WebView2WpfBrowser/MainWindow.xaml.cs" id="DownloadStarting":::

ClientCertificateRequested is raised when WebView2 is making a request to an HTTP server that needs a client certificate for HTTP authentication. Read more about HTTP client certificates at [RFC 8446 The Transport Layer Security (TLS) Protocol Version 1.3](https://tools.ietf.org/html/rfc8446).

The host have several options for responding to client certificate requests: Scenario Handled Cancel SelectedCertificate Respond to server with a certificate True False MutuallyTrustedCertificate value Respond to server without certificate True False null Display default client certificate selection dialog prompt False False n/a Cancel the request n/a True n/a If the host don't handle the event, WebView2 will show the default client certificate selection dialog prompt to the user. :::code language="csharp" source="../code/sample/SampleApps/WebView2WpfBrowser/MainWindow.xaml.cs" id="ClientCertificateRequested1"::: :::code language="csharp" source="../code/sample/SampleApps/WebView2WpfBrowser/MainWindow.xaml.cs" id="ClientCertificateRequested2":::

Opens the Browser Task Manager view as a new window in the foreground.

If the Browser Task Manager is already open, this will bring it into the foreground. WebView2 currently blocks the Shift+Esc shortcut for opening the task manager. An end user can open the browser task manager manually via the Browser task manager entry of the DevTools window's title bar's context menu.

Indicates whether all audio output from this CoreWebView2 is muted or not. Set to true will mute this CoreWebView2, and set to false will unmute this CoreWebView2. true if audio is muted.

:::code language="csharp" source="../code/sample/SampleApps/WebView2WpfBrowser/MainWindow.xaml.cs" id="ToggleIsMuted"::: :::code language="csharp" source="../code/sample/SampleApps/WebView2WpfBrowser/MainWindow.xaml.cs" id="UpdateTitleWithMuteState":::

Indicates whether any audio output from this CoreWebView2 is playing. true if audio is playing even if is true.

:::code language="csharp" source="../code/sample/SampleApps/WebView2WpfBrowser/MainWindow.xaml.cs" id="UpdateTitleWithMuteState":::

IsMutedChanged is raised when the mute state changes.

:::code language="csharp" source="../code/sample/SampleApps/WebView2WpfBrowser/MainWindow.xaml.cs" id="IsMutedChanged":::

IsDocumentPlayingAudioChanged is raised when document starts or stops playing audio.

:::code language="csharp" source="../code/sample/SampleApps/WebView2WpfBrowser/MainWindow.xaml.cs" id="IsDocumentPlayingAudioChanged":::

True if the default download dialog is currently open.

The value of this property changes only when the default download dialog is explicitly opened or closed. Hiding the WebView implicitly hides the dialog, but does not change the value of this property. :::code language="csharp" source="../code/sample/SampleApps/WebView2WpfBrowser/MainWindow.xaml.cs" id="ToggleDefaultDownloadDialog":::

The default download dialog corner alignment.

The dialog can be aligned to any of the WebView corners (see ). When the WebView or dialog changes size, the dialog keeps it position relative to the corner. The dialog may become partially or completely outside of the WebView bounds if the WebView is small enough. Set the margin from the corner with the property. :::code language="csharp" source="../code/sample/SampleApps/WebView2WpfBrowser/MainWindow.xaml.cs" id="SetDefaultDownloadDialogPosition":::

The default download dialog margin relative to the WebView corner specified by .

The margin is a point that describes the vertical and horizontal distances between the chosen WebView corner and the default download dialog corner nearest to it. Positive values move the dialog towards the center of the WebView from the chosen WebView corner, and negative values move the dialog away from it. Use (0, 0) to align the dialog to the WebView corner with no margin.

Raised when the property changes.

This event comes after the event. Setting the property disables the default download dialog and ensures that this event is never raised.

Open the default download dialog.

If the dialog is opened before there are recent downloads, the dialog shows all past downloads for the current profile. Otherwise, the dialog shows only the recent downloads with a "See more" button for past downloads. Calling this method raises the event if the dialog was closed. No effect if the dialog is already open.

Close the default download dialog.

Calling this method raises the event if the dialog was open. No effect if the dialog is already closed.

BasicAuthenticationRequested event is raised when WebView encounters a Basic HTTP Authentication request as described in https://developer.mozilla.org/docs/Web/HTTP/Authentication, a Digest HTTP Authentication request as described in https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Authorization#digest, an NTLM authentication or a Proxy Authentication request.

The host can provide a response with credentials for the authentication or cancel the request. If the host sets the Cancel property to false but does not provide either UserName or Password properties on the Response property, then WebView2 will show the default authentication challenge dialog prompt to the user. :::code language="csharp" source="../code/sample/SampleApps/WebView2WpfBrowser/MainWindow.xaml.cs" id="BasicAuthenticationRequested":::

ContextMenuRequested is raised when a context menu is requested by the user and the content inside WebView hasn't disabled context menus.

The host has the option to create their own context menu with the information provided in the event or can add items to or remove items from WebView context menu. If the host doesn't handle the event, WebView will display the default context menu. :::code language="csharp" source="../code/sample/SampleApps/WebView2WpfBrowser/MainWindow.xaml.cs" id="CustomContextMenu":::

Runs an asynchronous DevToolsProtocol method for a specific session of an attached target.

The sessionId for an attached target. null or empty string is treated as the session for the default target for the top page. The full name of the method in the format {domain}.{method}. A JSON formatted string containing the parameters for the corresponding method. A JSON string that represents the method's return object. There could be multiple DevToolsProtocol targets in a WebView. Besides the top level page, iframes from different origin and web workers are also separate targets. Attaching to these targets allows interaction with them. When the DevToolsProtocol is attached to a target, the connection is identified by a sessionId. To use this API, you must set the flatten parameter to true when calling Target.attachToTarget or Target.setAutoAttach DevToolsProtocol method. Using Target.setAutoAttach is recommended as that would allow you to attach to dedicated worker targets, which are not discoverable via other APIs like Target.getTargets. For more information about targets and sessions, navigate to [Chrome DevTools Protocol - Target domain]( https://chromedevtools.github.io/devtools-protocol/tot/Target). For more information about available methods, navigate to [DevTools Protocol Viewer](https://aka.ms/DevToolsProtocolDocs). The handler's Invoke method will be called when the method asynchronously completes. Invoke will be called with the method's return object as a JSON string.

The current text of the statusbar as defined by [Window.statusbar](https://developer.mozilla.org/docs/Web/API/Window/statusbar).

StatusBarTextChanged event is raised when the text in the [Window.statusbar](https://developer.mozilla.org/docs/Web/API/Window/statusbar) changes. When the event is fired use the property to get the current statusbar text.

Events which cause causes can be anything from hover, url events, and others. There is not a finite list on how to cause the statusbar to change. The developer must create the status bar and set the text.

The associated object of .

:::code language="csharp" source="../code/sample/SampleApps/WebView2WpfBrowser/MainWindow.xaml.cs" id="Profile":::

The ServerCertificateErrorDetected event is raised when the WebView2 cannot verify server's digital certificate while loading a web page.

This event will raise for all web resources and follows the event. If you don't handle the event, WebView2 will show the default TLS interstitial error page to the user for navigations, and for non-navigations the web request is cancelled. WebView2 caches the response when action is for the RequestUri's host and the server certificate in the session and the event won't be raised again. To raise the event again you must clear the cache using . :::code language="csharp" source="../code/sample/SampleApps/WebView2WpfBrowser/MainWindow.xaml.cs" id="ServerCertificateErrorDetected":::

Clears all cached decisions to proceed with TLS certificate errors from the event for all WebView2's sharing the same session.

Get the Uri as a string of the current Favicon. This will be an empty string if the page does not have a Favicon.

Raised when the Favicon has changed. This can include when a new page is loaded and thus by default no icon is set or the icon is set for the page by DOM or JavaScript.

The first argument is the Webview2 which saw the changed Favicon and the second is null.

Get the downloaded Favicon image for the current page and copy it to the image stream.

The format to retrieve the Favicon in. An IStream populated with the downloaded Favicon.

Print the current web page asynchronously to the specified printer with the provided settings.

See for description of settings. Passing null for printSettings results in default print settings used. The method will return as if printerName doesn't match with the name of any installed printers on the user OS. The method will throw ArgumentException if the caller provides invalid settings for a given printer. The async Print operation completes when it finishes printing to the printer. Only one Printing operation can be in progress at a time. If Print is called while a or or job is in progress, throws exception. This is only for printing operation on one webview. Error PrintStatus Notes No Print operation succeeded. No If specified printer is not found or printer status is not available, offline or error state. No Print operation is failed. ArgumentException If the caller provides invalid settings for the specified printer. Exception Print operation is failed as printing job already in progress. :::code language="csharp" source="../code/sample/SampleApps/WebView2WpfBrowser/MainWindow.xaml.cs" id="PrintToPrinter":::

Opens the print dialog to print the current web page.

See for descriptions of print dialog kinds. Invoking browser or system print dialog doesn't open new print dialog if it is already open. :::code language="csharp" source="../code/sample/SampleApps/WebView2WpfBrowser/MainWindow.xaml.cs" id="ShowPrintUI":::

Provides the Pdf data of current web page asynchronously for the provided settings.

Stream will be rewound to the start of the pdf data. See for description of settings. Passing null for printSettings results in default print settings used. The async PrintToPdfStream operation completes when it finishes writing to the stream. Only one Printing operation can be in progress at a time. If is called while a or or job is in progress, the throws an exception. This is only for printing operation on one webview. :::code language="csharp" source="../code/sample/SampleApps/WebView2WpfBrowser/MainWindow.xaml.cs" id="PrintToPdfStream":::

Share a shared buffer object with script of the main frame in the WebView.

The object to be shared with script. The desired given to script. Additional data to be send to script. If it is not null or empty string, and it is not a valid JSON string, will be thrown. The script will receive a sharedbufferreceived event from chrome.webview. The event arg for that event will have the following methods and properties. Property Description getBuffer() A method that returns an ArrayBuffer object with the backing content from the shared buffer. additionalData An object as the result of parsing additionalDataAsJson as JSON string. This property will be undefined if additionalDataAsJson is nullptr or empty string. source With a value set as chrome.webview object. If access is , the script will only have read access to the buffer. If the script tries to modify the content in a read only buffer, it will cause an access violation in WebView renderer process and crash the renderer process. If the shared buffer is already closed, the API throws with error code of RO_E_CLOSED. The script code should call chrome.webview.releaseBuffer with the shared buffer as the parameter to release underlying resources as soon as it does not need access to the shared buffer any more. The application can post the same shared buffer object to multiple web pages or iframes, or post to the same web page or iframe multiple times. Each PostSharedBufferToScript will create a separate ArrayBuffer object with its own view of the memory and is separately released. The underlying shared memory will be released when all the views are released. Sharing a buffer to script has security risk. You should only share buffer with trusted site. If a buffer is shared to a untrusted site, possible sensitive information could be leaked. If a buffer is shared as modifiable by the script and the script modifies it in an unexpected way, it could result in corrupted data that might even crash the application. The example code shows how to send data to script for one time read only consumption. :::code language="csharp" source="../code/sample/SampleApps/WebView2WpfBrowser/MainWindow.xaml.cs" id="OneTimeShareBuffer"::: :::code language="csharp" source="../code/sample/SampleApps/WebView2WpfBrowser/assets/sharedBuffer.html" id="ShareBufferScriptCode_1"::: :::code language="csharp" source="../code/sample/SampleApps/WebView2WpfBrowser/assets/sharedBuffer.html" id="ShareBufferScriptCode_2":::

Represents a certificate. Gives access to a certificate's metadata.

Converts this to a X509Certificate2.

An object created using PEM encoded data from this object.

The valid date and time for the certificate since the UNIX epoc.

Subject of the certificate.

Name of the certificate authority that issued the certificate.

Base64 encoding of DER encoded serial number of the certificate. Read more about DER at [RFC 7468 DER](https://tools.ietf.org/html/rfc7468#appendix-B).

Display name for a certificate.

Returns list of PEM encoded certificate issuer chain. In this list first element is the current certificate followed by intermediate1, intermediate2...intermediateN-1. Root certificate is the last element in the list.

PEM encoded data for the certificate. Returns Base64 encoding of DER encoded certificate. Read more about PEM at [RFC 1421 Privacy Enhanced Mail](https://tools.ietf.org/html/rfc1421).

Represents a client certificate. Gives access to a certificate's metadata.

Converts this to a X509Certificate2.

An object created using PEM encoded data from this object.

The valid date and time for the certificate since the UNIX epoc.

Subject of the certificate.

Name of the certificate authority that issued the certificate.

Base64 encoding of DER encoded serial number of the certificate. Read more about DER at [RFC 7468 DER](https://tools.ietf.org/html/rfc7468#appendix-B).

Display name for a certificate.

Returns list of PEM encoded client certificate issuer chain. In this list first element is the current certificate followed by intermediate1, intermediate2...intermediateN-1. Root certificate is the last element in the list.

Kind of a certificate. See for descriptions.

PEM encoded data for the certificate. Returns Base64 encoding of DER encoded certificate. Read more about PEM at [RFC 1421 Privacy Enhanced Mail](https://tools.ietf.org/html/rfc1421).

This class is the owner of the object, and provides support for resizing, showing and hiding, focusing, and other functionality related to windowing and composition.

The owns the , and if all references to the go away, the WebView will be closed.

The owner of the object that provides support for resizing, showing and hiding, focusing, and other functionality related to windowing and composition.

The CoreWebView2Controller owns the , and if all references to the go away, the WebView is closed.