通过NHibernate ORM和CodeDom在任何数据库中自动生成表以生成代码

最新推荐文章于 2019-08-14 08:09:38 发布

寒冰屋

最新推荐文章于 2019-08-14 08:09:38 发布

阅读量656

点赞数

分类专栏：架构及框架 CSharp.NET MVC 文章标签： NHibernate CodeDom

CSharp.NET 同时被 3 个专栏收录

1233 篇文章 58 订阅

订阅专栏

架构及框架

633 篇文章 16 订阅

订阅专栏

MVC

73 篇文章 3 订阅

订阅专栏

2.使用Fluent NHibernate + Microsoft.Build for CodeDOM + AngularJS for Frontend创建MVC项目

3.审核场景和测试

4.使用代码

下载源代码：NHibernate和CodeDOM生成数据库

介绍

本文描述了如何允许用户通过两种技术代码生成（CodeDOM）和NHibernate（Fluent）自动从应用程序构建数据库，这使我们可以制作后端，无论数据库的类型如何，也不涉及复杂的概念。

首先，我想提一下为什么我选择了NHibernate或用更好的词语，Fluent NHibernate来做这件事。我已经计算了NHibernate最受欢迎的一些优点和缺点。

NHibernate

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

NHibernate的优点：

强大的映射能力。
进入一次数据库并执行多个查询，而不是为每个查询都进入一次DB(数据库)。
延迟加载(Lazy Loading)适用于NHibernate，它意味着你只需要在内存中获取必要的数据而不是内存中的整个集合，这样可以减少内存的开销。
与数据库解耦，这意味着您可以使用各种数据库类型而不是仅使用如Oracle等的SQL。
为NHibernate编写代码使开发人员在可读性和文档方面感觉更好。
缓存和二级缓存。
它的会话工厂是NHibernate中的线程安全对象。

NHibernate缺点：

在NHibernate中学习和掌握需要时间，而且专业化似乎很麻烦。
对于每个实体，NHibernate需要复杂的XML配置。
由于元数据中的准备操作很重，因此首次启动它需要很长时间。

NHibernate如何运作？

NHibernate提供ORM作为免费的XML配置。它取决于为绑定数据库而创建会话的会话工厂。您需要一个类来定义特定配置，该类引入特定数据库的连接字符串。之后，每当您调用会话时，您都可以连接到您的数据库。您可以使用NHibernate.Linq作为命名空间，将代码编写为传统的sql查询或Linq查询。完全会话也封装了工作模式单元。您需要生成XML文件才能与NHibenate一起使用，但我使用了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很容易生成源代码。我为CodeDOM导入了Microsoft.Build库。

最后，我在前端和UI部分使用了AngularJS，您可以在http://www.codeproject.com/Articles/869433/AngularJS-MVC-Repository-Dispose获取有关angularjs实现的更多信息，以及有关MVC ASP.NET实现的更多信息。

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

选择“Empty”

安装Fluent NHibernate：

转到解决方案 - >右键单击“引用” - >选择“管理Nuget包”

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

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

FluentNHibernate
Iesi.Collections
NHibernate

要使用CodeDOM，您应该添加“Microsoft.Build”和“Microsoft.Build.Framework”

安装AngularJS：

转到解决方案 - >右键单击“引用” - >选择“管理Nuget包”

搜索：“AngularJS” - >点击“安装”

3.审核场景和测试

在这个场景中，我为两个字段分配了两个文本框，您可以根据需要创建多个文本框。

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

但是child表在最后一个组合框中通过其调用 parent表与 parent有关系。

查看解决方案，您将看到CodeDOM在“实体”和“映射”中生成了新类。对于每个权限，有两个类，一个在“Entities”文件夹中，如“Parent.cs”，另一个在“Mapping”文件夹中，作为“ChildMap.cs”。

在生成之后，还要查看数据库。你的数据库SQL，Oacle等没有区别。你的表也是由FluentNHibernate在这里生成的。

简而言之：

您可以在UI上确定表的规格，然后Angular将信息发送给控制器，然后使用 “GenerateTable.cs”和“GenerateMap.cs”以及GenerateDBController/Generate操作，您的实体类将在“实体”和“映射”文件夹中创建。FluentNHibernate实用程序“NHibernate.cs” 将在数据库中创建表，如“Parent.cs”和“ParentMap.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>

原文地址：https://www.codeproject.com/Articles/891056/Automatic-Table-Generation-in-any-database-by-NHib

寒冰屋

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
通过NHibernate ORM和CodeDom在任何数据库中自动生成表以生成代码

目录介绍NHibernateNHibernate的优点：NHibernate缺点：NHibernate如何运作？CodeDOMCodeDOM的优点：CodeDOM缺点：逐步使用代码1.创建数据库2.使用Fluent NHibernate + Microsoft.Build for CodeDOM + AngularJS for Frontend创建MV...
复制链接

扫一扫

专栏目录