codesmith使用

最新推荐文章于 2025-08-10 11:13:09 发布
最新推荐文章于 2025-08-10 11:13:09 发布
阅读量83 收藏
点赞数
文章标签： c# 数据库
本文介绍如何使用CodeSmith来自动生成C#代码，包括实体类和数据访问层等，并提供了详细的步骤和示例代码。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

安装后

破解

将两个dll烤到安装目录下！

 自己制作CodeTemplateRule

将CodeSmith.Engine（在bin目录里）和SchemaExplorer（在AddIns目录里）  两个类添加到引用

 

 

using System;
using System.Text;
using System.ComponentModel;
using CodeSmith.Engine;
using System.Data;
using SchemaExplorer;

namespace CodeTemplateRule
{
    /**/
    /// <summary>
    /// CodeSmith自动生成代码所用到的函数
    /// </summary>
    public class CodeTemplateRule
    {
        /**/
        /// <summary>
        /// 获取所有列的集合
        /// </summary>
        /// <param name="dataBase">数据库Schema</param>
        /// <param name="tableName">表名</param>
        /// <returns>Columns Schema</returns>
        public ColumnSchemaCollection GetColumnCollection(DatabaseSchema dataBase, string tableName)
        {
            TableSchemaCollection tables = new TableSchemaCollection(dataBase.Tables);
            ColumnSchemaCollection columns = null;
            for (int i = 0; i < tables.Count; i++)
            {
                if (tables[i].Name.ToUpper() == tableName.ToUpper())
                {
                    TableSchema ts = tables[i];
                    columns = new ColumnSchemaCollection(ts.Columns);
                }
            }
            return columns;
        }

        /**/
        /// <summary>
        /// 获取处理后的表名 例如：ORG_Person,返回Person
        /// </summary>
        /// <param name="tableName">表名</param>
        /// <returns>返回处理后的表名</returns>
        public string GetTableName(string tableName)
        {
            int i = tableName.IndexOf("_");
            return tableName.Substring(i + 1, tableName.Length - (i + 1));
        }

        /**/
        /// <summary>
        /// 获取唯一号的变量名，第一个字母小写
        /// </summary>
        /// <param name="guidColumn">唯一号列名</param>
        /// <returns>唯一号的变量名</returns>
        public string GetGuidColumnVar(string guidColumn)
        {
            string guid;
            guid = guidColumn.Substring(0, 1).ToLower() + guidColumn.Substring(1, guidColumn.Length - 1);
            return guid;
        }

        /**/
        /// <summary>
        /// 获取c#变量类型
        /// </summary>
        /// <param name="column">列</param>
        /// <returns>c#变量类型</returns>
        public string GetType(ColumnSchema column)
        {
            if (column.Name.EndsWith("TypeCode")) return column.Name;

            switch (column.DataType)
            {
                case DbType.AnsiString: return "string";
                case DbType.AnsiStringFixedLength: return "string";
                case DbType.Binary: return "byte[]";
                case DbType.Boolean: return "bool";
                case DbType.Byte: return "int";
                case DbType.Currency: return "decimal";
                case DbType.Date: return "DateTime";
                case DbType.DateTime: return "DateTime";
                case DbType.Decimal: return "decimal";
                case DbType.Double: return "double";
                case DbType.Guid: return "Guid";
                case DbType.Int16: return "short";
                case DbType.Int32: return "int";
                case DbType.Int64: return "long";
                case DbType.Object: return "object";
                case DbType.SByte: return "sbyte";
                case DbType.Single: return "float";
                case DbType.String: return "string";
                case DbType.StringFixedLength: return "string";
                case DbType.Time: return "TimeSpan";
                case DbType.UInt16: return "ushort";
                case DbType.UInt32: return "uint";
                case DbType.UInt64: return "ulong";
                case DbType.VarNumeric: return "decimal";
                default:
                    {
                        return "__UNKNOWN__" + column.NativeType;
                    }
            }
        }

