文档章节

C#动态编译,实现按钮功能动态配置

白志华
 白志华
发布于 2015/10/18 10:55
字数 3563
阅读 8
收藏 0

现在对做的系统要求要越来越灵活,功能配置越来越方便,牺牲一小部分的效率,而换取系统的灵活性,对于维护、功能扩展升级等工作提供了很大的方便。


前两天,一个项目要求界面上的按钮都是可以配置的,位置和功能都是可配置的。位置好说,用xml即可。但是功能可配置就有点难度了。如果说使用接口,那么参数则不好设置,而且就算用接口,在实际调用时,也得明确实例化哪个类。您可能还会说用反射,嗯,这的确是个好办法,但是还是在调用的时候,参数不确定,反射也就无用武之地了。查了半天,最终还是选择了动态编译。


用一个专门的类,完成动态编译的过程。其实这个动态编译,就是动态生成代码,经过动态编译,然后直接在系统中可以使用。所以需要你在代码中添加中功能所需要的动态链接库、程序集以及命名空间。以下是我用到的动态编译的类:


using System;
using System.Data;
using System.Configuration;
using System.IO;
using System.Text;
using System.CodeDom.Compiler;
using System.Windows.Forms;
using Microsoft.CSharp;
using System.Reflection;

namespace DynamicAddFunction
{
    /// <summary>   
    /// 本类用来将字符串转为可执行文本并执行,用于动态定义按钮响应的事件。
    /// </summary>   
    public class Evaluator
    {
        private string filepath = Path.Combine(Application.StartupPath, "FunBtn.config");
     
