运用CodeSmith Studio实现C#项目构架

最新推荐文章于 2019-12-12 10:39:57 发布
最新推荐文章于 2019-12-12 10:39:57 发布
阅读量753 收藏
点赞数 1
分类专栏： .NET 文章标签： c# string assembly 数据库 import list
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq409982078/article/details/6611386
版权

摘要：运用CodeSmith Studio可以非常方便的针对具体的数据库生成C#项目的构架。本文将简要介绍操作流程。

准备工作：安装好CodeSmith Studio（网上一搜，到处都有下载）、Visual Studio、Mssql Server。

  1. 建立好数据库。假如数据库名叫SkillExchange。
  2. 启动CodeSmith，连接数据库。在Schema Explorer（如果主界面没有显示，在菜单View中将其打开）中点击“+”图标，在弹出的【Data Source Manager】中选择【Add】。在弹出【Data Source】对话框中，自己给该数据源取一个名称，【Provider Type】选择【SqlSchemaProvider】，点击【Connection String】右侧的按钮，可以帮助生成连接字符串。之后点几个OK，一个Close，数据库连接就大功告成了。
  3. 使用模版生成3层代码。在模板管理器【Template Explorer】中选择模版，双击打开。这里要用到的项目构架代码可能找不到，我在这里提供。该模板来源于网络，也还有可以改进的地方。

Model.cst（用于生成数据库表中字段的封装类，每个表生成一个类）

<%@ CodeTemplate Language="C#" TargetLanguage="C#" Description="Template description here." %>
<%@ Assembly Name="SchemaExplorer" %>
<%@ Import Namespace="SchemaExplorer" %>
<%@ Property Name="SourceTable" Type="SchemaExplorer.TableSchema" Category="Context" %>
<%@ Import Namespace="System.Text.RegularExpressions" %>
using System;
using System.Collections.Generic;
using System.Text;

namespace MODEL
{
	[Serializable]
	public class <%=GetClassName(SourceTable)%>
	{
		<% foreach (ColumnSchema column in SourceTable.Columns) {%>
		<% if (column.IsForeignKeyMember) {%>
		private <%=GetPascalName(GetForeignKeyColumnType(column))%> <%=GetCamelName(GetForeignKeyColumnName(column))%> = new <%=GetPascalName(GetForeignKeyColumnType(column))%>();
		<% }else{%>
		private <%=GetCSharpVariableType(column)%> <%=GetCamelName(column)%>;
		<% }%>
		<% }%>	
		
		<% foreach (ColumnSchema column in SourceTable.Columns) {%>
		<% if (column.IsForeignKeyMember) {%>
		public <%=GetPascalName(GetForeignKeyColumnType(column)) %> <%=GetPascalName(GetForeignKeyColumnName(column))%>
		{
			get { return <%=GetCamelName(GetForeignKeyColumnName(column)) %>; }
			set { <%=GetCamelName(GetForeignKeyColumnName(column)) %> = value; }
		}
		<% } else {%>
		public <%=GetCSharpVariableType(column) %> <%=GetPascalName(column) %>
		{
			get { return <%= GetCamelName(column) %>; }
			set { <%= GetCamelName(column) %> = value; }
		}
		<% }%>
		<% }%>
	}
}
<script runat="template">

public string MakeSingle(string name)
{
	return name;
}
public string GetCamelName(ColumnSchema column)
{
	return column.Name.Substring(0, 1).ToLower() + column.Name.Substring(1);
}
public string GetCamelName(string value)
{
	return value.Substring(0, 1).ToLower() + value.Substring(1);
}
public string GetPascalName(ColumnSchema column)
{
	return column.Name.Substring(0, 1).ToUpper() + column.Name.Substring(1);
}
public string GetPascalName(string value)
{
	return value.Substring(0, 1).ToUpper() + value.Substring(1);
}
public string GetClassName(TableSchema table)
{
	return GetPascalName(MakeSingle(table.Name));
}	
public string GetForeignKeyColumnType(ColumnSchema column)
{		
	return column.Table.ForeignKeys[0].PrimaryKeyTable.Name;
}
public string GetForeignKeyColumnName(ColumnSchema column)
{	
	if(column.Name.Substring(column.Name.Length-2).ToLower() == "id")
	{
		return column.Name.Substring(0,column.Name.Length-2);
	}
	else
	{
		return column.Name;
	}
}

