65.9K
CodeProject 正在变化。 阅读更多。
Home

使用 NHibernate ORM 和 CodeDom 进行代码生成， 在任何数据库中自动生成表

Mahsa Hassankashi
starIconstarIconstarIconstarIcon
emptyStarIcon
starIcon

4.98/5 (28投票s)

2019 年 4 月 3 日

CPOL

7分钟阅读

viewsIcon

65798

downloadIcon

39

本文档介绍如何通过输入表名及其字段，在 Oracle、SQLServer、MySQL、SQLite、Sybase 等任何数据库中生成表。然后，您可以使用 NHibernate 的功能来查询数据层。

引言

本文档介绍了如何通过两种技术——代码生成（CodeDOM）和 NHibernate（Fluent）——允许用户通过应用程序自动构建数据库，这使得我们可以独立于数据库类型进行后端开发，而无需涉及复杂的概念。

首先，我想说明为什么我选择了 NHibernate，或者更准确地说，Fluent NHibernate 来完成这项工作。我列举了一些 NHibernate 最普遍的优缺点。

NHibernate

NHibernate 是一个对象关系映射（ORM）框架。NHibernate 位于数据库和业务层之间，并提供强大的映射功能。它继承自 Java 世界的 Hibernate。它除了属性之外，还使用映射文件或特性。

NHibernate 的优点

  1. 强大的映射功能
  2. 一次性执行多个数据库查询，而不是每次查询都单独访问数据库。
  3. NHibernate 支持延迟加载，这意味着您只在需要时将数据加载到内存中，而不是一次性加载整个集合，从而减少内存开销。
  4. 与数据库解耦，这意味着您可以使用各种类型的数据库，而不仅仅是 SQL，例如 Oracle 等。
  5. 使用 NHibernate 编写代码，可以让开发人员在可读性和文档方面感觉更好。
  6. 缓存和二级缓存
  7. 其 SessionFactory 对象在 NHibernate 中是线程安全的。

NHibernate 的缺点

  1. 学习和掌握 NHibernate 需要时间，并且要精通它似乎很麻烦。
  2. NHibernate 需要为每个实体提供复杂的 XML 配置。
  3. 首次启动时需要很长时间，因为元数据准备操作非常繁重。

NHibernate 如何工作？

NHibernate 提供免费的 XML 配置 ORM。它依赖于 SessionFactory 来创建 Session 以绑定数据库。您需要一个类来定义您的特定配置，该配置指定特定数据库的连接字符串。之后，每当您调用 Session 时，您就可以连接到您的数据库。您可以使用 `NHibernate.Linq` 作为命名空间，编写传统的 SQL 查询或 Linq 查询。Session 还封装了工作单元模式。您需要生成 XML 文件来使用 NHibernate，但我使用了 Fluent NHibernate 来避免在实现过程中出现任何繁琐的操作。

CodeDOM

使用 Fluent NHibernate 时，您需要为每个实体（即您的表）编写两个类：一个简单的类和一个映射类，用于引入与其他表的关联。如果您的项目中有大量表，为每个实体编写两个类会有些困难。因此，我决定使用 **代码文档对象模型** ( **CodeDOM** ) 作为生成工具来生成这些类。我从 UI 获取父表的表名、字段名及其数据类型，对于子表，我获取其父表信息以构建外键。

作为对 CodeDOM 最简单的解释：请想象您需要生成许多结构相同的类，但其中某些部分表达式不同。为了节省您的时间和精力，最好只编写一个类而不是许多类，然后该类作为优秀的模板生成您所有的类。

以下命名空间使您能够使用 CodeDOM：

using System.IO;
using System.CodeDom;
using System.CodeDom.Compiler;
using Microsoft.CSharp;

通过使用 CodeDOM，您可以为 ASP.NET、XML Web 服务客户端代理等编写源代码，或者进行编译。它的结构是一个树形图，其根是 `codecompileunit`。然后，您应该定义您的命名空间并导入它们。确定您的类名、字段和属性，并将它们作为成员添加到类中。

CodeDOM 的优点

  1. CodeDOM 允许您在运行时创建、编译和执行应用程序的源代码，而无需编写大量代码，或者在参数需要在运行时确定时非常有用。
  2. CodeDOM 使用单一模型生成源代码，因此支持 CodeDOM 的任何语言都可以与它一起工作。
  3. 可以将 VB 翻译成 C# 或反之亦然。

