C# 封装miniblink 使用HTML/CSS/JS来构建.Net 应用程序界面和简易浏览器

MiniBlink的作者是 龙泉寺扫地僧

miniblink是什么？   (抄了一下 龙泉寺扫地僧 写的简洁)

Miniblink是一个全新的、追求极致小巧的浏览器内核项目，
其基于chromium最新版内核，去除了chromium所有多余的部件，只保留最基本的排版引擎blink。
Miniblink保持了10M左右的极简大小，是所有同类产品最小的体积，同时支持windows xp、npapi。

为什么要做miniblink？

市面上作为嵌入的组件的可用的浏览器内核，不外乎这几个：webkit、cef、nwjs、electron。

cef：优点是由于集成的chromium内核，所以对H5支持的很全，同时因为使用的人也多，各种教程、示例，资源很多。但缺点很明显，太大了。最新的cef已经夸张到了100多M，还要带一堆的文件。同时新的cef已经不支持xp了（chromium对应版本是M49）。而且由于是多进程架构，对资源的消耗也很夸张。如果只是想做个小软件，一坨文件需要带上、超大的安装包，显然不能忍受。

nwjs，或者最近大火的electron：和cef内核类似，都是chromium内核。缺点和cef一模一样。优点是由于可以使用nodejs的资源，同时又自带了各种api的绑定，所以可以用的周边资源非常丰富；而基于js的开发方案，使得前端很容易上手。所以最近N多项目都是基于nwjs或electron来实现。例如vscode，atom等等。

原版webkit：现在官网还在更新windows port，但显然漫不在心，而且最新的webkit也很大了，超过20几M。最关键的是，周边资源很少，几乎没人再基于webkit来做开发。同时由于windows版的saferi已经停止开发了，所以用webkit就用不了他的dev tools了。这是个大遗憾。

WKE：这是个很老的webkit内核的裁剪版了。小是小，但bug太多了。

那么关键点来了，使用miniblink有啥好处呢？？

首先，miniblink对大小要求非常严格。原版chromium、blink里对排版渲染没啥大用的如音视频全都被砍了，只专注于网页的排版和渲染。甚至为了裁剪大小，我不惜使用vc6的crt来跑mininblink。这个也算前无古人后无来者了。

其次，miniblink紧跟最新chromium，这意味着chromium相关的资源都可以利用。在未来的规划里，我是打算把electron的接口也加上的，这样可以无缝替换electron。使用miniblink的话，开发调试时用原版electron，发布的时候再替换掉那些dll，直接可以无缝切换，非常方便。

 

miniblink如何裁剪到这么小？

这个比较复杂了。主要就是把blink从chromium抽离了出来，同时补上了cc层（硬件渲染层）。现在的blink，已经不是当年的那个webkit了，渲染部分全走cc层，复杂无比。我这大半年都在重写他那个蛋疼又复杂的cc层。

和webkit比，miniblink架构有什么优势

现在的webkit版本，已经比miniblink落后太多了。blink一直在加入各种极富创造力和想象力的功能、组件。例如，blink早就加入多线程解析html token、blink gc回收器、多线程录制回放渲染机制。这些能让blink的解析渲染速度极大提升。下一次，我会先开源出blink gc组件，这东西很有意思，在c++里硬是搞出了一个垃圾回收机制，能让你像写java一样写c++。

miniblink 开源地址：https://github.com/weolar/miniblink49

我们可以通过miniblink做桌面应用的UI，超小的附加dll，压缩之后大约5M，比起Cefsharp 小太多了。VSCode也是用  Electron 网页开发的

Html开发UI和WPF对比有什么优势？

1、 Html 前端资源丰富，各种框架

2、 会Html的人比会WPF的人多太多了，入门简单

3、.Net2.0照样可以用

4、网站和桌面程序界面可以统一，甚至大部分前端代码复用

资源消耗方面，和WPF差不多，毕竟浏览器也是内存消耗大户

不过对比electron 这种纯 Html CSS + js的，我更喜欢 用C# 代替JS 做业务逻辑，我感觉JS写大项目 代码比较乱，维护比C#麻烦。所以 JS做前端辅助比较合适，业务逻辑用C#实现

接下来，我写个简单的MiniBlink封装案例！更多功能你们可以自行封装 或者 看看 DSkin