        #region 构造函数
        /// <summary>   
        /// 可执行串的构造函数   
        /// </summary>   
        /// <param name="items">   
        /// 可执行字符串数组   
        /// </param>   
        public Evaluator(EvaluatorItem[] items)
        {
            ConstructEvaluator(items);      //调用解析字符串构造函数进行解析   
        }
        /// <summary>   
        /// 可执行串的构造函数   
        /// </summary>   
        /// <param name="returnType">返回值类型</param>   
        /// <param name="expression">执行表达式</param>   
        /// <param name="name">执行字符串名称</param>   
        public Evaluator(Type returnType, string expression, string name)
        {
            //创建可执行字符串数组   
            EvaluatorItem[] items = { new EvaluatorItem(returnType, expression, name) };
            ConstructEvaluator(items);      //调用解析字符串构造函数进行解析
        }
        /// <summary>   
        /// 可执行串的构造函数   
        /// </summary>   
        /// <param name="item">可执行字符串项</param>   
        public Evaluator(EvaluatorItem item)
        {
            EvaluatorItem[] items = { item };//将可执行字符串项转为可执行字符串项数组   
            ConstructEvaluator(items);      //调用解析字符串构造函数进行解析   
        }
        /// <summary>   
        /// 解析字符串构造函数   
        /// </summary>   
        /// <param name="items">待解析字符串数组</param>   
        private void ConstructEvaluator(EvaluatorItem[] items)
        {
            //创建C#编译器实例   
            //ICodeCompiler comp = (new CSharpCodeProvider().CreateCompiler());
            CSharpCodeProvider comp = new CSharpCodeProvider(); 
            //编译器的传入参数   
            CompilerParameters cp = new CompilerParameters();

            Configer configer = Configer.Current(filepath);
            string[] assemblies = configer.GetAssembly("FunBtn//assembly//dll","name");
            cp.ReferencedAssemblies.AddRange(assemblies);           //添加程序集集合
            //cp.ReferencedAssemblies.Add("system.dll");              //添加程序集 system.dll 的引用   
            //cp.ReferencedAssemblies.Add("system.data.dll");         //添加程序集 system.data.dll 的引用   
            //cp.ReferencedAssemblies.Add("system.xml.dll");          //添加程序集 system.xml.dll 的引用   
            //cp.ReferencedAssemblies.Add("system.windows.forms.dll");
            //cp.ReferencedAssemblies.Add("FunButton.dll");
            //cp.ReferencedAssemblies.Add("DynamicAddFunction.exe");
            cp.GenerateExecutable = false;                          //不生成可执行文件   
            cp.GenerateInMemory = true;                             //在内存中运行   

            StringBuilder code = new StringBuilder();               //创建代码串   
            /* 
             * 添加常见且必须的引用字符串 
             */
            //获取引用的命名空间
            string[] usings = configer.GetAssembly("FunBtn//assembly//using", "name");

            foreach (var @using in usings)
            {
                code.Append(@using+"\n");//添加引用的命名空间
            }
            //code.Append("using System; \n");
            //code.Append("using System.Data; \n");
            //code.Append("using System.Data.SqlClient; \n");
            //code.Append("using System.Data.OleDb; \n");
            //code.Append("using System.Xml; \n");
            //code.Append("using FunButton; \n");
            //code.Append("using System.Windows.Forms; \n");
            //code.Append("using DynamicAddFunction; \n");

            code.Append("namespace EvalGuy { \n");                  //生成代码的命名空间为EvalGuy,和本代码一样   

            code.Append(" public class _Evaluator { \n");          //产生 _Evaluator 类,所有可执行代码均在此类中运行   
            foreach (EvaluatorItem item in items)               //遍历每一个可执行字符串项   
            {
                code.AppendFormat("    public {0} {1}() ",          //添加定义公共函数代码   
                                  item.ReturnType.Name.ToLower() ,             //函数返回值为可执行字符串项中定义的返回值类型   
                                  item.Name);                       //函数名称为可执行字符串项中定义的执行字符串名称   
                code.Append("{ ");                                  //添加函数开始括号
                if (item.ReturnType.Name == "Void")
                {
                    code.AppendFormat("{0};", item.Expression);//添加函数体,返回可执行字符串项中定义的表达式的值   
                }
                else
                {
                    code.AppendFormat("return ({0});", item.Expression);//添加函数体,返回可执行字符串项中定义的表达式的值   
                }
                code.Append("}\n");                                 //添加函数结束括号   
            }
            code.Append("} }");                                 //添加类结束和命名空间结束括号   

            //得到编译器实例的返回结果   
            CompilerResults cr = comp.CompileAssemblyFromSource(cp, code.ToString());

            if (cr.Errors.HasErrors)                            //如果有错误   
            {
                StringBuilder error = new StringBuilder();          //创建错误信息字符串   
                error.Append("编译有错误的表达式: ");                //添加错误文本   
                foreach (CompilerError err in cr.Errors)            //遍历每一个出现的编译错误   
                {
                    error.AppendFormat("{0}\n", err.ErrorText);     //添加进错误文本,每个错误后换行   
                }
                throw new Exception("编译错误: " + error.ToString());//抛出异常   
            }
            Assembly a = cr.CompiledAssembly;                       //获取编译器实例的程序集   
            _Compiled = a.CreateInstance("EvalGuy._Evaluator");     //通过程序集查找并声明 EvalGuy._Evaluator 的实例   
        }
        #endregion

        #region 公有成员
        /// <summary>   
        /// 执行字符串并返回整型值   
        /// </summary>   
        /// <param name="name">执行字符串名称</param>   
        /// <returns>执行结果</returns>   
        public int EvaluateInt(string name)
        {
            return (int)Evaluate(name);
        }
        /// <summary>   
        /// 执行字符串并返回字符串型值   
        /// </summary>   
        /// <param name="name">执行字符串名称</param>   
        /// <returns>执行结果</returns>   
        public string EvaluateString(string name)
        {
            return (string)Evaluate(name);
        }
        /// <summary>   
        /// 执行字符串并返回布尔型值   
        /// </summary>   
        /// <param name="name">执行字符串名称</param>   
        /// <returns>执行结果</returns>   
        public bool EvaluateBool(string name)
        {
            return (bool)Evaluate(name);
        }
        /// <summary>   
        /// 执行字符串并返 object 型值   
        /// </summary>   
        /// <param name="name">执行字符串名称</param>   
        /// <returns>执行结果</returns>   
        public object Evaluate(string name)
        {
            MethodInfo mi = _Compiled.GetType().GetMethod(name);//获取 _Compiled 所属类型中名称为 name 的方法的引用   
            return mi.Invoke(_Compiled, null);                  //执行 mi 所引用的方法   
        }