        /**/
        /// <summary>
        /// 获取c#变量类型默认值
        /// </summary>
        /// <param name="column">列</param>
        /// <returns>c#变量类型默认值</returns>
        public string GetDefaultValue(ColumnSchema column)
        {
            if (column.Name.EndsWith("TypeCode")) return column.Name;

            switch (column.DataType)
            {
                case DbType.AnsiString: return "\"\"";
                case DbType.AnsiStringFixedLength: return "\"\"";
                case DbType.Binary: return "null";
                case DbType.Boolean: return "false";
                case DbType.Byte: return "0";
                case DbType.Currency: return "0";
                case DbType.Date: return "DateTime.Parse(\"1900-1-1\")";
                case DbType.DateTime: return "DateTime.Parse(\"1900-1-1\")";
                case DbType.Decimal: return "0";
                case DbType.Double: return "0";
                case DbType.Guid: return "Guid.NewGuid().ToString()";
                case DbType.Int16: return "0";
                case DbType.Int32: return "0";
                case DbType.Int64: return "0";
                case DbType.Object: return "\"\"";
                case DbType.SByte: return "0";
                case DbType.Single: return "0";
                case DbType.String: return "\"\"";
                case DbType.StringFixedLength: return "";
                case DbType.Time: return "DateTime.Parse(\"1900-1-1\")";
                case DbType.UInt16: return "0";
                case DbType.UInt32: return "0";
                case DbType.UInt64: return "0";
                case DbType.VarNumeric: return "0";
                default:
                    {
                        return "__UNKNOWN__" + column.NativeType;
                    }
            }
        }

        /**/
        /// <summary>
        /// 获取c#变量类型默认值
        /// </summary>
        /// <param name="column">列</param>
        /// <returns>c#变量类型默认值</returns>
        public string GetConvert(ColumnSchema column)
        {
            if (column.Name.EndsWith("TypeCode")) return column.Name;

            switch (column.DataType)
            {
                case DbType.AnsiString: return "Convert.ToString";
                case DbType.AnsiStringFixedLength: return "Convert.ToString";
                case DbType.Binary: return "Convert.ToByte";
                case DbType.Boolean: return "Convert.ToBoolean";
                case DbType.Byte: return "Convert.ToInt32";
                case DbType.Currency: return "Convert.ToDecimal";
                case DbType.Date: return "Convert.DateTime";
                case DbType.DateTime: return "Convert.DateTime";
                case DbType.Decimal: return "Convert.ToDecimal";
                case DbType.Double: return "Convert.ToDouble";
                case DbType.Guid: return "Convert.ToString";
                case DbType.Int16: return "Convert.ToInt16";
                case DbType.Int32: return "Convert.ToInt32";
                case DbType.Int64: return "Convert.ToInt64";
                case DbType.Object: return "Convert.ToString";
                case DbType.SByte: return "Convert.ToByte";
                case DbType.Single: return "Convert.ToInt32";
                case DbType.String: return "Convert.ToString";
                case DbType.StringFixedLength: return "Convert.ToString";
                case DbType.Time: return "Convert.DateTime";
                case DbType.UInt16: return "Convert.ToUInt16";
                case DbType.UInt32: return "Convert.ToUInt32";
                case DbType.UInt64: return "Convert.ToUInt64";
                case DbType.VarNumeric: return "Convert.ToDecimal";
                default:
                    {
                        return "__UNKNOWN__" + column.NativeType;
                    }
            }
        }
    }
}

 

 

将 重新编译生成的CodeTemplateRule拷贝到 codesmith目录下的 两个文件夹中

 

模板页中添加引用

ContractedBlock.gifExpandedBlockStart.gifCode
<%-- 
Name:模板
Author: awp
Description: 生成模板
--%>
<%@ CodeTemplate Language="C#" ResponseEncoding="UTF-8"  TargetLanguage="Text" Description="Template description here." %>
<%@ Assembly Name="SchemaExplorer" %>
<%@ Import Namespace="SchemaExplorer" %>
<%@ Assembly Name="CodeTemplateRule" %>
<%@ Import Namespace="CodeTemplateRule" %>
<%--模板属性--%>
<%@ Property Name="DataBase" Type="SchemaExplorer.DatabaseSchema" Category="Context" Description="数据库连接." %>
<%@ Property Name="TableName" Type="System.String" Default="t_User" Optional="False" Category="" Description="表名" %>
<%@ Property Name="Model" Type="System.String" Default="Bs.Model" Optional="False" Category="" Description="实体类命名空间" %>
<%@ Property Name="DAL" Type="System.String" Default="Bs.DAL" Optional="False" Category="" Description="数据层命名空间" %>
<%@ Property Name="BLL" Type="System.String" Default="Bs.BLL" Optional="False" Category="" Description="业务逻辑层命名空间" %>
<%@ Property Name="SQLHelper" Type="System.String" Default="Bs.SQLHelper" Optional="False" Category="" Description="数据操作层命名空间" %>
<%@ Property Name="Author" Type="System.String" Default="awp" Optional="False" Category="" Description="作者" %>
<%@ Property Name="Description" Type="System.String" Default="实体类" Optional="False" Category="" Description="该类的描述" %>
<script runat="template">
 CodeTemplateRule rule=new CodeTemplateRule();