采用 PInvoke 和Winform封装方式，MiniBlink对外提供的接口主要在 wke.h ，miniblink 的dll可以通过GitHub源码编译出来。具体封装规则，你们可以百度查查看

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;
//by:DSkin

namespace MiniBlink
{
    public static class MiniblinkPInvoke
    {
        const string miniblinkdll = "node.dll";


        [DllImport(miniblinkdll, CallingConvention = CallingConvention.Cdecl)]
        public static extern void wkeSetHandle(IntPtr webView, IntPtr wnd);

        [DllImport(miniblinkdll, CharSet = CharSet.Unicode)]
        public static extern IntPtr wkeGetStringW(IntPtr @string);

        [DllImport(miniblinkdll, CharSet = CharSet.Unicode)]
        public static extern IntPtr wkeToStringW(IntPtr @string);

        [DllImport(miniblinkdll, CallingConvention = CallingConvention.Cdecl)]
        public static extern IntPtr wkeGetString(IntPtr @string);

        [DllImport(miniblinkdll)]
        public static extern void wkeSetDebugConfig(IntPtr webView, string debugString, IntPtr param);

        [DllImport(miniblinkdll)]
        public static extern Int64 wkeRunJSW(IntPtr webView, [In] [MarshalAs(UnmanagedType.LPWStr)] string script);

        [return: MarshalAs(UnmanagedType.I1)]
        [DllImport(miniblinkdll, CallingConvention = CallingConvention.Cdecl)]
        public static extern bool wkeFireMouseEvent(IntPtr webView, uint message, int x, int y, uint flags);

        [return: MarshalAs(UnmanagedType.I1)]
        [DllImport(miniblinkdll, CallingConvention = CallingConvention.Cdecl)]
        public static extern bool wkeFireMouseWheelEvent(IntPtr webView, int x, int y, int delta, uint flags);

        [DllImport(miniblinkdll, CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.I1)]
        public static extern bool wkeFireKeyUpEvent(IntPtr webView, uint virtualKeyCode, uint flags, [MarshalAs(UnmanagedType.I1)] bool systemKey);

        [return: MarshalAs(UnmanagedType.I1)]
        [DllImport(miniblinkdll, CallingConvention = CallingConvention.Cdecl)]
        public static extern bool wkeFireKeyDownEvent(IntPtr webView, uint virtualKeyCode, uint flags, [MarshalAs(UnmanagedType.I1)] bool systemKey);

        [DllImport(miniblinkdll, CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.I1)]
        public static extern bool wkeFireKeyPressEvent(IntPtr webView, uint charCode, uint flags, [MarshalAs(UnmanagedType.I1)] bool systemKey);

        [DllImport(miniblinkdll, CallingConvention = CallingConvention.Cdecl)]
        public static extern void wkeSetFocus(IntPtr webView);

        [DllImport(miniblinkdll, CallingConvention = CallingConvention.Cdecl)]
        public static extern void wkeKillFocus(IntPtr webView);

        [DllImport(miniblinkdll, CallingConvention = CallingConvention.Cdecl)]
        public static extern void wkeResize(IntPtr webView, int w, int h);

        [DllImport(miniblinkdll)]
        public static extern IntPtr wkeCreateWebView();

        [DllImport(miniblinkdll, CallingConvention = CallingConvention.Cdecl)]
        public static extern void wkeDestroyWebView(IntPtr webView);

        [DllImport(miniblinkdll)]
        public static extern void wkeInitialize();

        [DllImport(miniblinkdll)]
        public static extern void wkeLoadFile(IntPtr webView, [In, MarshalAs(UnmanagedType.LPWStr)] string filename);

        [DllImport(miniblinkdll)]
        public static extern void wkeLoadHTML(System.IntPtr webView, [In()] [MarshalAs(UnmanagedType.LPStr)] string html);

        [DllImport(miniblinkdll, CallingConvention = CallingConvention.Cdecl)]
        public static extern void wkeOnURLChanged2(IntPtr webView, UrlChangedCallback2 callback, IntPtr callbackParam);

        [DllImport(miniblinkdll, CharSet = CharSet.Auto, CallingConvention = CallingConvention.Cdecl)]
        public static extern void wkeLoadURLW(IntPtr webView, [In, MarshalAs(UnmanagedType.LPWStr)] string url);