public string GetStructureParameter()
{//int id,string name
		string temp = "";
		foreach(ColumnSchema column in SourceTable.NonPrimaryKeyColumns) 
		{
				if(column.IsForeignKeyMember) 
				{
					temp += GetPascalName(GetForeignKeyColumnType(column)) + " " +GetCamelName(GetForeignKeyColumnName(column)) + ",";
				}
				else
				{
					temp += GetCSharpVariableType(column) + " " + GetCamelName(column) + ",";
				}
		}
		return temp.Substring(0,temp.Length-1);
}
public string GetPrimaryKeyType(TableSchema table)
{
	if (table.PrimaryKey != null)
	{
		if (table.PrimaryKey.MemberColumns.Count == 1)
		{
			return GetCSharpVariableType(table.PrimaryKey.MemberColumns[0]);
		}
		else
		{
			throw new ApplicationException("This template will not work on primary keys with more than one member column.");
		}
	}
	else
	{
		throw new ApplicationException("This template will only work on tables with a primary key.");
	}
}
public string GetCSharpVariableType(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 "byte";
		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;
		}
	}
}	
public override string GetFileName()
{
	return 	GetClassName(SourceTable) + ".cs";
}
</script>

DAL.cst（Data Access Layer，用于生成数据库的增删改查类）

<%@ CodeTemplate Language="C#" TargetLanguage="C#" Description="Create:Teacher Pan"%>
<%@ Assembly Name="SchemaExplorer" %>
<%@ Import Namespace="SchemaExplorer" %>
<%@ Property Name="SourceTable" Type="SchemaExplorer.TableSchema" Category="Context" %>
<%@ Import Namespace="System.Text.RegularExpressions" %>
using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.Data.SqlClient;
using MODEL;

namespace DAL
{
	public class <%=GetClassName(SourceTable)%>Service
	{
		private const string SQL_INSERT_<%=SourceTable.Name.ToUpper()%> = "<%=GetAddConstString(SourceTable)%>";
		private const string SQL_UPDATE_<%=SourceTable.Name.ToUpper()%> = "<%=GetUpdateConstString(SourceTable)%>";
		private const string SQL_DELETE_<%=SourceTable.Name.ToUpper()%>_BY_ID = "<%=GetDeleteConstString(SourceTable)%>";
		private const string SQL_SELECT_<%=SourceTable.Name.ToUpper()%>_ALL = "SELECT * FROM <%=SourceTable.Name%>";
		private const string SQL_SELECT_ONE_<%=SourceTable.Name.ToUpper()%>_BY_ID = "SELECT * FROM <%=SourceTable.Name%> WHERE <%=GetPascalName(SourceTable.PrimaryKey.MemberColumns[0].Name)%>=@<%=GetPascalName(SourceTable.PrimaryKey.MemberColumns[0].Name)%>";

		public static int Add<%=GetClassName(SourceTable)%>(<%=GetClassName(SourceTable)%> <%=GetCamelName(GetClassName(SourceTable))%>)
		{
			<%=GetAddMothodText(SourceTable)%>
		}
	
		public static int Update<%=GetClassName(SourceTable)%>(<%=GetClassName(SourceTable)%> <%=GetCamelName(GetClassName(SourceTable))%>)
		{
			<%=GetUpdateMothodText(SourceTable)%>
		}
	
		public static int Delete<%=GetClassName(SourceTable)%>ById(<%=GetCSharpVariableType(SourceTable.PrimaryKey.MemberColumns[0].Column)%> id)
		{
			<%=GetDeleteMothodText(SourceTable)%>
		}
    
		public static List<<%=GetClassName(SourceTable)%>> GetAll<%=SourceTable.Name%>()
		{
			return Get<%=SourceTable.Name%>BySql(CommandType.Text, SQL_SELECT_<%=SourceTable.Name.ToUpper()%>_ALL, null);
		}
	