CodeDOM 的缺点

  1. CodeDOM 在定义任何表达式方面存在限制，您需要使用 `Snippet` 类。
  2. `Snippet` 类不能满足所有表达式，因此您不应该在上面使用复杂的函数。

逐步使用代码

1. 创建数据库

您应该将数据库创建为“`GenerateDB`”，这是连接字符串的基本要求。我使用了 SQL Server 2008，但您可以使用任何数据库，因为 NHibernate 超越了数据库类型。

我为此定义了“`DataType`”表，其中包含两个列：`ID` 和 `Name`，用于实体的 [数据类型]。您可以为“`Name`”字段分配您的数据类型名称，例如 `int`、`string` 等。请注意，CodeDOM 会注意您的应用程序语言的数据类型，例如，我使用的是 C#，所以使用了 `int` 和 `string`，这与 VB 语言略有不同。在 VB 中，我们使用“`integer`”而不是“`int`”。

2. 创建带有 Fluent NHibernate + Microsoft.Build for CodeDOM + AngularJS for Frontend 的 MVC 项目

我为此场景使用了 Microsoft Visual Studio 2013 和 MVC ASP.NET。我采用了 Fluent NHibernate 而不是 NHibernate，因为它的源代码生成通过 CodeDOM 很容易实现。我导入了 `Microsoft.Build` 库来使用 CodeDOM。

最后，我使用了 AngularJS 作为前端和 UI 部分。您可以访问 https://codeproject.org.cn/Articles/869433/AngularJS-MVC-Repository-Dispose 获取有关 angularjs 实现的更多信息，以及有关 MVC ASP.NET 实现的信息，请访问

文件 -> 新建项目 -> ASP.NET MVC 4 项目 -> 选择“Internet 应用程序”

选择“**空**”。

安装 Fluent NHibernate

转到**解决方案** -> 右键单击“**引用**” -> 选择“**管理 NuGet 程序包**”。

搜索“**FluentNHibernate**” -> 单击“**安装**”以添加其引用。

查看解决方案 -> 引用 -> 有三个新的引用

  1. FluentNHibernate
  2. Iesi.Collections
  3. NHibernate

为了使用 CodeDOM，您应该添加“`Microsoft.Build`”和“`Microsoft.Build.Framework`”。

安装 AngularJS

转到**解决方案** -> 右键单击“**引用**” -> 选择“**管理 NuGet 程序包**”。

搜索：“**AngularJS**” -> 单击“**安装**”。

3. 场景回顾与测试

在此场景中，我只为两个字段分配了两个文本框，您可以根据需要创建更多。我将在本文档的更新版本中通过在运行时创建文本框来改进这一部分，因此请收藏本文档以获取最新更新。

我创建了一个 `parent` 表和一个 `child` 表，它们之间存在一对多的关系。下图中的 `parent` 表没有父表，因此最后一个组合框应该为空。

但是，`child` 表通过其调用最后一个组合框中的 `parent` 表来与 `parent` 表建立关系。

查看解决方案，您将在“**Entities**”和“**Mapping**”文件夹中看到由 CodeDOM 生成的新类。对于每个实体，都有两个类：一个在“Entities”文件夹中，例如“Parent.cs”，另一个在“Mapping”文件夹中，例如“ChildMap.cs”。

生成后，也请查看您的数据库。您的数据库类型（SQL、Oracle 等）无关紧要。您的表也已在此处由 FluentNHibernate 生成。

简而言之

您在 UI 上确定表规范，然后 Angular 将信息发送到控制器，控制器通过使用“GenerateTable.cs”和“GenerateMap.cs”以及 `GenerateDBController`/`Generate` 操作，在“Entities”和“Mapping”文件夹中创建您的实体类。这些类（如“Parent.cs”和“ParentMap.cs”）通过 FluentNHibernate 的实用程序“NHibernate.cs”将在数据库中创建表。

4. 使用代码

Fluent NHibernate 配置

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using FluentNHibernate.Cfg;
using FluentNHibernate.Cfg.Db;
using NHibernate;
using NHibernate.Tool.hbm2ddl;
using MVCNHibernate.Entities;     //ProjectName.Entites
using MVCNHibernate.Controllers;  //ProjectName.Controllers