        [DllImport(miniblinkdll, CallingConvention = CallingConvention.Cdecl)]
        public static extern void wkeOnPaintUpdated(IntPtr webView, wkePaintUpdatedCallback callback, IntPtr callbackParam);

        [DllImport(miniblinkdll, CallingConvention = CallingConvention.Cdecl)]
        public static extern void wkePaint(IntPtr webView, IntPtr bits, int pitch);
        [DllImport(miniblinkdll, CallingConvention = CallingConvention.Cdecl)]
        public static extern WkeCursorInfo wkeGetCursorInfoType(IntPtr webView);

        public static string Utf8IntptrToString(this IntPtr ptr)
        {
            var data = new List<byte>();
            var off = 0;
            while (true)
            {
                var ch = Marshal.ReadByte(ptr, off++);
                if (ch == 0)
                {
                    break;
                }
                data.Add(ch);
            }
            return Encoding.UTF8.GetString(data.ToArray());
        }
　　　　　//调用这个之后要手动调用  Marshal.FreeHGlobal(ptr);
        public static IntPtr Utf8StringToIntptr(this string str)
        {
            byte[] utf8bytes = Encoding.UTF8.GetBytes(str);
            IntPtr ptr = Marshal.AllocHGlobal(utf8bytes.Length + 1);
            Marshal.Copy(utf8bytes, 0, ptr, utf8bytes.Length);
            Marshal.WriteByte(ptr, utf8bytes.Length, 0);
            return ptr;
        }


        public enum WkeCursorInfo
        {
            WkeCursorInfoPointer = 0,
            WkeCursorInfoCross = 1,
            WkeCursorInfoHand = 2,
            WkeCursorInfoIBeam = 3,
            WkeCursorInfoWait = 4,
            WkeCursorInfoHelp = 5,
            WkeCursorInfoEastResize = 6,
            WkeCursorInfoNorthResize = 7,
            WkeCursorInfoNorthEastResize = 8,
            WkeCursorInfoNorthWestResize = 9,
            WkeCursorInfoSouthResize = 10,
            WkeCursorInfoSouthEastResize = 11,
            WkeCursorInfoSouthWestResize = 12,
            WkeCursorInfoWestResize = 13,
            WkeCursorInfoNorthSouthResize = 14,
            WkeCursorInfoEastWestResize = 15,
            WkeCursorInfoNorthEastSouthWestResize = 16,
            WkeCursorInfoNorthWestSouthEastResize = 17,
            WkeCursorInfoColumnResize = 18,
            WkeCursorInfoRowResize = 19,
        }
        public enum wkeMouseMessage : uint
        {
            WKE_MSG_MOUSEMOVE = 0x0200,
            WKE_MSG_LBUTTONDOWN = 0x0201,
            WKE_MSG_LBUTTONUP = 0x0202,
            WKE_MSG_LBUTTONDBLCLK = 0x0203,
            WKE_MSG_RBUTTONDOWN = 0x0204,
            WKE_MSG_RBUTTONUP = 0x0205,
            WKE_MSG_RBUTTONDBLCLK = 0x0206,
            WKE_MSG_MBUTTONDOWN = 0x0207,
            WKE_MSG_MBUTTONUP = 0x0208,
            WKE_MSG_MBUTTONDBLCLK = 0x0209,
            WKE_MSG_MOUSEWHEEL = 0x020A,
        }
        public enum wkeMouseFlags
        {
            WKE_LBUTTON = 0x01,
            WKE_RBUTTON = 0x02,
            WKE_SHIFT = 0x04,
            WKE_CONTROL = 0x08,
            WKE_MBUTTON = 0x10,
        }


        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        public delegate void wkePaintUpdatedCallback(IntPtr webView, IntPtr param, IntPtr hdc, int x, int y, int cx, int cy);

        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        public delegate void UrlChangedCallback2(IntPtr webView, IntPtr param, IntPtr frameId, IntPtr url);
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text;
using System.Text.RegularExpressions;
using System.Windows.Forms;
//by:DSkin

namespace MiniBlink
{
    public class TestControl : Control
    {
        IntPtr handle = IntPtr.Zero;
        string url = string.Empty;