        public void EvaluateVoid(string name)
        {
            MethodInfo mi = _Compiled.GetType().GetMethod(name);//获取 _Compiled 所属类型中名称为 name 的方法的引用   
            mi.Invoke(_Compiled, null);                  //执行 mi 所引用的方法   
        }

        #endregion

        #region 静态成员
        /// <summary>   
        /// 执行表达式并返回整型值   
        /// </summary>   
        /// <param name="code">要执行的表达式</param>   
        /// <returns>运算结果</returns>   
        static public int EvaluateToInteger(string code)
        {
            Evaluator eval = new Evaluator(typeof(int), code, staticMethodName);//生成 Evaluator 类的对像   
            return (int)eval.Evaluate(staticMethodName);                        //执行并返回整型数据   
        }
        /// <summary>   
        /// 执行表达式并返回字符串型值   
        /// </summary>   
        /// <param name="code">要执行的表达式</param>   
        /// <returns>运算结果</returns>   
        static public string EvaluateToString(string code)
        {
            Evaluator eval = new Evaluator(typeof(string), code, staticMethodName);//生成 Evaluator 类的对像   
            return (string)eval.Evaluate(staticMethodName);                     //执行并返回字符串型数据   
        }
        /// <summary>   
        /// 执行表达式并返回布尔型值   
        /// </summary>   
        /// <param name="code">要执行的表达式</param>   
        /// <returns>运算结果</returns>   
        static public bool EvaluateToBool(string code)
        {
            Evaluator eval = new Evaluator(typeof(bool), code, staticMethodName);//生成 Evaluator 类的对像   
            return (bool)eval.Evaluate(staticMethodName);                       //执行并返回布尔型数据   
        }
        /// <summary>   
        /// 执行表达式并返回 object 型值   
        /// </summary>   
        /// <param name="code">要执行的表达式</param>   
        /// <returns>运算结果</returns>   
        static public object EvaluateToObject(string code)
        {
            Evaluator eval = new Evaluator(typeof(object), code, staticMethodName);//生成 Evaluator 类的对像   
            return eval.Evaluate(staticMethodName);                             //执行并返回 object 型数据   
        }

        /// <summary>   
        /// 执行表达式并返回 void 空值   
        /// </summary>   
        /// <param name="code">要执行的表达式</param>   
        static public void EvaluateToVoid(string code)
        {
            Evaluator eval = new Evaluator(typeof(void), code, staticMethodName);//生成 Evaluator 类的对像   
            eval.EvaluateVoid(staticMethodName);                             //执行并返回 object 型数据   
        }

        #endregion

        #region 私有成员
        /// <summary>   
        /// 静态方法的执行字符串名称   
        /// </summary>   
        private const string staticMethodName = "ExecuteBtnCommand";
        /// <summary>   
        /// 用于动态引用生成的类,执行其内部包含的可执行字符串   
        /// </summary>   
        object _Compiled = null;
        #endregion
    }
    /// <summary>   
    /// 可执行字符串项(即一条可执行字符串)   
    /// </summary>   
    public class EvaluatorItem
    {
        /// <summary>   
        /// 返回值类型   
        /// </summary>   
        public Type ReturnType;
        /// <summary>   
        /// 执行表达式   
        /// </summary>   
        public string Expression;
        /// <summary>   
        /// 执行字符串名称   
        /// </summary>   
        public string Name;
        /// <summary>   
        /// 可执行字符串项构造函数   
        /// </summary>   
        /// <param name="returnType">返回值类型</param>   
        /// <param name="expression">执行表达式</param>   
        /// <param name="name">执行字符串名称</param>   
        public EvaluatorItem(Type returnType, string expression, string name)
        {
            ReturnType = returnType;
            Expression = expression;
            Name = name;
        }
    }
}