namespace MVCNHibernate
{
    public class NHibernate
    {
        private static ISessionFactory _sessionFactory;
        private static ISessionFactory SessionFactory
        {
            get
            {
                if (_sessionFactory == null)
                    InitializeSessionFactory();
                return _sessionFactory;
            }
        }

        private static void InitializeSessionFactory()
        {
              _sessionFactory = Fluently.Configure()
              .Database(MsSqlConfiguration.MsSql2008
                            .ConnectionString(
                                @"Server=.;initial catalog=GenerateDB;integrated security=True")
                            .ShowSql()
              )
              .Mappings(m =>
                        m.FluentMappings
                            .AddFromAssemblyOf<generatedbcontroller>())
              .ExposeConfiguration(cfg => new SchemaUpdate(cfg)
                                              .Execute(false, true))
              .BuildSessionFactory();
        }

        public static ISession OpenSession()
        {
           return SessionFactory.OpenSession();
        }
    }
}

GenerateTable.cs:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Reflection;
using System.IO;
using System.CodeDom;
using System.CodeDom.Compiler;
using Microsoft.CSharp;
using System.Reflection;
using System.Web.Mvc;
using System.Web;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;

namespace MVCNHibernate
{
    public class GenerateTable
    {
        CodeCompileUnit targetUnit;

        CodeTypeDeclaration targetClass;
               
        public GenerateTable(string tableName)
        {
            targetUnit = new CodeCompileUnit();

            //Path
            CodeNamespace samples = new CodeNamespace("MVCNHibernate.Entities");
            
            //Namespace
            samples.Imports.Add(new CodeNamespaceImport("System"));
            samples.Imports.Add(new CodeNamespaceImport("System.Collections.Generic"));
            samples.Imports.Add(new CodeNamespaceImport("System.Linq"));
            samples.Imports.Add(new CodeNamespaceImport("System.Text"));
            samples.Imports.Add(new CodeNamespaceImport("MVCNHibernate.Entities"));

            targetClass = new CodeTypeDeclaration(tableName);
            targetClass.IsClass = true;
            targetClass.TypeAttributes =
                TypeAttributes.Public;
            samples.Types.Add(targetClass);
            targetUnit.Namespaces.Add(samples);
        }