        IntPtr bits = IntPtr.Zero;
        Size oldSize;
        MiniblinkPInvoke.UrlChangedCallback2 UrlChangedCallback2;
        MiniblinkPInvoke.wkePaintUpdatedCallback wkePaintUpdatedCallback;

        public TestControl()
        {
            SetStyle(ControlStyles.OptimizedDoubleBuffer |
            ControlStyles.DoubleBuffer |
            ControlStyles.AllPaintingInWmPaint |
            ControlStyles.ResizeRedraw |
            ControlStyles.UserPaint, true);
        }

        public string Url
        {
            get
            {
                return url;
            }

            set
            {
                url = value;
                if (handle != IntPtr.Zero)
                {
                    MiniblinkPInvoke.wkeLoadURLW(handle, value);
                }
            }
        }

        protected override void OnCreateControl()
        {
            base.OnCreateControl();
            if (!DesignMode)
            {
                MiniblinkPInvoke.wkeInitialize();
                handle = MiniblinkPInvoke.wkeCreateWebView();//创建 WebView
                MiniblinkPInvoke.wkeSetHandle(handle, this.Handle);
                MiniblinkPInvoke.wkeResize(handle, Width, Height);

                UrlChangedCallback2 = (webView, param, frameId, url) =>
                {
                    this.url = MiniblinkPInvoke.wkeGetString(url).Utf8IntptrToString();
                    OnUrlChanged(EventArgs.Empty);
                };
                MiniblinkPInvoke.wkeOnURLChanged2(handle, UrlChangedCallback2, IntPtr.Zero);

                wkePaintUpdatedCallback = (IntPtr webView, IntPtr param, IntPtr hdc, int x, int y, int cx, int cy) =>
                {
                    Invalidate();
                };
                MiniblinkPInvoke.wkeOnPaintUpdated(handle, wkePaintUpdatedCallback, IntPtr.Zero);

                Url = url;
            }
        }

        protected override void OnPaint(PaintEventArgs e)
        {
            if (handle != IntPtr.Zero)
            {
                if (bits == IntPtr.Zero || oldSize != Size)
                {
                    if (bits != IntPtr.Zero)
                    {
                        Marshal.FreeHGlobal(bits);
                    }
                    oldSize = Size;
                    bits = Marshal.AllocHGlobal(Width * Height * 4);
                }

                MiniblinkPInvoke.wkePaint(handle, bits, 0);
                using (Bitmap bmp = new Bitmap(Width, Height, Width * 4, PixelFormat.Format32bppPArgb, bits))
                {
                    e.Graphics.DrawImage(bmp, 0, 0);
                }
            }
            base.OnPaint(e);
            if (DesignMode)
            {
                e.Graphics.DrawString("MiniBlinkBrowser", this.Font, Brushes.Red, new Point());
                e.Graphics.DrawRectangle(Pens.Black, new Rectangle(0, 0, Width - 1, Height - 1));
            }
        }

        protected override void OnSizeChanged(EventArgs e)
        {
            base.OnSizeChanged(e);
            if (handle != IntPtr.Zero && Width > 1 && Height > 1)
            {
                MiniblinkPInvoke.wkeResize(handle, Width, Height);
            }
        }