为了提高其灵活性,上面这个类添加的程序集和命名空间,以及调用功能的代码,都改成了读取xml格式的配置文件来获取。这样做理论上可以使得系统中可以添加任意.net制作的dll、exe等的功能。大大增强了系统的灵活性。

读写配置文件的类采用了单例模式,可以减少对系统的消耗,代码如下:


using System;
using System.Drawing;
using System.IO;
using System.Windows.Forms;
using System.Xml;
using System.Reflection;
using System.Configuration;

namespace DynamicAddFunction
{
    ///   <summary> 
    ///   负责读写应用程序配置文件,即app.config的读写。 
    ///   </summary> 
    public class Configer
    {
        #region   私有成员

        private string version; //版本号
        private string updatetime; //更新时间
        private string isautoupdate; //是否自动更新
        private string funbtnwidth; //功能区按钮宽度
        private string funbtnheight; //功能区按钮高度
        private string expandbtnwidth; //扩展区按钮宽度
        private string expandbtnheight; //扩展区按钮高度

        //private string btnname; //按钮名称
        //private string btntext; //按钮显示文本
        //private string btntype; //按钮类型
        //private string btnleft; //左边距
        //private string btntop; //上边距
        //private string btnreturntype; //返回值类型
        //private string btncode; //调用代码

        private string arrange; //扩展区按钮布局
        private string firstleft; //第一个按钮的左边距
        private string firsttop; //第一个按钮的上边距
        private string horizontal; //水平间距
        private string vertical; //垂直间距

        private string filePath; //文件路径
        private static Configer current; //唯一实例

        #endregion

        /// <summary>
        /// 因为不需要多个实例,所以采用了单例模式,由Current属性来获取唯一的实例
        /// </summary>
        /// <param name="filepath">文件Url</param>
        private Configer(string filepath)
        {
            this.filePath = filepath;
        }

        /// <summary>
        /// 获取当前配置。
        /// </summary>
        /// <param name="filepath">配置文件路径</param>
        /// <returns>返回唯一实例</returns>
        public static Configer Current(string filepath)
        {
            if (current == null)
            {
                current = new Configer(filepath);
            }
            //current = new Configer(filepath);
            return current;
        }       

        /// <summary>
        /// 为节点列表的特定属性写入相同的值
        /// </summary>
        /// <param name="path">路径</param>
        /// <param name="nodeProperty">属性名</param>
        public string[] GetAssembly(string path, string nodeProperty)
        {
            if (!File.Exists(filePath)) return null;
            var xmlDoc = new XmlDocument();
            xmlDoc.Load(filePath);

            string[] assemblies = null;

            //获取节点列表
            XmlNodeList nodelist = xmlDoc.SelectNodes(path);
            if (nodelist != null)
            {
                //根据节点个数,实例化数组,用于存在引用的dll名称
                assemblies = new string[nodelist.Count];

                for (int i = 0; i < nodelist.Count; i++)//遍历列表
                {
                    var element = (XmlElement)nodelist[i];
                    assemblies[i] = element.GetAttribute(nodeProperty);//装载dll到数组中
                }
            }
            return assemblies;//返回数组
        }

        /// <summary>                                                                         
        /// 获取节点值 
        /// </summary>
        /// <param name="path">节点路径</param>
        /// <param name="nodeProperty">节点名称</param>
        /// <returns>属性值</returns>
        public string GetNodeProperty(string path, string nodeProperty)
        {
            XmlDocument doc = new XmlDocument();
            //加载文件
            doc.Load(filePath);

            XmlElement element = null;

            //节点元素
            element = (XmlElement)(doc.SelectSingleNode(path));

            if (element != null)
            {
                return element.GetAttribute(nodeProperty);
            }
            else
            {
                return " ";
            }
        }