</script> 


using System;

namespace <%= Model %>
{
    /// <summary>
    /// 实体类:<%= rule.GetTableName(TableName) %>Info 数据实体
    /// 描述:<%
TableSchema table=DataBase.Tables["t_"+rule.GetTableName(TableName)];

%>
    /// 作者:<%= Author %>
    /// 日期:<%= DateTime.Now.ToString() %>
    ///</summary>

    public class <%= rule.GetTableName(TableName) %>Info
    {                
          #region 变量定义
<%

        ColumnSchemaCollection columns=rule.GetColumnCollection(DataBase,TableName);
        for(int i=0;i<columns.Count;i++)
        {
            string des="";

            if(columns[i].Description.Length>0)
            {
                des=columns[i].Description;
            }
            
            switch(rule.GetType(columns[i]))
            {
                case "int":
                    %>
                    private int _<%=columns[i].Name%>;//<%=des%>
                    <%
                    break;
                case "string":
                    %>
                    private string _<%=columns[i].Name%>;//<%=des%>
                    <%
                    break;
                case "DateTime":
                    %>
                    private DateTime _<%=columns[i].Name%>;//<%=des%>
                    <%
                    break;
                default:
                    %>
                    private string _<%=columns[i].Name%>;//<%=des%>
                    <%
                break;
            }

        }
%>
        #endregion 变量定义

        ///<summary>
        ///构造函数
        ///</summary>
        public <%= rule.GetTableName(TableName)+"Info()" %>
        {
<%
        for(int i=0;i<columns.Count;i++)
        {
            switch(rule.GetType(columns[i]))
            {
                case "int":
                    Response.Write("            _"+columns[i].Name+" = int.MaxValue;\r\n");
                    break;
                case "string":
                    Response.Write("            _"+columns[i].Name+" = null;\r\n");
                    break;
                case "DateTime":
                    Response.Write("            _"+columns[i].Name+" = DateTime.MinValue;\r\n");
                    break;
                default:
                    Response.Write("            _"+columns[i].Name+" = null;\r\n");
                break;
            }
        }
%>
        }


         #region 公共属性
<%
        for(int i=0;i<columns.Count;i++)
        {
%> 
          ///<summary>
        ///<%if(columns[i].Description.Length>0){ Response.Write(columns[i].Description);}else{Response.Write(columns[i].Name);}%>
        ///</summary>
        public <%= rule.GetType(columns[i]) %> <%= columns[i].Name%>
        {
            get{
                return _<%= columns[i].Name %>;
            }
            set{
                _<%= columns[i].Name %>=value;
                }
        }
<%   
          }
%> 
        #endregion 公共属性
        
        
    }
}

**********************************************************

using System;
using System.Data;
using System.Data.SqlClient;
using System.Collections.Generic;
using System.Text;
using <%=SQLHelper%>;
using <%=Model%>;


namespace <%=DAL %>
{    
     
    
    /// <summary>
    /// 数据操作层类:DAL<%= rule.GetTableName(TableName) %> 
    /// 描述:<%
    
    
    %>
    /// 作者:<%= Author %>
    /// 日期:<%= DateTime.Now.ToString() %>
    ///</summary>
    public class DAL<%= rule.GetTableName(TableName) %>
    {    
        /// <summary>
        /// 构造函数
        /// </summary>
          public DAL<%= rule.GetTableName(TableName) %>(string tableName)
        {
            this.TableName = tableName;
        }


        #region 重写继承的DataBase类的的方法 (为了实现多表的功能)


        public override int GetCountVir(string sqlStr)
        {
            return SqlHelper.ExecuteNonQuery(sqlStr, null);
        }