        protected override void OnMouseWheel(MouseEventArgs e)
        {
            base.OnMouseWheel(e);
            if (handle != IntPtr.Zero)
            {
                uint flags = GetMouseFlags(e);
                MiniblinkPInvoke.wkeFireMouseWheelEvent(handle, e.X, e.Y, e.Delta, flags);
            }
        }
        protected override void OnMouseDown(MouseEventArgs e)
        {
            base.OnMouseDown(e);
            uint msg = 0;
            if (e.Button == MouseButtons.Left)
            {
                msg = (uint)MiniblinkPInvoke.wkeMouseMessage.WKE_MSG_LBUTTONDOWN;
            }
            else if (e.Button == MouseButtons.Middle)
            {
                msg = (uint)MiniblinkPInvoke.wkeMouseMessage.WKE_MSG_MBUTTONDOWN;
            }
            else if (e.Button == MouseButtons.Right)
            {
                msg = (uint)MiniblinkPInvoke.wkeMouseMessage.WKE_MSG_RBUTTONDOWN;
            }
            uint flags = GetMouseFlags(e);
            if (handle != IntPtr.Zero)
            {
                MiniblinkPInvoke.wkeFireMouseEvent(handle, msg, e.X, e.Y, flags);
            }
        }
        protected override void OnMouseUp(MouseEventArgs e)
        {
            base.OnMouseUp(e);
            uint msg = 0;
            if (e.Button == MouseButtons.Left)
            {
                msg = (uint)MiniblinkPInvoke.wkeMouseMessage.WKE_MSG_LBUTTONUP;
            }
            else if (e.Button == MouseButtons.Middle)
            {
                msg = (uint)MiniblinkPInvoke.wkeMouseMessage.WKE_MSG_MBUTTONUP;
            }
            else if (e.Button == MouseButtons.Right)
            {
                msg = (uint)MiniblinkPInvoke.wkeMouseMessage.WKE_MSG_RBUTTONUP;
            }
            uint flags = GetMouseFlags(e);
            if (handle != IntPtr.Zero)
            {
                MiniblinkPInvoke.wkeFireMouseEvent(handle, msg, e.X, e.Y, flags);
            }
        }
        protected override void OnMouseMove(MouseEventArgs e)
        {
            base.OnMouseMove(e);
            if (this.handle != IntPtr.Zero)
            {
                uint flags = GetMouseFlags(e);
                MiniblinkPInvoke.wkeFireMouseEvent(this.handle, 0x200, e.X, e.Y, flags);

                switch (MiniblinkPInvoke.wkeGetCursorInfoType(handle))
                {
                    case MiniblinkPInvoke.WkeCursorInfo.WkeCursorInfoPointer:
                        Cursor = Cursors.Default;
                        break;
                    case MiniblinkPInvoke.WkeCursorInfo.WkeCursorInfoCross:
                        Cursor = Cursors.Cross;
                        break;
                    case MiniblinkPInvoke.WkeCursorInfo.WkeCursorInfoHand:
                        Cursor = Cursors.Hand;
                        break;
                    case MiniblinkPInvoke.WkeCursorInfo.WkeCursorInfoIBeam:
                        Cursor = Cursors.IBeam;
                        break;
                    case MiniblinkPInvoke.WkeCursorInfo.WkeCursorInfoWait:
                        Cursor = Cursors.WaitCursor;
                        break;
                    case MiniblinkPInvoke.WkeCursorInfo.WkeCursorInfoHelp:
                        Cursor = Cursors.Help;
                        break;
                    case MiniblinkPInvoke.WkeCursorInfo.WkeCursorInfoEastResize:
                        Cursor = Cursors.SizeWE;
                        break;
                    case MiniblinkPInvoke.WkeCursorInfo.WkeCursorInfoNorthResize:
                        Cursor = Cursors.SizeNS;
                        break;
                    case MiniblinkPInvoke.WkeCursorInfo.WkeCursorInfoNorthEastResize:
                        Cursor = Cursors.SizeNESW;
                        break;
                    case MiniblinkPInvoke.WkeCursorInfo.WkeCursorInfoNorthWestResize:
                        Cursor = Cursors.SizeNWSE;
                        break;
                    case MiniblinkPInvoke.WkeCursorInfo.WkeCursorInfoSouthResize:
                        Cursor = Cursors.SizeNS;
                        break;
                    case MiniblinkPInvoke.WkeCursorInfo.WkeCursorInfoSouthEastResize:
                        Cursor = Cursors.SizeNWSE;
                        break;
                    case MiniblinkPInvoke.WkeCursorInfo.WkeCursorInfoSouthWestResize:
                        Cursor = Cursors.SizeNESW;
                        break;
                    case MiniblinkPInvoke.WkeCursorInfo.WkeCursorInfoWestResize:
                        Cursor = Cursors.SizeWE;
                        break;
                    case MiniblinkPInvoke.WkeCursorInfo.WkeCursorInfoNorthSouthResize:
                        Cursor = Cursors.SizeNS;
                        break;
                    case MiniblinkPInvoke.WkeCursorInfo.WkeCursorInfoEastWestResize:
                        Cursor = Cursors.SizeWE;
                        break;
                    case MiniblinkPInvoke.WkeCursorInfo.WkeCursorInfoNorthEastSouthWestResize:
                        Cursor = Cursors.SizeAll;
                        break;
                    case MiniblinkPInvoke.WkeCursorInfo.WkeCursorInfoNorthWestSouthEastResize:
                        Cursor = Cursors.SizeAll;
                        break;
                    case MiniblinkPInvoke.WkeCursorInfo.WkeCursorInfoColumnResize:
                        Cursor = Cursors.Default;
                        break;
                    case MiniblinkPInvoke.WkeCursorInfo.WkeCursorInfoRowResize:
                        Cursor = Cursors.Default;
                        break;
                    default:
                        Cursor = Cursors.Default;
                        break;
                }
            }
        }
        protected override void OnKeyDown(KeyEventArgs e)
        {
            base.OnKeyDown(e);
            if (handle != IntPtr.Zero)
            {
                MiniblinkPInvoke.wkeFireKeyDownEvent(handle, (uint)e.KeyValue, 0, false);
            }
        }
        protected override void OnKeyPress(KeyPressEventArgs e)
        {
            base.OnKeyPress(e);
            if (handle != IntPtr.Zero)
            {
                e.Handled = true;
                MiniblinkPInvoke.wkeFireKeyPressEvent(handle, (uint)e.KeyChar, 0, false);
            }
        }
        protected override void OnKeyUp(KeyEventArgs e)
        {
            base.OnKeyUp(e);
            if (handle != IntPtr.Zero)
            {
                MiniblinkPInvoke.wkeFireKeyUpEvent(handle, (uint)e.KeyValue, 0, false);
            }
        }