        public void AddFields(string fld1, string dt1, string fld2, string dt2)
        {
            CodeMemberField field1 = new CodeMemberField();
            field1.Attributes = MemberAttributes.Private;
            if (dt1=="int")
            {
                field1.Type = new CodeTypeReference(typeof(System.Int32));
            }
            else if (dt1 == "string")
            {
                field1.Type = new CodeTypeReference(typeof(System.String));
            }
            
            field1.Name = "_"+fld1;
            targetClass.Members.Add(field1);

            CodeMemberProperty property1 = new CodeMemberProperty();
            property1.GetStatements.Add(new CodeMethodReturnStatement
              (new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_" + fld1)));
            property1.SetStatements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression
              (new CodeThisReferenceExpression(), "_" + fld1), 
               new CodePropertySetValueReferenceExpression()));
            property1.Attributes = MemberAttributes.Public ;
            property1.Name = fld1;
            if (dt1 == "int")
            {
                property1.Type = new CodeTypeReference(typeof(System.Int32));
            }
            else if (dt1 == "string")
            {
                property1.Type = new CodeTypeReference(typeof(System.String));
            }
           
            targetClass.Members.Add(property1);

            CodeMemberField field2 = new CodeMemberField();
            field2.Attributes = MemberAttributes.Private;
            if (dt2 == "int")
            {
                field2.Type = new CodeTypeReference(typeof(System.Int32));
            }
            else if (dt2 == "string")
            {
                field2.Type = new CodeTypeReference(typeof(System.String));
            }
            field2.Name = "_" + fld2;
            targetClass.Members.Add(field2);

            CodeMemberProperty property2 = new CodeMemberProperty();
            property2.GetStatements.Add(new CodeMethodReturnStatement
             (new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_" + fld2)));
            property2.SetStatements.Add(new CodeAssignStatement
             (new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_" + fld2), 
              new CodePropertySetValueReferenceExpression()));
            property2.Attributes = MemberAttributes.Public ;
            property2.Name = fld2;
            if (dt2 == "int")
            {
                property2.Type = new CodeTypeReference(typeof(System.Int32));
            }
            else if (dt2 == "string")
            {
                property2.Type = new CodeTypeReference(typeof(System.String));
            }
           
            targetClass.Members.Add(property2);
        }
        
        public void RelationalAddFields(string tableName,
               string fld1, string dt1, string fld2, string dt2, string parent)
        {
            CodeMemberField field1 = new CodeMemberField();
            field1.Attributes = MemberAttributes.Private;
            if (dt1 == "int")
            {
                field1.Type = new CodeTypeReference(typeof(System.Int32));
            }
            else if (dt1 == "string")
            {
                field1.Type = new CodeTypeReference(typeof(System.String));
            }

            field1.Name = "_" + fld1;
            targetClass.Members.Add(field1);

            CodeMemberProperty property1 = new CodeMemberProperty();
            property1.GetStatements.Add(new CodeMethodReturnStatement
             (new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_" + fld1)));
            property1.SetStatements.Add(new CodeAssignStatement
             (new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_" + fld1), 
              new CodePropertySetValueReferenceExpression()));
            property1.Attributes = MemberAttributes.Public;
            property1.Name = fld1;
            if (dt1 == "int")
            {
                property1.Type = new CodeTypeReference(typeof(System.Int32));
            }
            else if (dt1 == "string")
            {
                property1.Type = new CodeTypeReference(typeof(System.String));
            }

            targetClass.Members.Add(property1);

            CodeMemberField field2 = new CodeMemberField();
            field2.Attributes = MemberAttributes.Private;
            if (dt2 == "int")
            {
                field2.Type = new CodeTypeReference(typeof(System.Int32));
            }
            else if (dt2 == "string")
            {
                field2.Type = new CodeTypeReference(typeof(System.String));
            }
            field2.Name = "_" + fld2;
            targetClass.Members.Add(field2);

            CodeMemberProperty property2 = new CodeMemberProperty();
            property2.GetStatements.Add(new CodeMethodReturnStatement
             (new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_" + fld2)));
            property2.SetStatements.Add(new CodeAssignStatement
             (new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_" + fld2), 
              new CodePropertySetValueReferenceExpression()));
            property2.Attributes = MemberAttributes.Public;
            property2.Name = fld2;
            if (dt2 == "int")
            {
                property2.Type = new CodeTypeReference(typeof(System.Int32));
            }
            else if (dt2 == "string")
            {
                property2.Type = new CodeTypeReference(typeof(System.String));
            }

            targetClass.Members.Add(property2);

            CodeMemberField field3 = new CodeMemberField();
            field3.Attributes = MemberAttributes.Private;
            
            // field3.Type = new CodeTypeReference(typeof(System.Int32));
            Type myType = Type.GetType("MVCNHibernate.Entities."+parent);
            //dynamic instance = Activator.CreateInstance(myType);

            field3.Type = new CodeTypeReference(myType);

            field3.Name = "_" + parent+tableName;
            targetClass.Members.Add(field3);

            CodeMemberProperty property3 = new CodeMemberProperty();
            property3.GetStatements.Add(new CodeMethodReturnStatement
                (new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), 
                 "_" + parent + tableName)));
            property3.SetStatements.Add(new CodeAssignStatement
                 (new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_" + 
                  parent + tableName), new CodePropertySetValueReferenceExpression()));
            property3.Attributes = MemberAttributes.Public;
            property3.Name = parent + tableName;
            Type myType2 = Type.GetType("MVCNHibernate.Entities." + parent);
           // dynamic instance2 = Activator.CreateInstance(myType2);
            property3.Type = new CodeTypeReference(myType2);

            targetClass.Members.Add(property3);
        }
   
        CodeDomProvider provider;
        public void GenerateCSharpCode(string fileName)
        {
             
             provider = CodeDomProvider.CreateProvider("CSharp");
            CodeGeneratorOptions options = new CodeGeneratorOptions();
            options.BracingStyle = "C";

            using (StreamWriter sourceWriter = new StreamWriter(fileName))
            {
                provider.GenerateCodeFromCompileUnit(
                    targetUnit, sourceWriter, options);
            }
        }
    }
}

GenerateMap.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Reflection;
using System.IO;
using System.CodeDom;
using System.CodeDom.Compiler;
using Microsoft.CSharp;
using System.Linq.Expressions;

namespace MVCNHibernate
{
    public class GenerateMap
    {
        CodeCompileUnit targetUnit;

        CodeTypeDeclaration targetClass;

        public GenerateMap(string tableName)
        {
            targetUnit = new CodeCompileUnit();
           
            //Path
            CodeNamespace samples = new CodeNamespace("MVCNHibernate.Mapping");
           
            //Namespace
            samples.Imports.Add(new CodeNamespaceImport("System"));
            samples.Imports.Add(new CodeNamespaceImport("System.Collections.Generic"));
            samples.Imports.Add(new CodeNamespaceImport("System.Linq"));
            samples.Imports.Add(new CodeNamespaceImport("System.Web"));
            samples.Imports.Add(new CodeNamespaceImport("FluentNHibernate.Mapping"));
            samples.Imports.Add(new CodeNamespaceImport("MVCNHibernate.Entities"));

            targetClass = new CodeTypeDeclaration(tableName+"Map");
            targetClass.BaseTypes.Add(new CodeTypeReference 
                      { BaseType = "ClassMap`1[" + tableName + "]", 
                      Options = CodeTypeReferenceOptions.GenericTypeParameter });
            targetClass.IsClass = true;
            targetClass.TypeAttributes =
                TypeAttributes.Public ;
            samples.Types.Add(targetClass);
            targetUnit.Namespaces.Add(samples);
        }

        public void AddConstructor(string fld1, string fld2, string tbl)
        {
            // Declare the constructor
            CodeConstructor constructor = new CodeConstructor();
            constructor.Attributes =
                MemberAttributes.Public | MemberAttributes.Final;

            CodeExpression newType = new CodeExpression();
            CodeSnippetExpression snippet = new CodeSnippetExpression();

            string hh = string.Format("Table(\"{0}\"", tbl);
            string lambda = @"Id(x => x." + fld1 + "); Map(x => x." + fld2 + ");" + hh+")";

            var lambdaExpression = new CodeSnippetExpression(lambda);
           
            constructor.Statements.Add(lambdaExpression);

            targetClass.Members.Add(constructor);
        }


        public void RelationalAddConstructor(string fld1, string fld2, string tbl, string parent)
        {
            CodeConstructor constructor = new CodeConstructor();
            constructor.Attributes =
                MemberAttributes.Public | MemberAttributes.Final;

            CodeExpression newType = new CodeExpression();
            CodeSnippetExpression snippet = new CodeSnippetExpression();

            string parenttbl = parent + tbl;
            string fk=parent+"id";
            string cc= string.Format("\"{0}\"", fk);
            string hh = string.Format("Table(\"{0}\"", tbl);
            string lambda = @"Id(x => x." + fld1 + "); Map(x => x." + fld2 + "); 
                   References(x => x." + parenttbl + ").Column(" + cc + "); " + hh + ")";

            var lambdaExpression = new CodeSnippetExpression(lambda);
            
            constructor.Statements.Add(lambdaExpression);

            targetClass.Members.Add(constructor);
        }

        public void GenerateCSharpCode(string fileName)
        {
            CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp");
            CodeGeneratorOptions options = new CodeGeneratorOptions();
            options.BracingStyle = "C";

            using (StreamWriter sourceWriter = new StreamWriter(fileName))
            {
                provider.GenerateCodeFromCompileUnit(
                    targetUnit, sourceWriter, options);
            }
        }
    }
}

GenerateDBController.cs:

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using MVCNHibernate.Entities;
using Microsoft.Build;
using Microsoft.Build.Construction;
using Microsoft.Build.Evaluation;
using Microsoft.Build.Execution;
using NHibernate.Linq;
using NHibernate;
using System.Collections;

namespace MVCNHibernate.Controllers
{
    public class GenerateDBController : Controller
    {
    