        public override int GetSumVir(string sqlStr)
        {
            return SqlHelper.ExecuteNonQuery(sqlStr, null);
        }

        public override SqlDataReader GetListDrVir(string sqlStr)
        {
            return SqlHelper.ExecuteReader(sqlStr);
        }

        public override DataSet GetListDsVir(string sqlStr)
        {
            return SqlHelper.ExecuteDataset(sqlStr);
        }

        public override DataTable GetListDtVir(string sqlStr)
        {
            return SqlHelper.ExecuteDataset(sqlStr).Tables[0];
        }

        public override bool ExistsVir(string sqlStr)
        {
            if (SqlHelper.ExecuteNonQuery(sqlStr, null) > 0)
            {
                return true;

            }
            else
            {
                return false;
            }

        }



        #endregion
        
         #region Add增加一条数据
        /// <summary>
        /// 增加一条数据
        /// </summary>
        /// <param name="model">实体类</param>
        /// <returns>新增数据的ID</returns>
        public int Add(<%= rule.GetTableName(TableName) %>Info model)
        {
            StringBuilder strSql = new StringBuilder();
            strSql.Append("insert into t_<%= rule.GetTableName(TableName) %>(");
            
            <%string sqlStr="";
            string sqlStr2="";
        for(int i=0;i<columns.Count;i++)
        {
            
            if(i+1==columns.Count)
            {
                sqlStr+=columns[i].Name;
                sqlStr2+="@"+columns[i].Name;
            }
            else
            {
                sqlStr+=columns[i].Name+",";
                sqlStr2+="@"+columns[i].Name+",";
            }
            
        }%>
            
            strSql.Append("<%=sqlStr%>");
            strSql.Append(")");
            strSql.Append(" values (");
            strSql.Append("<%=sqlStr2%>");
            strSql.Append(")");
            strSql.Append(";select @@IDENTITY");

            //获取参数
            SqlParameter[] parameters = GetParameters("<%=rule.GetTableName(TableName)%>Add");
            
            <%
                for(int i=0;i<columns.Count;i++)
                {
                    %>
                     parameters[<%=i%>].Value = model.<%=columns[i].Name%>;
                    <%
                }
            
            %>


            int ID = int.Parse(SqlHelper.ExecuteScalar(strSql.ToString(), parameters).ToString());

            OnAdd(ID);//可以表示在添加前还是后执行这个事件 
            //比如在 注册事件中应该是 添加成功后进行登入操作

            return ID;
        }
        #endregion
        
           #region Update 更新
        public bool Update(<%= rule.GetTableName(TableName) %>Info model)
        {


            StringBuilder strSql = new StringBuilder();
            strSql.Append("update t_<%= rule.GetTableName(TableName) %> set ");

            SqlParameter[] parms = {
                new SqlParameter("@ID", SqlDbType.Int, 4)
                                   };

            parms[0].Value = model.ID;

            int j = 1;
            
            <% 
            for(int i=0;i<columns.Count;i++)
            {
                if(columns[i].Name!="ID")
                {
                
                        
                        switch(rule.GetType(columns[i]))
                        {
                            case "int":
                                %>
                                    if (model.<%=columns[i].Name%> != int.MaxValue)
                                    {
                                    strSql.Append(" <%=columns[i].Name%>=@<%=columns[i].Name%>,");
                                    Array.Resize<SqlParameter>(ref parms, parms.Length + 1);
                                    parms[j] = new SqlParameter("@<%=columns[i].Name%>", SqlDbType.Int,<%=columns[i].Size%>);
                                    parms[j].Value = model.<%=columns[i].Name%>;
                                    j = j + 1;
                                    }
                                <%
                                break;
                            case "string":
                                %>
                                     if (model.<%=columns[i].Name%> != null)
                                    {
                                    strSql.Append(" <%=columns[i].Name%>=@<%=columns[i].Name%>,");
                                    Array.Resize<SqlParameter>(ref parms, parms.Length + 1);
                                    parms[j] = new SqlParameter("@<%=columns[i].Name%>", SqlDbType.VarChar,<%=columns[i].Size%>);
                                    parms[j].Value = model.<%=columns[i].Name%>;
                                    j = j + 1;
                                    }
                                <%
                                break;
                            case "DateTime":
                                %>
                                     if (model.<%=columns[i].Name%> !=  DateTime.MinValue)
                                    {
                                    strSql.Append(" <%=columns[i].Name%>=@<%=columns[i].Name%>,");
                                    Array.Resize<SqlParameter>(ref parms, parms.Length + 1);
                                    parms[j] = new SqlParameter("@<%=columns[i].Name%>", SqlDbType.DateTime);
                                    parms[j].Value = model.<%=columns[i].Name%>;
                                    j = j + 1;
                                    }
                                <%
                                break;
                            default:
                                %>
                                    if (model.<%=columns[i].Name%> != null)
                                    {
                                    strSql.Append(" Address=@Address,");
                                    Array.Resize<SqlParameter>(ref parms, parms.Length + 1);
                                    parms[j] = new SqlParameter("@Address", SqlDbType.VarChar, 200);
                                    parms[j].Value = model.Address;
                                    j = j + 1;
                                    }
                                <%
                            break;
                        }
                        
                    
                }
                
            }
            
            %>



            strSql = strSql.Remove(strSql.Length - 1, 1);


            strSql.Append(" where ID=@ID");

            if (SqlHelper.ExecuteNonQuery(strSql.ToString(), parms) > 0)
            {
                OnUpdate("");
                return true;
            }
            else
            {
                return false;
            }


        }
        #endregion
        