		public static <%=GetClassName(SourceTable)%> Get<%=GetClassName(SourceTable)%>ById(<%=GetCSharpVariableType(SourceTable.PrimaryKey.MemberColumns[0].Column)%> id)
		{
			SqlParameter commandParameters = new SqlParameter("@<%=GetPascalName(SourceTable.PrimaryKey.MemberColumns[0].Name)%>",id);
			List<<%=GetClassName(SourceTable)%>> list = Get<%=SourceTable.Name%>BySql(CommandType.Text ,SQL_SELECT_ONE_<%= SourceTable.Name.ToUpper() %>_BY_ID, commandParameters);
			if (list.Count > 0)
			{
				return list[0];
			}
			return null;
		}
	
		private static List<<%=GetClassName(SourceTable)%>> Get<%=SourceTable.Name%>BySql(CommandType commandType, string commandText, params SqlParameter[] commandParameters)
		{ 
			List<<%=GetClassName(SourceTable)%>> list = new List<<%=GetClassName(SourceTable)%>>();
			using(SqlDataReader reader = DBHelper.ExecuteGetReader(commandType,commandText,commandParameters))
			{
				List<string> columnNames = new List<string>();
				for (int i = 0; i < reader.FieldCount; i++)
				{
					columnNames.Add(reader.GetName(i));
				}
				while (reader.Read())
				{
					<%=GetClassName(SourceTable)%> <%=GetCamelName(GetClassName(SourceTable))%> = new <%=GetClassName(SourceTable)%>();
				
					//NonForeignKey					
					<%=GetNonForeignKeyColumnsText(SourceTable)%>
					<%if(SourceTable.ForeignKeys.Count > 0){%>					
					//ForeignKey
					<%for(int i=0;i<SourceTable.ForeignKeys.Count;i++){%>
					<%=GetForeignKeyTableNewObjectText(SourceTable.ForeignKeys[i].PrimaryKeyTable,SourceTable.ForeignKeys[i].ForeignKeyMemberColumns[0])%>
					<%=GetForeignKeyColumnsText(SourceTable.ForeignKeys[i].PrimaryKeyTable,SourceTable.ForeignKeys[i].ForeignKeyMemberColumns[0])%>					
					<%=AddForeignKeyObjectInPrimaryObject(SourceTable.ForeignKeys[i].PrimaryKeyTable,SourceTable.ForeignKeys[i].ForeignKeyMemberColumns[0])%>
					<%}%>					
					<%}%>					
					list.Add(<%=GetCamelName(GetClassName(SourceTable))%>);
				}
			}
			return list;
		}
  	}
}

<script runat="template">
public string GetCSharpVariableType(ColumnSchema column)
{
	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 "byte";
		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;
		}
	}
}
public string GetClassName(TableSchema table)
{	//need update ....    
	return GetPascalName(MakeSingle(table.Name));  //ToPascalName
}
public string GetPascalName(string name)
{
	return name.Substring(0,1).ToUpper() + name.Substring(1);
}
public string GetCamelName(string name)
{
	return name.Substring(0,1).ToLower() + name.Substring(1);
}
public string GetPrimaryKeyName(TableSchema table)
{
	return SourceTable.PrimaryKey.MemberColumns[0].Name;	
}
public string GetForeignKeyColumnType(ColumnSchema column)
{		
	return column.Table.ForeignKeys[0].PrimaryKeyTable.Name;
}
public string GetForeignKeyColumnName(ColumnSchema column)
{	
	if(column.Name.Substring(column.Name.Length-2).ToLower() == "id")
	{
		return column.Name.Substring(0,column.Name.Length-2);
	}
	else
	{
		return column.Name;
	}
}
public string GetForeignKeyTablePrimaryColumn(ColumnSchema column)
{	
	return column.Table.ForeignKeys[0].PrimaryKeyTable.PrimaryKey.MemberColumns[0].Name;
}
/**/
public string MakeSingle(string name)
{
	return name;
}