        public ActionResult Index()
        {
            return View();
        }

        public JsonResult getDataType()
        {
            using (var session = NHibernate.OpenSession())
            {
                using (var transaction = session.BeginTransaction())
                {
                    var query = session.CreateSQLQuery("select Name from DataType");
                    var result = query.List();
                    return Json(result, JsonRequestBehavior.AllowGet);
                }
            }
        }

        public JsonResult getTable()
        {
            using (var session = NHibernate.OpenSession())
            {
                using (var transaction = session.BeginTransaction())
                {
                    var sql = String.Format("SELECT * FROM information_schema.tables");
                    var query = session.CreateSQLQuery(sql);
                    var result = query.List();
                   
                    List<string> tableName = new List<string>();
                    object tableSpec;

                    IList collection;
                    for (int i = 0; i < result.Count; i++)
                    {
                        tableSpec = result[i];
                        collection = (IList)tableSpec;
                        tableName.Add(collection[2].ToString());
                       
                    }
                  
                    return Json(tableName, JsonRequestBehavior.AllowGet);
                }
            }
        }

        public string Generator(string tableName, string fieldName1, 
               string dataType1, string fieldName2, string dataType2, string Parent)
        {
            try
            {

            if (Parent==null) //=> No Relation
            {
                var projectCollection = ProjectCollection.GlobalProjectCollection;
                string projPath = "~/MVCNHibernate.csproj";

                var p = projectCollection.LoadProject(Server.MapPath(projPath));


                string projItem1 = "~/Entities/" + tableName + ".cs";
                GenerateTable genTable = new GenerateTable(tableName);
                genTable.AddFields( fieldName1,  dataType1,  fieldName2,  dataType2);
                genTable.GenerateCSharpCode(Server.MapPath(projItem1));

                p.AddItem("Compile", Server.MapPath(projItem1));
                p.Save();

                string projItem2 = "~/Mapping/" + tableName + "Map.cs";
                GenerateMap genMap = new GenerateMap(tableName);
                genMap.AddConstructor(fieldName1,fieldName2,tableName);
                genMap.GenerateCSharpCode(Server.MapPath(projItem2));

                p.AddItem("Compile", Server.MapPath(projItem2));
                p.Save();
                ProjectCollection.GlobalProjectCollection.UnloadProject(p);

                p.Build();
               
                NHibernate.OpenSession();
                              
            }
            else if (Parent != null)//=> Relation To Parent
            {
                var projectCollection = ProjectCollection.GlobalProjectCollection;
                string projPath = "~/MVCNHibernate.csproj";

                var p = projectCollection.LoadProject(Server.MapPath(projPath));


                string fileNameEn = "~/Entities/" + tableName + ".cs";
                GenerateTable genTable = new GenerateTable(tableName);
                genTable.RelationalAddFields(tableName, fieldName1, 
                                             dataType1, fieldName2, dataType2, Parent);
                genTable.GenerateCSharpCode(Server.MapPath(fileNameEn));

                string projItem1 = "~/Entities/" + tableName + ".cs";
                p.AddItem("Compile", Server.MapPath(projItem1));
                p.Save();

                string fileNameMap = "~/Mapping/" + tableName + "Map.cs";
                GenerateMap genMap = new GenerateMap(tableName);
                genMap.RelationalAddConstructor(fieldName1, fieldName2, tableName, Parent);
                genMap.GenerateCSharpCode(Server.MapPath(fileNameMap));

                string projItem2 = "~/Mapping/" + tableName + "Map.cs";
                p.AddItem("Compile", Server.MapPath(projItem2));
                p.Save();
                //ProjectCollection.GlobalProjectCollection.UnloadProject(p);
                ProjectCollection.GlobalProjectCollection.UnloadAllProjects();
                p.Build();
               
                NHibernate.OpenSession();              
            }
            return "Database generated Successfully ";              
            }
            catch
            {                
                return "Database did not generate Successfully ";
            }                      
        }
    }
}

Entities -> DataType.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace MVCNHibernate.Entities
{
    public class DataType
    {
        public virtual int ID { get; set; }
        public virtual string Name { get; set; }
    }
}

Mapping -> DataTypeMap.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using FluentNHibernate.Mapping;
using MVCNHibernate.Entities;

namespace MVCNHibernate.Mapping
{
    public class DataTypeMap : ClassMap<datatype>
    {
        public DataTypeMap()
        {
            Id(x => x.ID);

            Map(x => x.Name);
           
            Table("DataType");
        }
    }
}

Content -> Angular -> Module.js

var app = angular.module('MyApp', ['ngRoute']);

Content -> Angular -> Controller.js

app.controller("AngularCtrlCreateTable", function ($scope, angularServiceCreateTable) {
    $scope.divGen = true;
    $scope.divNewGen = false;
    GetAllDataType1();
    GetAllTable();

    //To Get All Records  
    function GetAllDataType1() {
        var Data = angularServiceCreateTable.getDataType();
        Data.then(function (data) {
            $scope.items1 = data.data;
            $scope.items2 = data.data;
        }, function () {
            alert('Error');
        });
    }
     
    //To Get All Records  
    function GetAllTable() {
        var Data = angularServiceCreateTable.getTable();
        Data.then(function (tb) {
            $scope.itemsPT = tb.data;
        }, function () {
            alert('Error');
        });
    }

    $scope.Generator = function () {
        var dt1 = $scope.selectedItem1;
        var dt2 = $scope.selectedItem2;
        var dt3 = $scope.selectedItemParentTable;
        var getmsg = angularServiceCreateTable.Generator
                     ($scope.TableName, $scope.Field1, dt1, $scope.Field2, dt2, dt3);
        getmsg.then(function (messagefromcontroller) {
            $scope.divGen =false;
            $scope.divNewGen = true;
           alert(messagefromcontroller.data);
        }, function () {
            alert('There is error in database generation');
        });
    }

    $scope.GeneratorNew = function () {
            $scope.divGen = true;
            $scope.divNewGen = false;
            GetAllTable();
            GetAllDataType2();
            GetAllDataType1();
            $scope.TableName = "";
            $scope.Field1 = "";
            $scope.Field2 = "";
    }
});

Content -> Angular -> Service.js

app.service("angularServiceCreateTable", function ($http) {
    this.getDataType = function () {
        return $http.get("/GenerateDB/getDataType");
    };

    this.getTable = function () {
        return $http.get("/GenerateDB/getTable");
    };
   
    //Database Generation 
    this.Generator = function (tblName, fldName1, dType1, fldName2, dType2, prtTableName) {
        var response = $http({
            method: "post",
            url: "/GenerateDB/Generator",
            params: {
                tableName: tblName,
                fieldName1: fldName1,
                dataType1: dType1,
                fieldName2: fldName2,
                dataType2: dType2,
                Parent: prtTableName
            }
        });
        return response;
    }
});

Views -> GenerateDB -> Index.cshtml

@{
    ViewBag.Title = "Index";
}
<h2>Index</h2>
<div ng-controller="AngularCtrlCreateTable">
    <br />
    <table>
            <tr>
                  <td>
                     Table Name:
                     <input type="text" style="width:94px;" ng-model="TableName" />
                 </td>
             </tr>