        /// <summary> 
        /// 写入属性值
        /// </summary> 
        /// <param name="path">节点路径</param>
        /// <param   name= "nodeProperty"> 属性名称</param>
        /// <param   name= "nodeValue">属性值</param> 
        public void SetNodeProperty(string path, string nodeProperty, string nodeValue)
        {
            var doc = new XmlDocument();
            //加载文件
            doc.Load(filePath);

            XmlElement element = null;

            //获取版本信息
            element = (XmlElement)(doc.SelectSingleNode(path));

            if (element != null)
            {
                //给某个属性写入值
                element.SetAttribute(nodeProperty, nodeValue);
            }
            doc.Save(filePath);
        }

        /// <summary>
        /// 获取节点值 
        /// </summary>
        /// <param name="path">节点路径</param>
        /// <param name="nodeProperty">节点名称</param>
        /// <returns>属性值</returns>
        public string GetNodeValue(string path, string nodeProperty)
        {
            XmlDocument doc = new XmlDocument();
            //加载文件
            doc.Load(filePath);

            XmlNode node = null;

            //获取节点
            node = (doc.SelectSingleNode(path));

            if (node != null)
            {
                //返回节点内容
                return node.Value;
            }
            else
            {
                return " ";
            }
        }

        /// <summary> 
        /// 写入节点值
        /// </summary> 
        /// <param name="path">节点路径</param>
        /// <param   name= "nodeProperty"> 属性名称</param>
        /// <param   name= "nodeValue">属性值</param> 
        public void SetNodeValue(string path, string nodeProperty, string nodeValue)
        {
            var doc = new XmlDocument();
            //加载文件
            doc.Load(filePath);

            XmlNode node = null;

            //获取节点
            node = (doc.SelectSingleNode(path));

            if (node != null)
            {
                //在节点中写入内容
                node.Value = nodeValue;
            }
            doc.Save(filePath);
        }


        /// <summary>
        /// 为节点列表的特定属性写入相同的值
        /// </summary>
        /// <param name="path">路径</param>
        /// <param name="nodeProperty">属性名</param>
        /// <param name="nodeValue">属性值</param>
        public void SetAllNodeProperty(string path, string nodeProperty, string nodeValue)
        {
            if (!File.Exists(filePath)) return;
            var xmlDoc = new XmlDocument();
            xmlDoc.Load(filePath);

            //获取节点列表
            var selectSingleNode = xmlDoc.SelectNodes(path);
            if (selectSingleNode != null)
            {
                XmlNodeList nodelist = selectSingleNode;

                foreach (var VARIABLE in nodelist)//遍历列表
                {
                    XmlElement element = (XmlElement)VARIABLE;
                    //((XmlElement)VARIABLE).Attributes[nodeProperty].Value = nodeValue;
                    element.SetAttribute(nodeProperty, nodeValue);
                }
            }
            xmlDoc.Save(filePath);
        }

        /// <summary>
        /// 创建节点
        /// </summary>
        /// <param name="path">父节点路径</param>
        /// <param name="name">节点名称</param>
        /// <param name="nodeProperties">属性数组</param>
        /// <param name="nodeValues">属性值数组</param>
        public void CreateNode(string path,string name, string[] nodeProperties, string[] nodeValues)
        {
            if (!File.Exists(filePath)) return;
            XmlDocument xmlDoc = new XmlDocument();
            xmlDoc.Load(filePath);

            //获取按钮信息设置
            var selectSingleNode = xmlDoc.SelectSingleNode(path);
            if (selectSingleNode != null)
            {
                XmlElement xmlElement = xmlDoc.CreateElement(name);

                //遍历属性数组,一次添加
                for (int i = 0; i < nodeProperties.Length; i++)
                {
                    //添加属性
                    xmlElement.SetAttribute(nodeProperties[i], nodeValues[i]);
                }
                selectSingleNode.AppendChild(xmlElement);
            }
            xmlDoc.Save(filePath);//保存
        }