public string GetAddConstString(TableSchema SourceTable)
{
	string temp = "INSERT INTO "+ SourceTable.Name +" VALUES (";
  foreach(ColumnSchema column in SourceTable.NonPrimaryKeyColumns)
	{
	    temp += "@" + GetPascalName(column.Name) + ",";
	}
	return temp.Substring(0,temp.Length-1) + ");SELECT @@IDENTITY";
}
public string GetUpdateConstString(TableSchema SourceTable)
{
    //update x set title=@title,,,, where id=@id;
	string temp = "UPDATE " + SourceTable.Name +" SET ";
    foreach(ColumnSchema column in SourceTable.NonPrimaryKeyColumns)
	{
	    temp += GetPascalName(column.Name) +"=@" + GetPascalName(column.Name) + ",";
	}
	return temp.Substring(0,temp.Length-1) + " WHERE " + GetPascalName(SourceTable.PrimaryKey.MemberColumns[0].Name) + "=@" + GetPascalName(SourceTable.PrimaryKey.MemberColumns[0].Name);
}
public string GetDeleteConstString(TableSchema SourceTable)
{
    //delete from table where id=@id;
	string temp = "DELETE FROM " + SourceTable.Name + " WHERE " + GetPascalName(SourceTable.PrimaryKey.MemberColumns[0].Name) + "=@" + GetPascalName(SourceTable.PrimaryKey.MemberColumns[0].Name);
	return temp;
}
/*MothodText*/
public string GetAddMothodText(TableSchema SourceTable)
{
	string temp = "SqlParameter[] commandParameters = new SqlParameter[]" + "\r\n" 
				+ "\t\t\t"+ "{" +"\r\n";
    foreach(ColumnSchema column in SourceTable.NonPrimaryKeyColumns)
	{   
			if(column.IsForeignKeyMember)			
	    		temp += "\t\t\t\t"+"new SqlParameter(\"@" + GetPascalName(column.Name) + "\", " + GetCamelName(GetClassName(SourceTable)) + "." + GetPascalName(GetForeignKeyColumnName(column)) + "."+ GetForeignKeyTablePrimaryColumn(column) +"),\r\n";		
			else
				temp += "\t\t\t\t"+"new SqlParameter(\"@" + GetPascalName(column.Name) + "\", " + GetCamelName(GetClassName(SourceTable)) + "." + GetPascalName(column.Name) + "),\r\n";		
	}
	temp = temp.Substring(0,temp.Length-3) + "\r\n\t\t\t};";
	temp += "\r\n\t\t\t"+ "int id = Convert.ToInt32(DBHelper.ExecuteScalar(CommandType.Text, SQL_INSERT_" + SourceTable.Name.ToUpper() +", commandParameters));\r\n"; 
  temp += "\t\t\t"+"return id;"; 			
  return temp;	    
}
public string GetUpdateMothodText(TableSchema SourceTable)
{
	string temp = "SqlParameter[] commandParameters = new SqlParameter[]" + "\r\n" 
				+ "\t\t\t"+ "{" +"\r\n";
  	foreach(ColumnSchema column in SourceTable.Columns)
	{   
			if(column.IsForeignKeyMember)	
				temp += "\t\t\t\t"+"new SqlParameter(\"@" + GetPascalName(column.Name) + "\", " + GetCamelName(GetClassName(SourceTable)) + "." + GetPascalName(GetForeignKeyColumnName(column)) + "."+ GetForeignKeyTablePrimaryColumn(column) +"),\r\n";			
			else
				temp += "\t\t\t\t"+"new SqlParameter(\"@" + GetPascalName(column.Name) + "\", " + GetCamelName(GetClassName(SourceTable)) + "." + GetPascalName(column.Name) + "),\r\n";		
	}
	temp = temp.Substring(0,temp.Length-3) + "\r\n\t\t\t};";
	temp += "\r\n\t\t\t"+ "int rowCount = Convert.ToInt32(DBHelper.ExecuteNonQuery(CommandType.Text, SQL_UPDATE_"+ SourceTable.Name.ToUpper() +", commandParameters));\r\n"; 
  temp += "\t\t\t"+"return rowCount;"; 			
  return temp;	    
}
public string GetDeleteMothodText(TableSchema SourceTable)
{
	string temp = "SqlParameter commandParameters = new SqlParameter(\"@" + GetPascalName(GetPrimaryKeyName(SourceTable)) +"\", id);";
	temp += "\r\n\t\t\t"+ "int rowCount = Convert.ToInt32(DBHelper.ExecuteNonQuery(CommandType.Text, SQL_DELETE_"+ SourceTable.Name.ToUpper() +"_BY_ID, commandParameters));\r\n"; 
  temp += "\t\t\t"+"return rowCount;"; 			
  return temp;
}
public string GetNonForeignKeyColumnsText(TableSchema SourceTable)
{   //book.Id = (int)row["Id"];
    //book.Title = (string)row["Title"];
	string className = GetCamelName(GetClassName(SourceTable));
	string temp = "";
	foreach(ColumnSchema column in SourceTable.NonForeignKeyColumns)
	{  		
		temp += "if(columnNames.Contains(\""+ GetPascalName(column.Name) +"\"))"+"\r\n\t\t\t\t\t\t";
		if(GetCSharpVariableType(column) == "string")
		{
			temp += className + "." + GetPascalName(column.Name) + " = reader[\""+ GetPascalName(column.Name) +"\"].ToString();\r\n\t\t\t\t\t";
		}
		else
		{
			temp += className + "." + GetPascalName(column.Name) + " = ("+ GetCSharpVariableType(column) +")reader[\""+ GetPascalName(column.Name) +"\"];\r\n\t\t\t\t\t";	
		}				
	}
	return temp;
}
/*=============================*/
public string GetForeignKeyTableNewObjectText(TableSchema SourceTable,ColumnSchema columnName)
{
	string className = GetClassName(SourceTable);
	string temp = "";
	temp += className + " " + GetCamelName(className) + GetForeignKeyColumnName(columnName) + " = new " + className + "();";		
	return temp;
}
public string GetForeignKeyColumnsText(TableSchema SourceTable,ColumnSchema columnName)//SourceTable=????????
{	
	string className = GetClassName(SourceTable);
	string temp = "";
	int i=0;
	temp += ""+"if(columnNames.Contains(\""+ /*column*/columnName.Name +"\"))\r\n" + "\t\t\t\t\t{\r\n\t\t\t\t\t\t" 
			+ GetCamelName(className) + GetForeignKeyColumnName(columnName) + "." + SourceTable.Columns[0].Name + " = (" + GetCSharpVariableType(/*column*/columnName)
			+ ")reader[\""+ /*column*/columnName.Name +"\"];" + "\r\n\t\t\t\t\t}\r\n\t\t\t\t\t";
	foreach(ColumnSchema column in SourceTable.Columns)
	{
		if(i!=0)
		{
		temp += ""+"if(columnNames.Contains(\""+ column.Name +"\"))\r\n" + "\t\t\t\t\t{\r\n\t\t\t\t\t\t" 
			+ GetCamelName(className) + GetForeignKeyColumnName(columnName) + "." + column.Name + " = (" + GetCSharpVariableType(column)
			+ ")reader[\""+ column.Name +"\"];" + "\r\n\t\t\t\t\t}\r\n\t\t\t\t\t";
		}
		i++;
	}
	return temp;
}
public string AddForeignKeyObjectInPrimaryObject(TableSchema SourceTableForeign,ColumnSchema columnName)
{
	string className = GetClassName(SourceTableForeign);
	return GetCamelName(GetClassName(SourceTable)) + "." + GetPascalName(GetForeignKeyColumnName(columnName)) + " = " + GetCamelName(className) + GetForeignKeyColumnName(columnName) + ";\r\n";
}
public override string GetFileName()
{
	return this.GetClassName(this.SourceTable) + "Service.cs";
}
</script>