             <tr>
                 <td>
                     Field1(PK):<input type="text" style="width:94px;" ng-model="Field1" />
                     Data Type:<select data-ng-model="selectedItem1" 
                          ng-options="item1 for item1 in items1"></select>
                 </td>
             </tr>

             <tr>
                 <td>
                     Field2: <input type="text" style="width:94px;" ng-model="Field2" />
                     Data Type: <select data-ng-model="selectedItem2" 
                                 ng-options="item2 for item2 in items2"></select>

                 </td>
             </tr>

             <tr>
                 <td>
                    Relationship to Parent Table(FK): <select data-ng-model="selectedItemParentTable" 
                               ng-options="itemPT for itemPT in itemsPT"></select>
                 </td>
             </tr>

             <tr>
                 <td colspan="2">
                     <div ng-show="divGen">
                         <input type="button" value="Generate Table" ng-click="Generator()" />
                     </div>
                </td>

                 <td colspan="2">
                     <div ng-show="divNewGen">
                         <input type="button" value="Generate New Table" ng-click="GeneratorNew()" />

                      </div>
                </td>
             </tr>

        </table>
</div>

参考文献

历史

  • 初版：2015年3月28日

反馈

请随时对本文提供任何反馈；很高兴看到您的评论和投票。如果您有任何问题，请随时在此处提问。

© . All rights reserved.