        /// <summary>
        /// 移除节点
        /// </summary>
        /// <param name="path">父节点路径</param>
        /// <param name="name">子节点名称</param>
        public void RemoveNode(string path,string name)
        {
            if (!File.Exists(filePath)) return;
            XmlDocument xmlDoc = new XmlDocument();
            xmlDoc.Load(filePath);

            //获取父节点
            var selectSingleNode = xmlDoc.SelectSingleNode(path);
            if (selectSingleNode != null)
            {
                //获取子节点
                var node=selectSingleNode.SelectSingleNode(name);

                if (node != null)
                {
                    selectSingleNode.RemoveChild(node);
                }
            }
            xmlDoc.Save(filePath);//保存
        }
    }
}

配置文件信息如下:FunBtn.Config


<?xml version="1.0" encoding="utf-8"?>
<FunBtn>
  <!-- 版本信息 -->
  <info version="1.00" updatetime="2013-01-01 10:00:00.123" isautoupdate="true" />
  <!-- 引用的程序集和命名空间 -->
  <assembly>
    <dll name="system.dll" />
    <dll name="system.data.dll" />
    <dll name="system.xml.dll" />
    <dll name="system.windows.forms.dll" />
    <dll name="FunButton.dll" />
    <dll name="DynamicAddFunction.exe" />
    <using name="using System;" />
    <using name="using System.Data;" />
    <using name="using System.Data.SqlClient;" />
    <using name="using System.Data.OleDb;" />
    <using name="using System.Xml;" />
    <using name="using FunButton;" />
    <using name="using System.Windows.Forms;" />
    <using name="using DynamicAddFunction;" />
  </assembly>
  <!-- 按钮属性和方法 -->
  <btndetail>
    <btn name="btnDelOrder" value="删除订单" type="funbtn" rank="0" left="10" top="5" returntype="void" code="new DelOrderBtn().DelOrder(Form1.objs)" />
    <btn name="btnCheckOut" value="结 账" type="funbtn" rank="-1" left="10" top="335" returntype="void" code="new CheckOutBtn().CheckOut(Form1.objs)" />
    <btn name="btnClose" value="退出" type="funbtn" rank="-1" left="240" top="335" returntype="void" code="Application.Exit()" />
    <btn name="btnDelAllOrder" value="整单删除" type="funbtn" rank="-1" left="240" top="225" returntype="void" code="new DelOrderBtn().DelOrder(Form1.objs)" />
    <btn name="btnMore" value="更 多" type="funbtn" rank="6" left="10" top="230" returntype="void" code="new frmMore().Show()" />
  </btndetail>
</FunBtn>

这样在系统调用的时候就可以方便多了(我这里所有的按钮都相应一个事件,即Button_Click事件,它们是通过name,在配置文件中找到对应的代码,然后动态编译,然后去执行的)


/// <summary>
        /// 动态执行按钮点击事件
        /// </summary>
        public void Button_Click(object sender, EventArgs e)
        {
            try
            {
                Configer configer = Configer.Current(filePath);

                //获取调用的代码
                string code = configer.GetNodeProperty(
                    "FunBtn//btndetail//btn[@name='" + ((Button)sender).Name + "']", "code");
                
                //获取调用方法的返回值类型
                string returnType =
                    configer.GetNodeProperty("FunBtn//btndetail//btn[@name='" + ((Button)sender).Name + "']",
                                             "returntype");
                //根据返回值类型,判断调用那个动态生成的接口
                switch (returnType)
                {
                    case "void":
                        Evaluator.EvaluateToVoid(code);
                        break;
                    case "object":
                        Evaluator.EvaluateToObject(code);
                        break;
                    case "int":
                        Evaluator.EvaluateToInteger(code);
                        break;
                    case "bool":
                        Evaluator.EvaluateToBool(code);
                        break;
                    case "string":
                        Evaluator.EvaluateToString(code);
                        break;
                }
            }
            catch (Exception exception)
            {
                MessageBox.Show(exception.Message);
            }
        }