BLL.cst（Business Logical Layer，对应于DAL层的每一个方法，起到调用DAL层的作用）

<%@ CodeTemplate Language="C#" TargetLanguage="C#" Description="Create:Teacher Pan"%>
<%@ Assembly Name="SchemaExplorer" %>
<%@ Import Namespace="SchemaExplorer" %>
<%@ Property Name="SourceTable" Type="SchemaExplorer.TableSchema" Category="Context" %>
<%@ Import Namespace="System.Text.RegularExpressions" %>
using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using MODEL;
using DAL;

namespace BLL
{
    public class <%=MakeSingle(SourceTable.Name)%>Manager
    {
		public static int Add<%=MakeSingle(SourceTable.Name)%>(<%=MakeSingle(SourceTable.Name)%> <%=GetCamelName(MakeSingle(SourceTable.Name))%>)
        {
			return <%=MakeSingle(SourceTable.Name)%>Service.Add<%=MakeSingle(SourceTable.Name)%>(<%=GetCamelName(MakeSingle(SourceTable.Name))%>);
        }
		public static int Update<%=MakeSingle(SourceTable.Name)%>(<%=MakeSingle(SourceTable.Name)%> <%=GetCamelName(MakeSingle(SourceTable.Name))%>)
        {
			return <%=MakeSingle(SourceTable.Name)%>Service.Update<%=MakeSingle(SourceTable.Name)%>(<%=GetCamelName(MakeSingle(SourceTable.Name))%>);
        }
		public static int Delete<%=MakeSingle(SourceTable.Name)%>(<%=GetCSharpVariableType(SourceTable.PrimaryKey.MemberColumns[0].Column)%> id)
        {
			return <%=MakeSingle(SourceTable.Name)%>Service.Delete<%=MakeSingle(SourceTable.Name)%>ById(id);
        }
		public static List<<%=MakeSingle(SourceTable.Name)%>> GetAll<%=SourceTable.Name%>()
        {
            return <%=MakeSingle(SourceTable.Name)%>Service.GetAll<%=SourceTable.Name%>();
        }
		public static <%=MakeSingle(SourceTable.Name)%> Get<%=MakeSingle(SourceTable.Name)%>ById(<%=GetCSharpVariableType(SourceTable.PrimaryKey.MemberColumns[0].Column)%> id)
        {
            return <%=MakeSingle(SourceTable.Name)%>Service.Get<%=MakeSingle(SourceTable.Name)%>ById(id);
        }
    }
}
<script runat="template">
public string GetCSharpVariableType(ColumnSchema column)
{
	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 "byte";
		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;
		}
	}
}
public string MakeSingle(string name)
{
	return name;
}
public string GetCamelName(string name)
{
	return name.Substring(0,1).ToLower() + name.Substring(1);
}
public override string GetFileName()
{
	return this.MakeSingle(this.SourceTable.Name) + "Manager.cs";
}
</script>