         #region GetModel 得到一个实体对象
        /// <summary>
        /// 得到一个实体对象
        /// </summary>
        /// <param name="ID">主键ID</param>
        /// <returns></returns>
        public <%= rule.GetTableName(TableName) %>Info GetModel(int ID)
        {
            StringBuilder strSql = new StringBuilder();
                <% sqlStr="";
            
        for(int i=0;i<columns.Count;i++)
        {
            
            if(i+1==columns.Count)
            {
                sqlStr+=columns[i].Name;
                
            }
            else
            {
                sqlStr+=columns[i].Name+",";
                
            }
            
        }%>
            
            strSql.Append("SELECT  <%=sqlStr%> FROM t_<%= rule.GetTableName(TableName) %> ");
            strSql.Append(" where ID=@ID ");
            SqlParameter[] parameters = {
                    new SqlParameter("@ID", SqlDbType.Int,4)};
            parameters[0].Value = ID;
            <%= rule.GetTableName(TableName) %>Info model = new <%= rule.GetTableName(TableName) %>Info();
            using (SqlDataReader dr = SqlHelper.ExecuteReader(strSql.ToString(), parameters))
            {
                while (dr.Read())
                {
                <%
                for(int i=0;i<columns.Count;i++)
                {
                    switch(rule.GetType(columns[i]))
                    {
                        case "int":
                                %>
                                model.<%=columns[i].Name%> = dr.GetInt32(<%=i%>);   
                                <%
                                break;
                            case "string":
                                %>
                                model.<%=columns[i].Name%> = dr.GetString(<%=i%>);     
                                <%
                                break;
                            case "DateTime":
                                %>
                                model.<%=columns[i].Name%> = dr.GetDateTime(<%=i%>);     
                                <%
                                break;
                            default:
                                %>
                                 
                                <%
                            break;
                    }
                        
                    
                }
                
                %>
                    
                 

                }

            }
            return model;
        }

        /// <summary>
        /// 得到一个实体对象
        /// </summary>
        /// <param name="where">where条件 eg: name='awp'</param>
        /// <returns></returns>
        public <%= rule.GetTableName(TableName) %>Info GetModel(string where)
        {
            StringBuilder strSql = new StringBuilder();
          <% sqlStr="";
            
        for(int i=0;i<columns.Count;i++)
        {
            
            if(i+1==columns.Count)
            {
                sqlStr+=columns[i].Name;
                
            }
            else
            {
                sqlStr+=columns[i].Name+",";
                
            }
            
        }%>
            
            strSql.Append("SELECT  <%=sqlStr%> FROM t_<%= rule.GetTableName(TableName) %> ");
            if (!string.IsNullOrEmpty(where))
            {
                strSql.Append(" where  " + where);
            }

            <%= rule.GetTableName(TableName) %>Info model = new <%= rule.GetTableName(TableName) %>Info();
            using (SqlDataReader dr = SqlHelper.ExecuteReader(strSql.ToString(), null))
            {
                while (dr.Read())
                {
                 <%
                for(int i=0;i<columns.Count;i++)
                {
                    switch(rule.GetType(columns[i]))
                    {
                        case "int":
                                %>
                                model.<%=columns[i].Name%> = dr.GetInt32(<%=i%>);   
                                <%
                                break;
                            case "string":
                                %>
                                model.<%=columns[i].Name%> = dr.GetString(<%=i%>);     
                                <%
                                break;
                            case "DateTime":
                                %>
                                model.<%=columns[i].Name%> = dr.GetDateTime(<%=i%>);     
                                <%
                                break;
                            default:
                                %>
                                 
                                <%
                            break;
                    }
                        
                    
                }
                
                %>
                }

            }
            return model;
        }
        #endregion
        
        
        #region 参数处理

