标签：return string -- System new 二次开发 using null Ribbon
菜单选项卡的封装
使用XML来创建选项卡使用案列写在前面，关于文件的说明如下
- 创建一个命令交互类 CommandBase
- 抽象菜单面板基类 IRibbonAbs
- 创建从代码初始化菜单类 RibbonInit
- 创建从配置文件初始化菜单类RibbonInitConfig
- 创建一个借口用于命令绑定 IRibbonUI
- 添加一个XML配置文件 RibbonSetting.xml
- 添加图片文件夹 Images 图片格式为PNG，可以为嵌入资源或者本地文件
示例项目结构
调用方式
using Autodesk.AutoCAD.Runtime;
using Lad.Ribbons;
using System;
using AcadApp = Autodesk.AutoCAD.ApplicationServices.Application;
namespace RibbonDemo
{
/// <summary>
/// 分类管理，所有模块
/// </summary>
public partial class AppManager : IRibbonUI, IExtensionApplication
{
[CommandMethod("Load_RibbonInit")]
public void Initialize()
{
RibbonInitConfig ribbon = new(this, "RibbonDemo.RibbonSetting.xml");
try
{
ribbon.Init();
}
catch (System.Exception e)
{
AcadApp.DocumentManager.MdiActiveDocument.Editor.WriteMessage(e.Message);
}
}
public void Terminate()
{
throw new NotImplementedException();
}
}
/// <summary>
/// 命令
/// </summary>
public partial class AppManager
{
public Action<object> Commond { get; set; } = new Action<object>(e => Console.WriteLine("你好 Commond"));
public static Action<object> CommondSt { get; set; } = new Action<object>(e => Console.WriteLine("你好 CommondSt"));
public Action<object> CommondLambda = e => Console.WriteLine("你好 CommondLambda");
public static Action<object> CommondlambdaSt = e => Console.WriteLine("你好 CommondlambdaSt");
public void CommondMethod(object e)
{
Console.WriteLine("你好CommondMethod");
}
public static void CommondMethodSt(object e)
{
Console.WriteLine("你好CommondMethodSt");
}
}
}
注意：命令只能为一个参数，参数类型为object，返回值为void的方法或委托属性
显示结果如下,这里按钮图片随便找了几个，可以找一些好看的图片放进去
XML文件内容
<?xml version="1.0" encoding="utf-8" ?>
<Ribbon>
<RibbonTab Title="我的选项卡" Id="1001" IsActive="True">
<RibbonPanel Title="按钮组A" Id="10011">
<RibbonButton Text=" 设置 " Id="20001" Size="Large" ShowText="True" ShowImage="True" LargeImage="\Images\设置.png" CommandParameter="Line "
Orientation="Vertical" Command="Commond">
<RibbonToolTip Title="直线" Content="创建直线" Command="Line" ExpandedImage="\Images\按钮E.png"
ExpandedContent="使用LINE命令，可以创建一些连续的直线段，每条直线都是可以单独进行编辑的对象。"/>
</RibbonButton>
<RibbonButton Text=" 按钮E " Id="20002" Size="Large" ShowText="True" ShowImage="True" LargeImage="\Images\按钮E.png" CommandParameter="Line "
Orientation="Vertical" Command="Commond"/>
<RibbonButton Text=" 按钮F " Id="20003" Size="Large" ShowText="True" ShowImage="True" LargeImage="\Images\按钮F.png" CommandParameter="Line "
Orientation="Vertical" Command="CommondSt"/>
<RibbonButton Text=" 按钮G " Id="20004" Size="Large" ShowText="True" ShowImage="True" LargeImage="\Images\按钮G.png" CommandParameter="Line "
Orientation="Vertical" Command="CommondLambda"/>
<RibbonButton Text=" 按钮H " Id="20005" Size="Large" ShowText="True" ShowImage="True" LargeImage="\Images\按钮H.png" CommandParameter="Line "
Orientation="Vertical" Command="CommondLambdaSt"/>
<RibbonButton Text=" 按钮I " Id="20006" Size="Large" ShowText="True" ShowImage="True" LargeImage="\Images\按钮I.png" CommandParameter="Line "
Orientation="Vertical" Command="CommondMethod"/>
</RibbonPanel>
<RibbonPanel Title="按钮组B" Id="10012">
<RibbonButton Text=" 图形检查 " Id="20007" Size="Large" ShowText="True" ShowImage="True" LargeImage="\Images\图形检查.png"
Orientation="Vertical" Command="CommondMethodSt"/>
<RibbonButton Text=" 删除检查标记 " Id="20008" Size="Large" ShowText="True" ShowImage="True" LargeImage="\Images\删除.png"
Orientation="Vertical"/>
</RibbonPanel>
<RibbonPanel Title="按钮组C" Id="10013" IsVisible="True" IsEnabled="False">
<RibbonButton Text=" 设置 " Id="20009" Size="Large" ShowText="True" ShowImage="True" LargeImage="\Images\设置.png"
Orientation="Vertical"/>
<RibbonButton Text=" 按钮A " Id="20010" Size="Large" ShowText="True" ShowImage="True" LargeImage="\Images\按钮A.png"
Orientation="Vertical"/>
<RibbonButton Text=" 按钮B " Id="20011" Size="Large" ShowText="True" ShowImage="True" LargeImage="\Images\按钮B.png"
Orientation="Vertical"/>
<RibbonButton Text=" 按钮C " Id="20012" Size="Large" ShowText="True" ShowImage="True" LargeImage="\Images\按钮I.png"
Orientation="Vertical"/>
<RibbonButton Text=" 按钮D " Id="20013" Size="Large" ShowText="True" ShowImage="True" LargeImage="\Images\按钮E.png"
Orientation="Vertical"/>
</RibbonPanel>
</RibbonTab>
</Ribbon>
命令基类
/// <summary>
/// 命令交互基础类
/// </summary>
internal class CommandBase : System.Windows.Input.ICommand
{
public event EventHandler CanExecuteChanged;
/// <summary>
/// 是否可执行，通用方法，传入委托
/// </summary>
/// <param name="parameter"></param>
/// <returns></returns>
public bool CanExecute(object parameter)
{
//方法为True返回True,其它情况都返回False
return DoCanExecute?.Invoke(parameter) == true;
}
/// <summary>
/// 执行
/// </summary>
/// <param name="parameter"></param>
public void Execute(object parameter)
{
//如果不为空，执行委托
DoExecute?.Invoke(parameter);
}
public Action<object> DoExecute { get; set; }
public Func<object, bool> DoCanExecute { get; set; }
}
菜单抽象类
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.Windows;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Lad.Ribbons
{
/// <summary>
/// 菜单抽象类
/// </summary>
public abstract class IRibbonAbs
{
internal RibbonTab? Tab;
internal string Title;
internal string Id;
protected IRibbonAbs(string title, string id) { Title = title; Id = id; }
internal IRibbonAbs() { Tab = null; Title = string.Empty; Id = string.Empty; }
#region 面板
/// <summary>
/// 将面板添加到RibbonTab
/// </summary>
/// <param name="panel">面板</param>
/// <returns>添加后的RibbonPanel，如果RibbonTab中存在ID相同的RibbonPanel，则返回查找到的RibbonPanel</returns>
internal RibbonPanel AddPanel(RibbonPanel panel)
{
if (Tab == null)
throw new ArgumentNullException(nameof(Tab));
if (string.IsNullOrWhiteSpace(panel.Source.Id))
{
Tab.Panels.Add(panel);
return panel;
}
var temp = Tab.FindPanel(panel.Source.Id);
if (temp == null)
Tab.Panels.Add(panel);
else
panel = temp;
return panel;
}
/// <summary>
/// 根据名称查找面板功能组
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
internal RibbonPanel? FindPanelFrom(string name)
{
if (string.IsNullOrWhiteSpace(name)) return null;
return Tab?.Panels.Where(p => p.Source.Title == name).FirstOrDefault();
}
#endregion
#region 按钮
/// <summary>
/// 添加提示信息
/// </summary>
/// <param name="ribbon">按钮条目</param>
/// <param name="title">标题，like"直线"</param>
/// <param name="content">提示内容，like"创建直线段"</param>
/// <param name="command">命令快捷键，like"Line"</param>
/// <param name="expandedContent">扩展提示内容，like"使用LINE命令，可以创建一些连续的直线段，每条直线都是可以单独进行编辑的对象。"</param>
/// <param name="image ">扩展提示图片</param>
public void SetRibbonItemToolTip(RibbonItem ribbon, string title, object content, string command, object? expandedContent = default,
System.Windows.Media.ImageSource? image = default)
{
if (ribbon == null) return;
//添加提示对象
RibbonToolTip toolTip = new RibbonToolTip()
{
Title = title,
Content = content,
Command = command,
ExpandedContent = expandedContent
};
if (image != null)
toolTip.ExpandedImage = image;
ribbon.ToolTip = toolTip;
}
#endregion
/// <summary>
/// 从菜单控制器初始化菜单
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="ribbon"></param>
/// <param name="action"></param>
internal void InitRibbon(Action<RibbonControl> action)
{
//程序空闲时触发的事件
void LoadRibbonMenuOnIdle(object sender, EventArgs e)
{
var ribbonControl = Autodesk.Windows.ComponentManager.Ribbon;
if (ribbonControl != null)
{
Application.Idle -= LoadRibbonMenuOnIdle;
// Load Ribbon/Menu
action?.Invoke(ribbonControl);
if (Tab != null)
ribbonControl.ActiveTab = Tab;
}
}
Application.Idle += LoadRibbonMenuOnIdle;
//启动程序激活菜单的事件
void ComponentManager_ItemInitialized(object sender, RibbonItemEventArgs e)
{
if (Autodesk.Windows.ComponentManager.Ribbon != null)
Autodesk.Windows.ComponentManager.ItemInitialized -= new EventHandler<RibbonItemEventArgs>(ComponentManager_ItemInitialized);
}
if (Autodesk.Windows.ComponentManager.Ribbon == null)
Autodesk.Windows.ComponentManager.ItemInitialized += ComponentManager_ItemInitialized;
}
}
}
创建一个空接口
namespace Lad.Ribbons
{
/// <summary>
/// 从配置文件初始化菜单的调用对象需要继承当前接口
/// </summary>
public interface IRibbonUI
{
}
}
创建初始化菜单的类
using Autodesk.Windows;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Windows.Media.Imaging;
using System.Xml;
namespace Lad.Ribbons
{
/// <summary>
/// 从配置文件初始化菜单
/// </summary>
public class RibbonInitConfig : IRibbonAbs
{
private RibbonControl? control;
private IRibbonUI ribbon;
private Assembly? asm;
private string configPath;
private Type? RibbonType;
protected Action<object> CommandBase = e => System.Windows.MessageBox.Show("未绑定命令");
public RibbonInitConfig(IRibbonUI ribbonUI, string configPath) : base()
{
this.ribbon = ribbonUI;
this.RibbonType = ribbonUI.GetType();
this.asm = Assembly.GetAssembly(RibbonType);
this.configPath = configPath;
}
#region 功能区回调
const string RibbonRootNode = "Ribbon";
const string RibbonTabNode = "RibbonTab";
const string RibbonPanelNode = "RibbonPanel";
const string RibbonItemNodeName = "RibbonButton";
const string CommondAttribute = "Command";
const string RibbonToolTipNode = "RibbonToolTip";
public void Init()
{
this.InitRibbon(control =>
{
this.control = control;
var xdoc = GetResourceXmlDoc(asm, configPath);
foreach (var tab in InitRibbonTabs(xdoc))
{
this.Tab = tab.Tab;
foreach (var panel in InitRibbonPanels(tab.Node))
{
var tempPanel = panel.Panel;
foreach (var btnItem in InitRibbonItems(panel.Node))
{
if (btnItem.Item == null) continue;
RibbonItem? tempBtn = null;
if ((tempBtn = tempPanel.Source.Items.Where(b => b.Text == btnItem.Item.Text).FirstOrDefault()) != null)
tempPanel.Source.Items.Remove(tempBtn);
btnItem.Item.ToolTip = InitRibbonToolTip(btnItem.Node);
tempPanel.Source.Items.Add(btnItem.Item);
}
}
}
});
}
#endregion
#region Ribbon帮助
/// <summary>
/// 初始化选项卡
/// </summary>
/// <param name="xmlDoc"></param>
/// <returns></returns>
IEnumerable<(RibbonTab Tab, XmlNode Node)> InitRibbonTabs(XmlDocument? xmlDoc)
{
return xmlDoc?.SelectNodes($"/{RibbonRootNode}/{RibbonTabNode}")?.ForEach().Select(xmlNode =>
{
RibbonTab? temp = (!string.IsNullOrWhiteSpace(xmlNode.Attributes["Id"]?.Value) ? control?.FindTab(xmlNode.Attributes["Id"]?.Value) : null);
bool isNew = temp == null;
RibbonTab ribbonTab = temp ?? new RibbonTab();
foreach (XmlAttribute attribute in xmlNode.Attributes)
SetProperty(ribbonTab, attribute);
if (isNew) control?.Tabs.Add(ribbonTab);
return (ribbonTab, xmlNode);
}) ?? Enumerable.Empty<(RibbonTab Tab, XmlNode Node)>();
}
/// <summary>
/// 初始化面板
/// </summary>
/// <param name="xmlNode"></param>
/// <returns></returns>
IEnumerable<(RibbonPanel Panel, XmlNode Node)> InitRibbonPanels(XmlNode xmlNode)
{
return xmlNode?.SelectNodes(RibbonPanelNode)?.ForEach().Select(node =>
{
RibbonPanel? temp = (!string.IsNullOrWhiteSpace(node.Attributes["Id"]?.Value) ? this.Tab?.FindPanel(node.Attributes["Id"]?.Value) : null);
bool isNew = temp == null;
RibbonPanel panel = temp ?? new();
RibbonPanelSource panelSource = panel.Source ?? new();
foreach (XmlAttribute panelAttribute in node.Attributes)
SetProperty(panelSource, panelAttribute);
if (isNew)
{
panel.Source = panelSource;
this.Tab?.Panels.Add(panel);
}
return (panel, node);
}) ?? Enumerable.Empty<(RibbonPanel? Panel, XmlNode Node)>();
}
/// <summary>
/// 初始化RibbonItem
/// </summary>
/// <param name="xmlNode"></param>
/// <returns></returns>
IEnumerable<(RibbonItem? Item, XmlNode Node)> InitRibbonItems(XmlNode xmlNode)
{
if (RibbonType == null) return Enumerable.Empty<(RibbonItem? Item, XmlNode Node)>();
return xmlNode?.SelectNodes(RibbonItemNodeName)?.ForEach().Select(node =>
{
var type = Assembly.GetAssembly(typeof(RibbonItem)).GetType($"Autodesk.Windows.{node.Name}");
if (type != null)
{
var ribbonButton = System.Activator.CreateInstance(type);
//设置RibbonItem的属性
foreach (XmlAttribute btnAttribute in node.Attributes)
{
if (string.IsNullOrWhiteSpace(btnAttribute.Value)) continue;
//根据特性名判断是否为命令
if (CommondAttribute == btnAttribute.Name && typeof(RibbonCommandItem).IsAssignableFrom(type))
{
var proinfo = type.GetProperty(RibbonCommandItem.CommandHandlerPropertyName);
var commodMethod = (RibbonType.GetMethods().Where(m => m.Name == btnAttribute.Value && m.GetParameters().Length == 1
&& m.GetParameters()[0].ParameterType == typeof(object)).FirstOrDefault());
Action<object>? doExecute = null;
if (commodMethod == null)
{
var pinfoMethod = RibbonType.GetProperties().Where(p => p.Name == btnAttribute.Value && typeof(Action<object>)
.IsAssignableFrom(p.PropertyType)).FirstOrDefault()?.GetGetMethod();// 判断是否存在委托类型的属性
if (pinfoMethod != null)
doExecute = pinfoMethod.Invoke(pinfoMethod.IsStatic ? null : ribbon, null) as Action<object>;
}
else
doExecute = Delegate.CreateDelegate(typeof(Action<object>), commodMethod.IsStatic ? null : ribbon, commodMethod) as Action<object>;
proinfo.SetValue(ribbonButton, new CommandBase() { DoCanExecute = e => true, DoExecute = doExecute ?? CommandBase }, null);
}
//根据特性名称获取对应的属性
if (CommondAttribute != btnAttribute.Name)
{
var propertyInfo = type.GetProperty(btnAttribute.Name);
if (propertyInfo == null) continue;
if (propertyInfo.PropertyType.Equals(typeof(System.Windows.Media.ImageSource)))
{
BitmapImage? image;
if ((image = GetImageResource(asm, btnAttribute.Value)) != null)
propertyInfo.SetValue(ribbonButton, image, null);
}
else
propertyInfo.SetValue(ribbonButton, propertyInfo.PropertyType.IsEnum ? Enum.Parse(propertyInfo.PropertyType, btnAttribute.Value)
: Convert.ChangeType(btnAttribute.Value, propertyInfo.PropertyType), null);
}
}
return (ribbonButton as RibbonItem, node);
}
return (default, node);
}) ?? Enumerable.Empty<(RibbonItem? Item, XmlNode Node)>();
}
/// <summary>
/// 初始化提示
/// </summary>
/// <param name="xmlNode"></param>
/// <returns></returns>
RibbonToolTip? InitRibbonToolTip(XmlNode xmlNode)
{
var node = xmlNode?.SelectSingleNode(RibbonToolTipNode);
if (node == null) return null;
RibbonToolTip toolTip = new();
foreach (XmlAttribute attribute in node.Attributes)
{
var propertyInfo = typeof(RibbonToolTip).GetProperty(attribute.Name);
if (propertyInfo == null) continue;
if (propertyInfo.PropertyType.Equals(typeof(System.Windows.Media.ImageSource)))
{
BitmapImage? image;
if ((image = GetImageResource(asm, attribute.Value)) != null)
propertyInfo.SetValue(toolTip, image, null);
}
else
propertyInfo.SetValue(toolTip, propertyInfo.PropertyType.IsEnum ? Enum.Parse(propertyInfo.PropertyType, attribute.Value)
: Convert.ChangeType(attribute.Value, propertyInfo.PropertyType), null);
}
return toolTip;
}
/// <summary>
/// 根据节点属性设置对象的属性
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="info">实例对象</param>
/// <param name="attribute"></param>
void SetProperty<T>(T info, XmlAttribute attribute) where T : class
{
var propertyInfo = typeof(T).GetProperty(attribute.Name);
propertyInfo?.SetValue(info, propertyInfo.PropertyType.IsEnum ? Enum.Parse(propertyInfo.PropertyType, attribute.Value)
: Convert.ChangeType(attribute.Value, propertyInfo.PropertyType), null);
}
#endregion
#region 帮助器
/// <summary>
/// 获取程序集的资源图片
/// </summary>
/// <param name="asm"></param>
/// <param name="resourceName">图片路径</param>
/// <returns></returns>
private BitmapImage? GetImageResource(Assembly? asm, string resourceName)
{
if (string.IsNullOrWhiteSpace(resourceName) || asm == null) return null;
var resourcefileName = asm.GetManifestResourceNames()
.Where(s => s.Contains(resourceName.Replace(@"\", ".")))
.FirstOrDefault();
if (!string.IsNullOrWhiteSpace(resourcefileName))
return RibbonExtensions.SteamToBitmapImage(asm.GetManifestResourceStream(resourcefileName));
if (!string.IsNullOrWhiteSpace(asm.Location) && !string.IsNullOrEmpty(resourceName))
{
var dirPath = Directory.GetParent(asm.Location).FullName;
if (File.Exists(dirPath + resourceName))
return new(new(dirPath + resourceName));
if (dirPath.DirExists(resourceName.Substring(resourceName.LastIndexOf(@"\") + 1), out var path))
return new(new(path));
}
return null;
}
/// <summary>
/// 获取调用程序集的配置文档
/// </summary>
/// <param name="asm"></param>
/// <param name="resourceName"></param>
/// <returns></returns>
private XmlDocument? GetResourceXmlDoc(Assembly? asm, string resourceName)
{
if (asm != null)
{
var resourcefileName = asm.GetManifestResourceNames()
.Where(s => string.Compare(resourceName, s, StringComparison.OrdinalIgnoreCase) == 0)
.FirstOrDefault();
if (!string.IsNullOrWhiteSpace(resourcefileName))
{
using (StreamReader resourceReader = new StreamReader(asm.GetManifestResourceStream(resourcefileName)))
{
if (resourceReader != null)
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(resourceReader);
return xmlDoc;
}
}
}
}
return null;
}
#endregion
}
}
扩展函数
using Autodesk.Windows;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Windows.Media.Imaging;
using System.Xml;
namespace Lad.Ribbons
{
public static class RibbonExtensions
{
/// <summary>
/// 遍历节点
/// </summary>
/// <param name="nodeList"></param>
/// <returns></returns>
internal static IEnumerable<XmlNode> ForEach(this XmlNodeList nodeList)
{
foreach (XmlNode node in nodeList)
yield return node;
}
internal static BitmapImage? SteamToBitmapImage(Stream stream)
{
return stream == null ? null : BitmapToBitmapImage(new(stream));
}
// Bitmap --> BitmapImage
internal static BitmapImage? BitmapToBitmapImage(System.Drawing.Bitmap bitmap)
{
if (bitmap == null)
return null;
using (MemoryStream stream = new MemoryStream())
{
bitmap.Save(stream, System.Drawing.Imaging.ImageFormat.Png); // 坑点：格式选Bmp时，不带透明度
stream.Position = 0;
BitmapImage result = new BitmapImage();
result.BeginInit();
// According to MSDN, "The default OnDemand cache option retains access to the stream until the image is needed."
// Force the bitmap to load right now so we can dispose the stream.
result.CacheOption = BitmapCacheOption.OnLoad;
result.StreamSource = stream;
result.EndInit();
result.Freeze();
return result;
}
}
/// <summary>
/// 面板中添加功能按钮
/// </summary>
/// <param name="panel"></param>
/// <param name="ribbonItems">按钮组</param>
public static void AddRibbonItems(this RibbonPanel panel, params RibbonItem[] ribbonItems)
{
if (panel == null) throw new ArgumentNullException("RibbonPanel");
foreach (var item in ribbonItems)
if (!panel.Source.Items.Any(b => b.Text == item.Text))
panel.Source.Items.Add(item);
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Lad.Ribbons
{
internal static class FilePathExtension
{
/// <summary>
/// 程序集目录下的子文件夹是否包含配置文件
/// </summary>
/// <param name="dirFullName">搜索的文件目录</param>
/// <param name="searchName">搜索的文件名</param>
/// <param name="path">文件路径</param>
/// <returns>是否存在</returns>
public static bool DirExists(this string dirFullName, string searchName, out string path)
{
foreach (var dir in System.IO.Directory.GetDirectories(dirFullName))
{
path = System.IO.Path.Combine(dir, searchName);
if (System.IO.File.Exists(path))
return true;
else
{
if (DirExists(dir, searchName, out path))
return true;
}
}
path = string.Empty;
return false;
}
}
}
使用示例2
RibbonInit ribbonInit = new RibbonInit("我的选项卡", "1001");
ribbonInit.Init(tab =>
{
ribbonInit.CreatePanel("信息管理", "10011")
.AddRibbonItems(new RibbonItem[] {
ribbonInit.CreatLargeButton("查询", e =>
{
var button = e as RibbonButton;
if (button.CommandParameter != null)//命令行发送命令
{
Document doc = AcadApp.DocumentManager.MdiActiveDocument;
doc.SendStringToExecute(button.CommandParameter.ToString(), true, false, false);
}
}, default, "Line ")
});
});
tab.SetRibbonItemToolTip(btn, "直线", "创建直线段", "Line", "使用Line命令，可以创建一些连续的直线段，每条直线都是可以单独进行编辑的对象",
new(Path.Combine(imgPath, "Images", "LineToolTip.png")));
显示结果
//查找面板、选项卡的方法
control.FindTab("1001") //查找选项卡
control.FindPanel("10011",false) //查找面板---ID对应的是RibbonPanelSource的ID
control.ActiveTab.FindPanel("10011")//查找面板---ID对应的是RibbonPanelSource的ID
标签：return,string,--,System,new,二次开发,using,null,Ribbon 来源： https://www.cnblogs.com/taogeli/p/15651946.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。