将上述三个源文件按对应文件名保存，然后用CodeSmith Studio打开即可使用。

打开一个源文件，如MODEL.cst，在属性窗口【Properties】中，我们会看到【SourceTable】，点击旁边的按钮，选择对应的表。然后按【F5】，或者菜单栏的【run】，即可生成我们需要的代码，每一个表对用生成MODEL、DAL、BLL三个代码，名字分别为 TableName.cs、TableNameServices.cs、TableNameManager.cs。生成第一个类之后马上执行下一步操作。

4.在Visual Studio中生成项目

新建项目，选择【其他项目类型】中的【Visual Studio解决方案】，假如解决方案取名为TestCS，路径为“D:\”。

在【解决方案管理器】中找到刚新建的解决方案，右键【添加】，【新建项目】，【类库】。创建名为MODEL、DAL、BLL的三个类库。将CodeSmith中生成的代码分别考到对应的项目文件夹中，在解决方案中添加好。

继续右键右键【添加】，【新建网站】。注意路径应浏览到刚新建项目的对应文件夹下 ，此例中为“D:\TestCS\WEB”，点击【确定】，如果提示目录不存在，需要创建，则创建。这样就可以保证三个类库和网站都在同一个目录下。

 

5.添加引用

右键【DAL】，【添加引用...】，在弹出的【添加引用】对话框中，切换到【项目】选项卡，选择MODEL，确定。接下来分别为【BLL】添加MODEL、DAL引用，为【WEB】添加MODEL、DAL、BLL引用。

 

