文档章节

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

白志华
 白志华
发布于 2015/10/18 10:55
字数 3563
阅读 6
收藏 0
点赞 0
评论 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

共有 人打赏支持
白志华
粉丝 29
博文 260
码字总数 57524
作品 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 ⋅ 0

企业后台管理基础框架--hsweb

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

hsweb ⋅ 2016/12/08 ⋅ 16

困惑:使用ORM后如何支持用户自定义栏位的特性?

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

Seanx ⋅ 2012/03/17 ⋅ 2

.net erp(办公oa)开发平台架构概要说明之表单设计器

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

车江毅 ⋅ 2016/01/11 ⋅ 1

通用权限系统快速开发框架设计

系统在线演示地址: http://120.90.2.126:8051 登录账户:system,密码:system### DEMO下载地址: http://download.csdn.net/detail/shecixiong/5372895 一、开发技术:B/S(.NET C# ) 1、Win...

佘赐雄 ⋅ 2013/05/22 ⋅ 2

工作流系统之自定义脚本的实现方式

工作流软件系统包含流程引擎,流程设计器,流程发布运行等监控环境。流程引擎实现业务流程建模以及流程的流转,流程建模包含流程的基本节点模型,流程的流转就涉及到流程的提交,以及相关节点...

长平狐 ⋅ 2012/10/11 ⋅ 0

C#调用libEasyPlayer动态库,实现RTSP流播放

一、项目背景: 由于一个项目的附加部分,客户要求实现一个关于视频流媒体的方面内容,而且没有经费,且做为项目的附加条款,采购现成的系统,由于经费的问题,不太现实,所以上到开源社区寻...

janl ⋅ 2016/01/08 ⋅ 18

使用 Phalanger 整合 PHP 和 .Net

Phalanger 是一种 PHP 语言编译器,也是针对 .NET 的 PHP 运行时。 它可以用于把 PHP web 项目编译成 .NET 字节码,并在 Windows 中使用 IIS 或者在 Linux 上使用 Mono 和 Apache 作为 ASP....

墙头草 ⋅ 2012/04/11 ⋅ 14

C# 中静态调用C++dll 和C# 中动态调用C++dll

C# 中静态调用C++dll 和C# 中动态调用C++dll 在最近的项目中,牵涉到项目源代码保密问题,由于代码是C#写的,容易被反编译,因此决定抽取核心算法部分使用C++编写,C++到目前为止好像还不能被...

KavenSu ⋅ 2015/01/09 ⋅ 0

C#开发微信门户及应用(8)-微信门户应用管理系统功能介绍

最近对微信接口进行深入的研究,通过把底层接口一步步进行封装后,逐步升级到自动化配置、自动化应答,以及后台处理界面的优化和完善上,力求搭建一个较为完善、适用的微信门户应用管理系统。...

walb呀 ⋅ 2017/12/04 ⋅ 0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

JavaScript零基础入门——(十)JavaScript的DOM基础

JavaScript零基础入门——(十)JavaScript的DOM基础 欢迎大家回到我们的JavaScript零基础入门,上一节课,我们了解了JavaScript中的函数,这一节课,我们来了解一下JavaScript的DOM。 第一节...

JandenMa ⋅ 15分钟前 ⋅ 0

Spring mvc DispatchServlet 实现原理

在Spring中, ContextLoaderListener只是辅助类,在web 容器启动的时候查找并创建WebApplicationContext对象,通过该对象进行加载spring的配置文件。而真正的逻辑实现其实是在DispatcherSer...

轨迹_ ⋅ 27分钟前 ⋅ 0

Weex起步

本教程假设你已经在你的本地环境安装了node 其实weex起步教程在 https://github.com/lilugirl/incubator-weex 项目说明文件中都已经有了,但为了有些同学看到英文秒变文盲,所以这里我重新写...

lilugirl ⋅ 35分钟前 ⋅ 0

Jenkins实践1 之安装

1 下载 http://mirrors.jenkins.io/war/latest/jenkins.war 2 启动 java -jar jenkins.war 前提:安装jdk并配置环境变量 启动结果节选: ************************************************......

晨猫 ⋅ 41分钟前 ⋅ 0

组合数学 1-2000 中,能被6或10整除的数的个数

1--2000 中,能被6或10整除的数的个数 利用集合的性质 能被6整除的个数 2000/6 = 333 能被10整除的个数 2000/10 = 200 能被6和10整除的个数 2000/30 = 66 能被6或10整除的个数 333+200-66 =...

阿豪boy ⋅ 50分钟前 ⋅ 0

一篇文章学懂Shell脚本

Shell脚本,就是利用Shell的命令解释的功能,对一个纯文本的文件进行解析,然后执行这些功能,也可以说Shell脚本就是一系列命令的集合。 Shell可以直接使用在win/Unix/Linux上面,并且可以调用...

Jake_xun ⋅ 今天 ⋅ 0

大数据工程师需要精通算法吗,要达到一个什么程度呢?

机器学习是人工智能的一个重要分支,而机器学习下最重要的就是算法,本文讲述归纳了入门级的几个机器学习算法,加大数据学习群:716581014一起加入AI技术大本营。 1、监督学习算法 这个算法由...

董黎明 ⋅ 今天 ⋅ 0

Kylin 对维度表的的要求

1.要具有数据一致性,主键值必须是唯一的;Kylin 会进行检查,如果有两行的主键值相同则会报错。 2.维度表越小越好,因为 Kylin 会将维度表加载到内存中供查询;过大的表不适合作为维度表,默...

无精疯 ⋅ 今天 ⋅ 0

58到家数据库30条军规解读

军规适用场景:并发量大、数据量大的互联网业务 军规:介绍内容 解读:讲解原因,解读比军规更重要 一、基础规范 (1)必须使用InnoDB存储引擎 解读:支持事务、行级锁、并发性能更好、CPU及...

kim_o ⋅ 今天 ⋅ 0

代码注释中顺序更改 文件读写换行

`package ssh; import com.xxx.common.log.LogFactory; import com.xxx.common.log.LoggerUtil; import org.apache.commons.lang3.StringUtils; import java.io.*; public class DirErgodic ......

林伟琨 ⋅ 今天 ⋅ 0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

返回顶部
顶部