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 = ;
             while (true)
             {
                 var ch = Marshal.ReadByte(ptr, off++);
                 if (ch == )
                 {
                     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 + );
             Marshal.Copy(utf8bytes, , ptr, utf8bytes.Length);
             Marshal.WriteByte(ptr, utf8bytes.Length, );
             return ptr;
         }

         public enum WkeCursorInfo
         {
             WkeCursorInfoPointer = ,
             WkeCursorInfoCross = ,
             WkeCursorInfoHand = ,
             WkeCursorInfoIBeam = ,
             WkeCursorInfoWait = ,
             WkeCursorInfoHelp = ,
             WkeCursorInfoEastResize = ,
             WkeCursorInfoNorthResize = ,
             WkeCursorInfoNorthEastResize = ,
             WkeCursorInfoNorthWestResize = ,
             WkeCursorInfoSouthResize = ,
             WkeCursorInfoSouthEastResize = ,
             WkeCursorInfoSouthWestResize = ,
             WkeCursorInfoWestResize = ,
             WkeCursorInfoNorthSouthResize = ,
             WkeCursorInfoEastWestResize = ,
             WkeCursorInfoNorthEastSouthWestResize = ,
             WkeCursorInfoNorthWestSouthEastResize = ,
             WkeCursorInfoColumnResize = ,
             WkeCursorInfoRowResize = ,
         }
         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 * );
                 }

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

         protected override void OnSizeChanged(EventArgs e)
         {
             base.OnSizeChanged(e);
             if (handle != IntPtr.Zero && Width >  && Height > )
             {
                 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 = ;
             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 = ;
             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, , false);
             }
         }
         protected override void OnKeyPress(KeyPressEventArgs e)
         {
             base.OnKeyPress(e);
             if (handle != IntPtr.Zero)
             {
                 e.Handled = true;
                 MiniblinkPInvoke.wkeFireKeyPressEvent(handle, (uint)e.KeyChar, , false);
             }
         }
         protected override void OnKeyUp(KeyEventArgs e)
         {
             base.OnKeyUp(e);
             if (handle != IntPtr.Zero)
             {
                 MiniblinkPInvoke.wkeFireKeyUpEvent(handle, (uint)e.KeyValue, , 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 = ;
             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定义的