6.启动项设置

右键【WEB】，【设为启动项目】。

 

至此，此项目的解决方案构架基本完成。

 

总结：这个构架总的来说还是，比较简单的项目，使用使用它还是比较方便的，需要添加方法也可以直接在对应的类中编写。如果编码过程中数据库表还有改动的话，这将是比较麻烦的事，因为MODEL、DAL两层的代码都要改变。另外，我还用过一种构架，动软代码生成器。它比较强大，甚至可以生成整个项目，可是我嫌它太过于庞大，比较适合大型项目。另一个原因就是第一次接触的就是CodeSmith，适合了它的模式，习惯啊习惯！

 

后记：第一次在CSDN写博客，有不对的还请多多指教。

BlueBreezeq
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
codeSmith模板(自动生成C#和.net项目和后台)--vs05版
01-05
只需要一个数据库 生成网站后台(带功能) 生成三层结构 包括一些常用的方法（直接调用） 反射工厂 泛型接口 要求是每张表必须有主键才能生成 这点希望下载的朋友们注意一下。另外我做的几个网站全是用这个生成框架的 现在完美运行 完全没问题
CodeSmith Studio
11-19
CodeSmith Studio的核心功能是其模板引擎，它支持用户自定义模板，可以是SQL脚本、C#、VB.NET或其他编程语言。通过模板，开发者可以创建复杂的业务逻辑代码、数据访问层、实体模型、存储过程、触发器等，只需一次...
CodeSmith(C#)简单示例及相关小知识
diehe5608的博客
07-16 125
// 本文将介绍CodeSmith与数据库进行交互生成相应的存储过程，本例使用的数据库为SQL Server 2000。 // 在与数据库进行交互时，我们使用到了一个CodeSmith自带的组件SchemaExplorer，利用这个组件我们可以访问数据库的数据表、存储过程、视图等，并可以得到相应的数据类型、标识列、列的（字段）名称等信息。 // 下面这个例子是教我们如何...
C# 调用 CodeSmith 生成自己的代码.
java,c#,ExtJS.都来看....
06-10 856
废话不多说.直接进入正题. 此文章要求用户熟悉一下内容:     C# WinForm 编程开发. CodeSmith 模版编写 . 最终效果:     程序说明     为配合ssi框架整合 [2]基本参数位置 添加各种包的字符串传递.根据个人需求.自己开发. 核心说明    因需使用CodeSmith的api . 所以第一步 . 我们需要添加 CodeSmith 的Api 类
CodeSmith Generator Studio代码生成器
weixin_30457881的博客
08-10 705
1.配置数据库 新增数据库：Server=localhost;UserID=root;Password=root;Database=vmatrix;charset=utf8; 2.根据想生成的代码选择，生成所有All.cst 3.根据项目配置生成代码 4.在代码文件夹找到所需代码 粘贴到项目里 转载于:https://www.cnblogs.com/joy...
codeSmith studio
07-30
"CodeSmith Studio"是一款强大的代码生成工具，专为软件开发者设计，旨在提高开发效率和代码质量。...而WebChat项目则代表了CodeSmith Studio在实际应用场景中的一个实例，展示了如何利用工具来优化Web开发流程。
CodeSmith模板集合C#版
02-26
总结来说，"CodeSmith模板集合C#版"是一个强大的工具，它通过预定义的模板简化了C#开发中的对象持久化和数据库事务处理，使得开发者可以更专注于业务逻辑的实现，而不是基础代码的编写。对于大型项目或者团队开发，...
CodeSmith 8.0 可用且说明详细
06-20
详细安装说明，亲测可用，可对任何ASCII语言生成代码模板。CodeSmith Generator 8.0.1生成器是一个软件开发工具,以帮助您更快地完成工作。从技术上讲它是一个模板驱动的源代码生成器,可以自动创建通用应用程序
CodeSmith.zip
03-06
CodeSmith是一款强大的自动代码生成工具，它极大地提高了C#开发者的工作效率。在软件开发过程中，编写重复的代码是...通过熟练掌握CodeSmith，开发者可以更专注于设计和实现项目的独特功能，而不是反复编写类似的代码。
高效CodeSmith C# 三层结构模板
06-02
纯手工编写的CodeSmith模板，效率比动软生成的代码要高，因为去除了一些不必要的功能，可直接运用到实际项目中。包含增、删、查、改的公共方法和内部对象转换方法。 使用：使用CodeSmith加载模板后，打开Generate.cst，指定数据库和项目名称即可
C#版 -- 实用性CodeSmith模板（自动生成三层架构底层代码）
03-04
本模板可以自动生成三层架构底层代码，方便有经验的开发者能够节省大量代码量。
CodeSmith模版-生成C#增删改查（分页，主键）方法和存储过程
06-19
1生成Model层的实体类的“MyModels.cst”文件：本文件根据数据库的字段生成实体类，实体类的 命名规则是：表名+Model。例如有表：Table1那么生成的实体类为：Table1Model。其中的住外键关 系没有做处理，请自行处理。 2生成DAL层的与数据库打交道的类的“表的增删改查(分页，主键)C#方法.cst”文件。本文件 根据表的内容生成C#方法,包括增、删、改、查（分页查询和根据主键列查询）。 3与DAL层对应的也就是DAL层C#方法中要调用相应的“存储过程”，而这些存储过程则由“表的增删改查（分页，主键）SQL存储过程.cst”文件生成。存储过程名称也不用修改，都是“一一对应的”。 4而“表的增删改查(分页，主键)C#方法.cst”文件依赖于一个基层操作数据库的文件。该文件既是：“SQLDBHelper.cs”。 所以可以说这些文件时有关的，但用户也可以自行修改，但也要遵循一定的原则。 作者：王改娜. QQ:550927361. Email:wanggaina666@163.com
DotNet代码生成器CodeSmith
06-19
本软件主要是用来做.Net开发代码生成的，适用环境为VS2008+ .Net framework4.0 Client Profile SQL2008+ C#； 适用于使用传统三层架构，使用存储过程，并且对性能没有严格控制的中小型项目。本软件是由国外著名的CodeSmith代码生成器
基于 CodeSmith 模板的开源代码生成器
12-25
这是一个针对数据库的代码生成器。 使用 CodeSmith 模板生成 实体、数据访问对象基类、数据访问对象的 SqlServer 实现、业务逻辑对象。
编程好帮手----CodeSmith Generator Studio
weixin_30426879的博客
11-29 318
这是一个很好用的代码生成器，可以将数据库中的表生成类，这是和表中的字段一一对应这就很给力了，方便准确 转载于:https://www.cnblogs.com/hyk110988/p/3449274.html...
CodeSmith 引用C# 工具类方法
hezheqiang的专栏
12-12 405
CodeSmith在使用中，对数据库中表字段进行处理时，需要封装一些公用方法。下面提供调用方法： 一.创建工具类Common.cs,类下的属性和方法必须为静态类。代码如下： public static class Common { /// <summary> /// 获取当前日期 /// </summary> /// <retu...
CodeSmith 使用教程(1): 概述
mapdigit
10-24 362
前面正在介绍hibernate的开发教程，提到hibernate 在.Net 平台上相应的ORM工具为NHibernate ，使用NHibernate 就不能不提到CodeSmith。 CodeSmith 是一种基于模板的代码生成工具，它使用类似于 ASP.NET 的语法来生成任意类型的代码或文本。与其他许多代码生成工具不同，CodeSmith 不要求您订阅特定的应用程序设计或体系结构。...
调用CodeSmith类库实现代码生成(含源码)
小Q的博客
11-04 1651
CodeSmith的作用是不言而喻的,用过的人都会觉得它非常强大.根据自定义模板,快速生成代码.只是我们使用的时候,要在它提供的CodeSmith Studio环境下使用模板,再传入相应参数,最终生成NET的类文件.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值