        protected override void OnGotFocus(EventArgs e)
        {
            base.OnGotFocus(e);
            if (handle != IntPtr.Zero)
            {
                MiniblinkPInvoke.wkeSetFocus(handle);
            }
        }

        protected override void OnLostFocus(EventArgs e)
        {
            base.OnLostFocus(e);
            if (handle != IntPtr.Zero)
            {
                MiniblinkPInvoke.wkeKillFocus(handle);
            }
        }

        protected override void OnPreviewKeyDown(PreviewKeyDownEventArgs e)
        {
            base.OnPreviewKeyDown(e);
            switch (e.KeyCode)
            {
                case Keys.Down:
                case Keys.Up:
                case Keys.Left:
                case Keys.Right:
                case Keys.Tab:
                    e.IsInputKey = true;
                    break;
            }
        }
        private static uint GetMouseFlags(MouseEventArgs e)
        {
            uint flags = 0;
            if (e.Button == MouseButtons.Left)
            {
                flags = flags | (uint)MiniblinkPInvoke.wkeMouseFlags.WKE_LBUTTON;
            }
            if (e.Button == MouseButtons.Middle)
            {
                flags = flags | (uint)MiniblinkPInvoke.wkeMouseFlags.WKE_MBUTTON;
            }
            if (e.Button == MouseButtons.Right)
            {
                flags = flags | (uint)MiniblinkPInvoke.wkeMouseFlags.WKE_RBUTTON;
            }
            if (Control.ModifierKeys == Keys.Control)
            {
                flags = flags | (uint)MiniblinkPInvoke.wkeMouseFlags.WKE_CONTROL;
            }
            if (Control.ModifierKeys == Keys.Shift)
            {
                flags = flags | (uint)MiniblinkPInvoke.wkeMouseFlags.WKE_SHIFT;
            }
            return flags;
        }


        protected override void Dispose(bool disposing)
        {
            base.Dispose(disposing);
            if (handle != IntPtr.Zero)
            {//资源释放
                MiniblinkPInvoke.wkeDestroyWebView(handle);
                handle = IntPtr.Zero;
            }
            if (bits != IntPtr.Zero)
            {
                Marshal.FreeHGlobal(bits);
                bits = IntPtr.Zero;
            }
        }

        public event EventHandler UrlChanged;

        protected virtual void OnUrlChanged(EventArgs e)
        {
            if (UrlChanged != null)
            {
                UrlChanged(this, e);
            }
        }

    }
}

代码写好之后，生成一下，工具箱里就有控件了，然后拖到界面，设置Url，运行就有效果了

如果你想偷懒，要更完整的功能你可以看看 DSKin

DSkin已经封装好 Html构建桌面UI的快捷开发方式，资源内嵌，C#和JS互相调用，无需写麻烦的参数数据转换，通过Vue实现C#属性和页面双向绑定，页面和C#类对应等等，就像WebForm开发。 窗体阴影、系统按钮那些都是Html+CSS定义的