如何从C＃类生成数据库表？
有谁知道一种自动为给定类生成数据库表的方法？我并没有寻找一个完整的持久层，我已经有一个正在使用的数据访问解决方案，但是我突然不得不存储来自大量类的很多信息，我真的不想创建所有的持久化层。这些表是手工制作的。例如，给定以下类别：
class Foo
{
private string property1;
public string Property1
{
get { return property1; }
set { property1 = value; }
}
private int property2;
public int Property2
{
get { return property2; }
set { property2 = value; }
}
}
我希望使用以下SQL：
CREATE TABLE Foo
(
Property1 VARCHAR(500),
Property2 INT
)
我也想知道我们如何处理复杂类型。例如，在前面引用的类中，如果我们将其更改为：
class Foo
{
private string property1;
public string Property1
{
get { return property1; }
set { property1 = value; }
}
private System.Management.ManagementObject property2;
public System.Management.ManagementObject Property2
{
get { return property2; }
set { property2 = value; }
}
}
我该如何处理？
我已经尝试过自己尝试使用反射自动枚举每个类的属性来自动生成数据库脚本，但是它很笨拙，而且复杂的数据类型也让我很困惑。
解决方案
回答
对于复杂类型，我们可以将遇到的每个递归地转换成它自己的表，然后尝试管理外键关系。
我们可能还需要预先指定将或者不将哪些类转换为表。至于要在数据库中反映而不使架构膨胀的复杂数据，我们可以具有一个或者多个其他类型的表。此示例使用多达4个：
CREATE TABLE MiscTypes /* may have to include standard types as well */
( TypeID INT,
TypeName VARCHAR(...)
)
CREATE TABLE MiscProperties
( PropertyID INT,
DeclaringTypeID INT, /* FK to MiscTypes */
PropertyName VARCHAR(...),
ValueTypeID INT /* FK to MiscTypes */
)
CREATE TABLE MiscData
( ObjectID INT,
TypeID INT
)
CREATE TABLE MiscValues
( ObjectID INT, /* FK to MiscData*/
PropertyID INT,
Value VARCHAR(...)
)
回答
这真的很晚，我只花了大约10分钟的时间，所以它非常草率，但是它确实起作用，并且会给我们一个很好的起点：
using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
namespace TableGenerator
{
class Program
{
static void Main(string[] args)
{
List<TableClass> tables = new List<TableClass>();
// Pass assembly name via argument
Assembly a = Assembly.LoadFile(args[0]);
Type[] types = a.GetTypes();
// Get Types in the assembly.
foreach (Type t in types)
{
TableClass tc = new TableClass(t);
tables.Add(tc);
}
// Create SQL for each table
foreach (TableClass table in tables)
{
Console.WriteLine(table.CreateTableScript());
Console.WriteLine();
}
// Total Hacked way to find FK relationships! Too lazy to fix right now
foreach (TableClass table in tables)
{
foreach (KeyValuePair<String, Type> field in table.Fields)
{
foreach (TableClass t2 in tables)
{
if (field.Value.Name == t2.ClassName)
{
// We have a FK Relationship!
Console.WriteLine("GO");
Console.WriteLine("ALTER TABLE " + table.ClassName + " WITH NOCHECK");
Console.WriteLine("ADD CONSTRAINT FK_" + field.Key + " FOREIGN KEY (" + field.Key + ") REFERENCES " + t2.ClassName + "(ID)");
Console.WriteLine("GO");
}
}
}
}
}
}
public class TableClass
{
private List<KeyValuePair<String, Type>> _fieldInfo = new List<KeyValuePair<String, Type>>();
private string _className = String.Empty;
private Dictionary<Type, String> dataMapper
{
get
{
// Add the rest of your CLR Types to SQL Types mapping here
Dictionary<Type, String> dataMapper = new Dictionary<Type, string>();
dataMapper.Add(typeof(int), "BIGINT");
dataMapper.Add(typeof(string), "NVARCHAR(500)");
dataMapper.Add(typeof(bool), "BIT");
dataMapper.Add(typeof(DateTime), "DATETIME");
dataMapper.Add(typeof(float), "FLOAT");
dataMapper.Add(typeof(decimal), "DECIMAL(18,0)");
dataMapper.Add(typeof(Guid), "UNIQUEIDENTIFIER");
return dataMapper;
}
}
public List<KeyValuePair<String, Type>> Fields
{
get { return this._fieldInfo; }
set { this._fieldInfo = value; }
}
public string ClassName
{
get { return this._className; }
set { this._className = value; }
}
public TableClass(Type t)
{
this._className = t.Name;
foreach (PropertyInfo p in t.GetProperties())
{
KeyValuePair<String, Type> field = new KeyValuePair<String, Type>(p.Name, p.PropertyType);
this.Fields.Add(field);
}
}
public string CreateTableScript()
{
System.Text.StringBuilder script = new StringBuilder();
script.AppendLine("CREATE TABLE " + this.ClassName);
script.AppendLine("(");
script.AppendLine("\t ID BIGINT,");
for (int i = 0; i < this.Fields.Count; i++)
{
KeyValuePair<String, Type> field = this.Fields[i];
if (dataMapper.ContainsKey(field.Value))
{
script.Append("\t " + field.Key + " " + dataMapper[field.Value]);
}
else
{
// Complex Type?
script.Append("\t " + field.Key + " BIGINT");
}
if (i != this.Fields.Count - 1)
{
script.Append(",");
}
script.Append(Environment.NewLine);
}
script.AppendLine(")");
return script.ToString();
}
}
}
我将这些类放在程序集中进行测试：
public class FakeDataClass
{
public int AnInt
{
get;
set;
}
public string AString
{
get;
set;
}
public float AFloat
{
get;
set;
}
public FKClass AFKReference
{
get;
set;
}
}
public class FKClass
{
public int AFKInt
{
get;
set;
}
}
并生成了以下SQL：
CREATE TABLE FakeDataClass
(
ID BIGINT,
AnInt BIGINT,
AString NVARCHAR(255),
AFloat FLOAT,
AFKReference BIGINT
)
CREATE TABLE FKClass
(
ID BIGINT,
AFKInt BIGINT
)
GO
ALTER TABLE FakeDataClass WITH NOCHECK
ADD CONSTRAINT FK_AFKReference FOREIGN KEY (AFKReference) REFERENCES FKClass(ID)
GO
一些进一步的想法...我会考虑在类中添加[SqlTable]之类的属性，这样它只会为所需的类生成表。此外，这可以清理大量，修复错误，进行优化(FK Checker只是在开玩笑)等……只是为了让我们入门。
回答
我认为对于复杂的数据类型，应该通过指定ToDB()方法来扩展它们，该方法拥有自己的实现，用于在数据库中创建表，这样它就可以自动递归。
回答
另外...也许我们可以使用诸如Visio之类的工具(不确定Visio是否这样做，但是我认为确实如此)将类反向工程为UML，然后使用UML生成数据库架构...或者也许使用像这样的工具http://www.tangiblearchitect.net/visual-studio/
回答
我知道我们正在寻找整个持久层，但是NHibernate的hbm2ddl任务几乎可以单线完成。
有一个NAnt任务可以调用它，这可能很有趣。
回答
@乔纳森·霍兰德
哇，我认为这是我在StackOverflow帖子中见过的最原始的工作。做得好。但是，一定不要使用SQL 2005引入的SQL Server管理对象类，而不是将DDL语句构造为字符串。
David Hayden的标题为"使用Cand SQL Server管理对象(SMO)代码生成在SQL Server 2005中创建表"的文章，介绍了如何使用SMO创建表。使用以下方法可以轻松实现强类型对象：
// Create new table, called TestTable Table newTable = new Table(db, "TestTable");
和
// Create a PK Index for the table Index index = new Index(newTable, "PK_TestTable"); index.IndexKeyType = IndexKeyType.DriPrimaryKey;
VanOrman，如果我们使用的是SQL 2005，则一定要使SMO成为解决方案的一部分。
回答
亚音速也是另一个选择。我经常使用它来生成映射到数据库的实体类。它具有一个命令行实用程序，可让我们指定表，类型和许多其他有用的东西
回答
试用适用于.net的DaoliteMappingTool。它可以生成类。
在这里下载表格
回答
我们可以在这里对Cclasses执行相反的数据库表：
http://pureobjects.com/dbCode.aspx