        private static SqlParameter[] GetParameters(string Keys)
        {
            //从缓存中获取参数 如果不存在 重新生成
            SqlParameter[] parms = SqlHelper.GetCachedParameters(Keys);

            if (parms == null)
            {

                parms = new SqlParameter[] {
                <%
                for(int i=0;i<columns.Count;i++)
                {
                    switch(rule.GetType(columns[i]))
                    {
                            case "int":
                                %>
                                new SqlParameter("@<%=columns[i].Name%>", SqlDbType.Int,<%=columns[i].Size%>),
                                <%
                                break;
                            case "string":
                                %>
                                new SqlParameter("@<%=columns[i].Name%>",  SqlDbType.VarChar,<%=columns[i].Size%>),
                                <%
                                break;
                            case "DateTime":
                                %>
                                new SqlParameter("@<%=columns[i].Name%>", SqlDbType.DateTime),     
                                <%
                                break;
                            default:
                                %>
                                new SqlParameter("@<%=columns[i].Name%>", SqlDbType.<%=rule.GetType(columns[i])%>),
                                <%
                            break;
                    }
                }    
                %>
                                        };
                SqlHelper.CacheParameters(Keys, parms);
            }

            return parms;
        }

        #endregion
        

        
    }
}


CodeSmith Generator 7.1.0 最新版原版程序+注册机+激活说明
10-03
有条件请支持正版，目前最新版，官网下载便携版7.1，注册机通过杀软验证，五毒无捆绑，请放心使用。 CodeSmith Generator 7.1.0 最新版原版程序+注册机+激活说明
CodeSmith使用教程 - v1.01
08-03
CodeSmith 是一款强大的代码生成工具，它通过使用模板语言，类似 ASP.NET 的语法，来自动生成各种编程语言的代码或文本。本教程旨在帮助开发者掌握如何有效地利用 CodeSmith 进行自动化编码工作。 ### 第 1 章：...
调用CodeSmith类库实现代码生成(含源码)
小Q的博客
11-04 1721
CodeSmith的作用是不言而喻的,用过的人都会觉得它非常强大.根据自定义模板,快速生成代码.只是我们使用的时候,要在它提供的CodeSmith Studio环境下使用模板,再传入相应参数,最终生成NET的类文件.
CodeSmith基础教程
sjsm2007的专栏
01-08 2092
请大家耐心看完所有的基础文章，前两篇网上发表的比较多，是CodeSmith英文帮助文档的第一篇，我后面写的基础是将其他所有的英文帮助全部翻译出来了，全部为本人手写翻译，希望对大家有所帮助 一、第一个模板         创建好一个模板后第一步要指明这是一个C#语言的模板。       Description="Generates a class including a spe
CodeSmith绿色化的情况下,又能使之正常工作
郝玉杰的专栏
09-24 1270
最近，完成的工作中，需要使用CodeSmith
CodeSmith通过CSP文件生成代码的API使用
郝玉杰的专栏
08-05 1325
using CodeSmith.Engine;                 ProjectCodeGenerator myGen = new ProjectCodeGenerator();             myGen.GenerateCode(@"E:\work2\AutoPack\07_MyParser\out\debug\bin\PkgInf\UserInputPa
CodeSmith使用
站住借个吻的专栏
09-11 587
所用工具： CodeSmith Professional v5.1.3.8510，代码示例全部是以C#为例。 一、            工具设置 CodeSmith默认是不支持中文的，那么我们必须要先设置使其支持中文显示，保存。并且要能够在生成文件中支持中文。 [Tools->Options...->Studio->Editor->Enable unicode]将这个选项勾上，那么Co
CodeSmith 使用说明
weixin_34384681的博客
02-27 132
〇、            前言 最近两天自己写了个简单的ORM框架，非常的Easy，但是没有相应的代码生成工具，于是就很杯具了！ 于是乎，花费了一天的时间学习并写了一个CodeSmith可以使用的模板。在此记录下CodeSmith的学习笔记。 所用工具： CodeSmith Professional v5.1.3.8510，代码示例全部是以C#为例。 一、            工具设置...
CodeSmith使用心得
weixin_30338481的博客
07-07 162
代码生成器大家都用过吧，CodeSmith我想大家也不陌生。最近就用CodeSmith生成了自己的实体类。当然你也可以用它来生成HTML页面以及文档。 下面我就来说一说我生成实体类的步骤： 一、首先介绍一下CodeSmith 2.6，CodeSmith 2.6安装后，会有3个exe: 1. CodeSmith.exe即为CodeSmith Explorer，可视化生成代码工具，免...
CodeSmith使用手册及实例
angnong3282的博客
04-16 193
自己很早以前写过一系列CodeSmith的使用方法。今天把它打包为一个PDF文档供大家当做备忘录。本文档包含了CodeSmith的基本使用和三层架构各层代码模板的编写教程。还有整理的CodeSmith API大全和常用技巧。 在线预览：如果看不清本屏即可！ 转载于:https://www.cnblogs.com/astar/archive/20...
codesmith使用方法
11-03
【codesmith 使用方法详解】 Codesmith 是一款强大的代码生成工具，尤其在快速开发过程中能显著提升效率。通过自定义模板，它可以自动生成如 ORM 框架、数据库访问层、业务逻辑层等代码，减少重复劳动。以下是 ...
CodeSmith 使用手册 简易教程
12-30
接下来，我们关注《CodeSmith使用手册及实例.pdf》。这个文档可能更深入地探讨了CodeSmith的高级特性和实际应用： 1. **高级模板特性**：包括自定义宏、用户函数、模板继承和部分模板，以及如何利用这些特性创建...
CodeSmith 使用笔记
12-16
这个"CodeSmith使用笔记"包含了逐步的操作指南和源码示例，是学习和掌握CodeSmith的好帮手。 首先，CodeSmith的核心功能是通过模板语言自动生成代码。这种模板语言允许开发者定义规则，根据数据库模型生成诸如DAL...
win7_oracle11g_64位连接32位PLSQL_Develop
miracletiger的专栏
08-03 865
由于现在的笔记本大都是64位的window7系统，然而PLSQL_Developer没有64位的，这造成了我们连接的麻烦，这里教大家怎么将win7_oracle11g_64位连接32位PLSQL_Developer。并解决在使用PLSQL_Developer时出现中文乱码。现在开始吧~ 已经装好的64位Oracle数据库 window7_64位的
利用CodeSmith在自己的工程中动态生成代码
郝玉杰的专栏
04-18 3386
这一个星期都在与代码生成器在
C# 异步编程(使用异步Lambda表达式)
钢铁男儿
08-09 1067
到目前为止，本章只介绍了异步方法。但我们曾经说过，你还可以使用异步匿名方法和异步Lambda表达式。这些构造尤其适合那些只有少量工作要做的事件处理程序。下面的代码片段将一个表达式注册为一个按钮点击事件的事件处理程序。XAML文件中的标记如下：</图21-13展示了这段程序生成的窗体的三种状态。
c#属性（Property）的概念定义及使用详解
最新发布
2510_91653061的博客
08-10 426
在C#编程中，属性（Property）是类、结构和接口的成员，提供了一种机制来读取、写入或计算一个类的私有字段的值。属性可以看作是字段和方法的结合，通过使用属性，可以控制对类成员的访问，使代码更加清晰、简洁且易于维护。属性是C#编程中的重要概念，提供了对字段的安全访问方式。通过属性，开发者可以更好地封装数据、控制访问权限和实现数据验证，从而提升代码的可读性和维护性。熟练掌握属性的使用对于编写高质量的C#程序至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值