这样,只要你配置文件中的加入了程序集和命名控件,且代码OK,那么你就能调用任意的dll了。意味着你拥有了强大的扩展性,在添加功能方面,不用再重新发布新版本了。直接放用到的dll放入到程序根目录下,然后配置正确FunBtn.config即可。


当然,其实我还是不推荐用动态编译的,因为影响效率呀。每次点击按钮,都需要重新动态编译,效率肯定是要降低的。所以你在借鉴时,一定要慎重选择哦。



版权声明:本文为博主原创文章,未经博主允许不得转载。

本文转载自:http://blog.csdn.net/xiaoxian8023/article/details/8487811

共有 人打赏支持
白志华
粉丝 31
博文 265
码字总数 57524
作品 0
长沙
程序员
私信 提问
C#插件开发框架

【业务需求】 基于C#语言实现一个插件化开发框架,主要包括以下功能: 1、提供统一的插件引擎,实现插件的装载、卸载(热插拔)以及插件之间的通讯机制 2、提供一个统一的界面容器,为加载插...

traychen
2017/03/30
1
0
C#代码生成器--AutoCode_vs2010

AutoCode_vs2010 是 C# 代码生成器 1.代码生成灵活,根据用户所编辑的模板生成代码。 using System;using System.Collections.Generic;using System.Text;using System.IO;using ToolFuncti......

扒衣姥爷
2015/04/02
1K
0
困惑:使用ORM后如何支持用户自定义栏位的特性?

基于.NET平台,使用C#,ORM,例如产品对象 Product 有10个属性(映射表的10个栏位)。编译后发布的产品在使用的过程中,用户可以通过简单的界面操作给产品对象增加栏位,相当于在对象层增加了...

Seanx
2012/03/17
205
2
企业后台管理基础框架--hsweb

hsweb 企业后台管理基础框架 业务功能 现在: 权限管理: 权限资源-角色-用户. 配置管理: kv结构,自定义配置.可通过此功能配置数据字典. 脚本管理: 动态脚本,支持javascript,groovy,java动态编...

hsweb
2016/12/08
22K
16
.net erp(办公oa)开发平台架构概要说明之表单设计器

背景:搭建一个适合公司erp业务的开发平台。 架构概要图: 表单设计开发部署示例图 表单设计开发部署示例说明 1)每个开发人员可以自己部署表单设计至本地一份(当然也可以共用一套开发环境,...

车江毅
2016/01/11
627
1

没有更多内容

加载失败,请刷新页面

加载更多

微服务分布式事务实现

https://www.processon.com/view/link/5b2144d7e4b001a14d3d2d30

WALK_MAN
今天
2
0
《大漠烟尘》读书笔记及读后感文章3700字

《大漠烟尘》读书笔记及读后感文章3700字: 在这个浮躁的社会里,你有多久没有好好读完一本书了? 我们总觉得自己和别人不一样,所以当看到别人身上的问题时,很少有“反求诸己”,反思自己。...

原创小博客
今天
4
0
大数据教程(9.5)用MR实现sql中的jion逻辑

上一篇博客讲解了使用jar -jar的方式来运行提交MR程序,以及通过修改YarnRunner的源码来实现MR的windows开发环境提交到集群的方式。本篇博主将分享sql中常见的join操作。 一、需求 订单数据表...

em_aaron
今天
3
0
十万个为什么之什么是resultful规范

起源 越来越多的人开始意识到,网站即软件,而且是一种新型的软件。这种"互联网软件"采用客户端/服务器模式,建立在分布式体系上,通过互联网通信,具有高延时(high latency)、高并发等特点...

尾生
今天
3
0
Terraform配置文件(Terraform configuration)

Terraform配置文件 翻译自Terraform Configuration Terraform用文本文件来描述设备、设置变量。这些文件被称为Terraform配置文件,以.tf结尾。这一部分将讲述Terraform配置文件的加载与格式。...

buddie
今天
5
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部