C#高级进阶教程_000_值类型和引用类型

字数统计: 4.2k字   |   阅读时长≈ 18分

对象/关系数据库的映射。（object/relational mapping，ORM） ——类和表的映射（操作数据库就像操作对象一样）

1、基本介绍

NHibernate是一个面向.NET环境的对象/关系数据库映射工具。

对象/关系数据库映射（object / relational mapping，ORM）这个术语表示一种技术，用来把对象模型表示的对象映射到基于SQL的关系模型数据结构中去。

NHibernate不仅仅管理.NET类到数据库表的映射（包括.NET 数据类型到SQL数据类型的映射），还提供数据查询和获取数据的方法，可以大幅度减少开发时人工使用SQL和ADO.NET处理数据的时间。

NHibernate的目标主要是用于与数据持久化相关的编程任务，能够使开发人员从原来枯燥的SQL语句的编写中解放出来，解放出来的精力可以让开发人员投入到业务逻辑的实现上。对于以数据为中心的程序，开发人员往往是在数据库中使用存储过程来实现商业逻辑，这种情况下NHibernate可能不是最好的解决方案，但对于那些基于.NET，并且能够实现OO业务模型和商业逻辑的中间层应用，NHibernate是最有用的。NHibernate可以帮助用户消除或者包装那些针对特定厂商的SQL代码，并且帮用户把结果集从表格式的表示形式转换成一系列的对象。

Hibernate是一个目前应用的最广泛的开放源代码的对象关系映射框架，它对Java的JDBC（类似于ADO.Net）进行了非常轻量级的对象封装，使得程序员可以随心所欲的使用对象编程思维来操纵数据库。

NHibernate 是一个基于.Net 的针对关系型数据库的对象持久化类库。

NHibernate 从数据库底层来持久化你的.Net 对象到关系型数据库。NHibernate 为你处理这些，远胜于你不得不写SQL去从数据库存取对象。你的代码仅仅和对象关联，NHibernat 自动产生SQL语句，并确保对象提交到正确的表和字段中去。

2、NHibernate中的基本概念

NHibernate体系结构如图1所示。

它体现了NHibernate如何使用数据库和配置文件数据来为应用程序提供持久化服务（和持久化的对象）。

SessionFactory(NHibernate.IsessionFactory)：

它是Session的工厂，是ConnectionProvider的客户。可以持有一个可选的（第二级）数据缓存，可以在进程级别或集群级别保存的可以在事物中重用的数据。

会话(NHibernate.ISession):单线程，生命期较短的对象，代表应用程序和持久化层之间的一次对话。封装了一个ADO.NET连接，也是Transaction的工厂。保存有必需的（第一级）持久化对象的缓存，用于遍历对象图，或者通过标识符查找对象。

持久化对象(Persistent)及其集合(Collections):

生命期较短的单线程的对象，包含了持久化状态和商业功能。这些可能是普通的对象，唯一特别的是现在从属于且仅从属于一个Session。一旦Session被关闭，它们都将从Session中取消联系，可以在任何程序层自由使用（比如，直接作为传送到表现层的DTO,数据传输对象）。

临时对象(Transient Object)及其集合(Collection):

目前没有从属于一个Session的持久化类的实例。这些可能是刚刚被程序实例化，还没有来得及被持久化，或者是被一个已经关闭的Session实例化。

事务Transaction (NHibernate.ITransaction)：

（可选）单线程，生命期较短的对象，应用程序用其来表示一批工作的原子操作，它是底层的ADO.NET事务的抽象。一个Session在某些情况下可能跨越多个Transaction事务。

ConnectionProvider（NHibernate.Connection.ConnectionProvider）：

（可选）ADO.NET连接的工厂。从底层的IDbConnection抽象而来。对应用程序不可见，但可以被开发者扩展/实现。

TransactionFactory（net.sf.hibernate.TransactionFactory）：

（可选）事务实例的工厂。对应用程序不可见，但可以被开发者扩展/实现。

3、持久化类案例

持久化类是应用程序用来解决商业问题的类（比如，在电子交易程序中的Customer和Order）。

持久化类是暂时存在的，实例会被持久性保存于数据库中。

如果这些类符合简单的规则，NHibernate能够工作得最好，这些规则就是Plain Old CLR Object（POCO，简单传统CLR对象）编程模型。

POCO简单示例（用一个类描述一只猫）如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
public class Cat
{
    private long _id; // 标识符
    private string _name; // 名字
    private DateTime _birthdate; // 出生日期
    private Cat _mate; // 猫的配对
    private Set _kittens; // 猫仔
    private Color _color; // 颜色
    private char _sex; // 性别
    private float _weight; // 体重
    public long Id // 标识符属性
      {
        get {return _id; }
        set { _id = value; }
      }
      public string Name // 名字属性
      {
        get { return _name; }
        set { _name = value; }
      }
      public DateTime Birthdate // 出生日期属性
      {
        get { return _birthdate; }
        set { _birthdate = value; }
      }
      public Cat Mate // 猫的配对属性
      {
        get { return _mate; }
        set { _mate = value; }
      }
      public Set Kittens // 猫仔属性
      {
        get { return _kittens; }
        set { _kittens = value; }
      }
      public Color Color // 颜色属性
      {
        get { return _color; }
        set { _color = value; }
      }
      public char Sex // 性别属性
      {
        get { return _sex; }
        set { _sex = value; }
      }
      public float Weight // 体重属性
      {
        get { return _weight; }
        set { _weight = value; }
      }
}

4、规则

为持久化字段声明访问器（getters和setters）。

Cat为它的所有可持久化字段声明了getters和setters访问器。用访问器来替代直接访问字段是个好习惯。也可以通过字段（field）来使用NHibernate。属性不一定需要声明为public的。NHibernate可以对default、protected、internal或private的属性执行持久化.

实现一个默认的构造方法（constructor）：Cat有一个显式的无参数默认构造方法。所有的持久化类都必须具有一个默认的构造方法（可以不是public的），这样NHibernate就可以使用Constructor.Invoke()来实例化它们.

提供一个标识属性（identifier property）（可选）.

建议使用不是sealed的类（可选）.

5、映射

** 对象和关系数据库之间的映射是用一个XML文档（XML document）来定义的**。这个映射文档被设计为易读的，并且可以手工修改。

映射语言是以.NET为中心的，意味着映射是按照持久化类的定义来创建的，而非表的定义。

在Hibernate中XML映射文档可以手动定义，也有一些工具来辅助生成，包括Xdoclet、Middlegen和AndroMDA，但是在NHibernate文档中并没有上述的辅助工具，不过可以采MyGeneration这样的代码生成工具来生成XML配置文档。

虽然NHibernate目前不是非常的成熟，还没有达到实用化的水平，它经常在负荷有些大的时候崩溃，但是它脱胎于在Java社区有着巨大影响力的Hibernate，而且NHibernate在实际应用方面确实体现出了它的优势，基于上述原因NHibernate一定会被越来越多的开发人员所接受，而且一定会被标准化。

6、代码案例

01、配置NHibernate，运行在根目录上（始终复制）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<?xml version="1.0" encoding="utf-8"?>
<!--
This template was written to work with NHibernate.Test.
Copy the template to your NHibernate.Test project folder and rename it in hibernate.cfg.xml and change it
for your own use before compile tests in VisualStudio.
-->
<!-- This is the System.Data.dll provider for SQL Server -->
<hibernate-configuration  xmlns="urn:nhibernate-configuration-2.2" >
    <session-factory>
        <property name="connection.driver_class">NHibernate.Driver.MySqlDataDriver</property><!--使用什么数据库-->
        <property name="connection.connection_string">
            <!--Server=(local);initial catalog=nhibernate;Integrated Security=SSPI-->
            Server=localhost;Database=mygamedb;User Id=root;Password=liang521;
        </property>
        <property name="dialect">NHibernate.Dialect.MySQL5Dialect</property><!--使用数据库的版本-->
    </session-factory>
</hibernate-configuration>

02、Common下的NHibernate的辅助类：NHibernateHelper

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
namespace LJK_NHibernateLinkMySQLDemo_20210202.Common
{
    public static class NHibernateHelper
    {
        private static ISessionFactory _sessionFactory;
        private static ISessionFactory SessionFactory
        {
            get
            {
                if(_sessionFactory == null)
                {
                    var configuration = new Configuration();//创建配置对象
                    configuration.Configure();//解析数据库连接配置（在默认路径中解析）
                    configuration.AddAssembly("LJK_NHibernateLinkMySQLDemo_20210202");
                    _sessionFactory = configuration.BuildSessionFactory();
                }
                return _sessionFactory;
            }
        }
        public static ISession OpenSession()
        {
            return SessionFactory.OpenSession();//通过sessionFactory得到一个session。
        }
    }
}

03、Mappings下的Xml映射文件（实体类与表的映射）（嵌入资源）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
<?xml version="1.0" encoding="utf-8" ?>
<!--assembly:程序集，namespace:命名空间-->
<hibernate-mapping  xmlns="urn:nhibernate-mapping-2.2" 
                    assembly="LJK_NHibernateLinkMySQLDemo_20210202"        
                    namespace="LJK_NHibernateLinkMySQLDemo_20210202.Model">
   
    <!--基础配置-->
    <class name="User" table="users">
        
        <!--配置主键-->
        <id name="Id" type="Int32" unsaved-value="null">
            <!--指定表里面的列名和类型-->
            <column name="Id" sql-type="int" not-null="true" unique="true"/>
            <generator class="assigned"> </generator>  <!--自增长 "也有配置assigned" -->
            <!--native、assigned、uuid的区别？-->
            <!--
            第一种：
            native为id自动生成策略，生成的是数字id，添加数据到MySQL数据库时不需要设置id的值,hibernate框架会帮你生成，但是会给框架执行时间造成压力。
            第二种：
            assigned（手动委派）主键策略需要在添加数据时自己设置id，因为它不能自动生成id，不麻烦别人，自己动手。
            第三种：
            uuid.hex程序会自动生成16进制uuid主键，添加数据到MySQL数据库时不需要设置id的值，如果将id设置为这种策略，那么实体类id属性必须要定义成字符串string类型，不然会报错。
            -->
        </id>
        
        <!--其他列-->
        <property name="Username" type="String">
            <column name="Username" sql-type="varchar"  not-null="false"/>
        </property>
        <property name="Password" type="String">
            <column name="Password" sql-type="varchar"  not-null="false"/>
        </property>
        <property name="RegisterDate" type="DateTime">
            <column name="RegisterDate" sql-type="date"  not-null="false"/>
        </property>
    </class>
</hibernate-mapping>

Model文件下User实体类

1
2
3
4
5
6
7
8
9
10
11
using System;
namespace LJK_NHibernateLinkMySQLDemo_20210202.Model
{
    public class User
    {
        public virtual  int Id { get; set; }
        public virtual string Username { get; set; }
        public virtual string Password { get; set; }
        public virtual DateTime RegisterDate { get; set; }
    }
}

Manager文件下的IUserManger接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
using System.Collections;
using System.Collections.Generic;
using LJK_NHibernateLinkMySQLDemo_20210202.Model;
namespace LJK_NHibernateLinkMySQLDemo_20210202.Manager
{
    //定义接口的好处？可以以后更换中间件
    public interface IUserManager
    {
        void Add(User user);
        void Update(User user);
        void Remove(User user);
        User GetById(int id);
        User GetByUserName(string username);
        ICollection<User> GetAllUsers();
        bool VerifyUser(string username, string password);
    }
}

Manager文件下NHibernate连接数据库（对于不同的实体，可以一对一地写一个Repository，专注负责相对应的实体操作。）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
using System.Collections.Generic;
using LJK_NHibernateLinkMySQLDemo_20210202.Common;
using LJK_NHibernateLinkMySQLDemo_20210202.Model;
using NHibernate;
using NHibernate.Criterion;

namespace LJK_NHibernateLinkMySQLDemo_20210202.Manager
{
    public class UserManager : IUserManager
    {
        private static UserManager _instance;
        public static UserManager Instance => _instance ?? (_instance = new UserManager());

        public void Add(User user)
        {
            // ISession session = NHibernateHelper.OpenSession();
            // session.Save(user);
            // session.Close();
            using (ISession session = NHibernateHelper.OpenSession())
            {
                using (ITransaction transaction = session.BeginTransaction()) //需要释放，最好使用using，
                    //只有大括号里面执行完了，transaction才会释放
                {
                    session.Save(user);
                    transaction.Commit();
                }
            }
        }

        //更新
        public void Update(User user)
        {
            using (ISession session = NHibernateHelper.OpenSession())
            {
                using (ITransaction transaction = session.BeginTransaction()) //需要释放，最好使用using，
                    //只有大括号里面执行完了，transaction才会释放
                {
                    session.Update(user);
                    transaction.Commit();
                }
            }
        }

        public void Remove(User user)
        {
            using (ISession session = NHibernateHelper.OpenSession())
            {
                using (ITransaction transaction = session.BeginTransaction()) //需要释放，最好使用using，
                    //只有大括号里面执行完了，transaction才会释放
                {
                    session.Delete(user);
                    transaction.Commit();
                }
            }
        }

        public User GetById(int id)
        {
            using (ISession session = NHibernateHelper.OpenSession())
            {
                User user = session.Get<User>(id);
                return user;
            }
        }

        //使用CreateCriteria查询
        public User GetByUserName(string username)
        {
            using (ISession session = NHibernateHelper.OpenSession())
            {
                // ICriteria criteria = session.CreateCriteria(typeof(User));//criteria标准
                // criteria.Add(Restrictions.Eq("Username", username));//Restrictions限制条件，查询条件封装成了对象
                // return criteria.UniqueResult<User>();//Unique独一无二

                ICriteria criteria = session.CreateCriteria(typeof(User)).Add(Restrictions.Eq("Username", username));//Username属性名
                User user = criteria.UniqueResult<User>();
                return user;
            }
        }

        public ICollection<User> GetAllUsers()
        {
            using (ISession session = NHibernateHelper.OpenSession())
            {
                IList<User> users = session.CreateCriteria(typeof(User)).List<User>();
                return users;
            }
        }

        public bool VerifyUser(string username, string password)
        {
            using (ISession session = NHibernateHelper.OpenSession())
            {
                // 方式一：
                ICriteria criteria = session.CreateCriteria(typeof(User)).Add(Restrictions.Eq("Username", username));//Username属性名
                User user = criteria.UniqueResult<User>();
                return user.Password.Equals(password);
                
                //方式二：
                // User user = session
                //     .CreateCriteria(typeof(User))
                //     .Add(Restrictions.Eq("Username", username))
                //     .Add(Restrictions.Eq("Password", password))
                //     .UniqueResult<User>();
                // if (user==null)
                // {
                //     return false;
                // }
                // return true;
            }
        }
    }
}

应用场景案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
using System;
using System.Collections.Generic;
using System.Linq;
using LJK_NHibernateLinkMySQLDemo_20210202.Manager;
using LJK_NHibernateLinkMySQLDemo_20210202.Model;
using NHibernate;
using NHibernate.Cfg;

namespace LJK_NHibernateLinkMySQLDemo_20210202
{
    internal class Program
    {
        public static void Main(string[] args)
        {
            //         Configuration configuration = new Configuration();
            //         configuration.Configure(); //解析nHibernate.cfg.xml数据库的连接文件,默认路径默认名字解析
            //         configuration.AddAssembly("LJK_NHibernateLinkMySQLDemo_20210202"); //解析映射文件User.hbm.xml...
            //         ISessionFactory sessionFactory = null;
            //         ISession session = null;
            //         ITransaction transaction = null;
            //         try
            //         {
            //             sessionFactory = configuration.BuildSessionFactory(); //创建session工厂，用于与数据库的连接
            //             if (sessionFactory != null)
            //             {
            //                 session = sessionFactory.OpenSession(); //打开一个与数据库的会话（连接）
            //                 User user = new User()
            //                 {
            //                     Username = "KOKO",
            //                     Password = "5566",
            //                     RegisterDate = DateTime.Now
            //                 };
            //                 //插入
            //                 //session.Save(user);
            //                 
            //                 //删除
            //                 //session.Delete(user);
            //                 
            //                 //查询
            //                 // IQueryable<User> users = session.Query<User>();
            //                 // foreach (var u in users)
            //                 // {
            //                 //     Console.WriteLine(u.Id);
            //                 // }
            //
            //                 //事务
            //                 //MySQL 事务主要用于处理操作量大，复杂度高的数据。
            //                 //比如说，在人员管理系统中，你删除一个人员，你既需要删除人员的基本资料，也要删除和该人员相关的信息，如信箱，文章等等，
            //                 //这样，这些数据库操作语句就构成一个事务！
            //                 
            //                 /*一般来说，事务是必须满足4个条件（ACID）：原子性（Atomicity，或称不可分割性）、一致性（Consistency）、隔离性（Isolation，又称独立性）、持久性（Durability）。
            //                 原子性：一个事务（transaction）中的所有操作，要么全部完成，要么全部不完成，不会结束在中间某个环节。
            //                      事务在执行过程中发生错误，会被回滚（Rollback）到事务开始前的状态，就像这个事务从来没有执行过一样。
            //                 一致性：在事务开始之前和事务结束以后，数据库的完整性没有被破坏。
            //                      这表示写入的资料必须完全符合所有的预设规则，这包含资料的精确度、串联性以及后续数据库可以自发性地完成预定的工作。
            //                 隔离性：数据库允许多个并发事务同时对其数据进行读写和修改的能力，隔离性可以防止多个事务并发执行时由于交叉执行而导致数据的不一致。
            //                       事务隔离分为不同级别，包括读未提交（Read uncommitted）、读提交（read committed）、可重复读（repeatable read）和串行化（Serializable）。
            //                 持久性：事务处理结束后，对数据的修改就是永久的，即便系统故障也不会丢失。*/
            //                 
            //                 /*a少50，b多50*/    //数据的完整性和统一性,事务回滚
            //                 
            //                 //创建事务
            //                 
            //                 //方法一：直接创建
            //                 {
            //                     transaction = session.BeginTransaction();
            //                     //进行操作
            //                     User user01 = new User()
            //                     {
            //                         Username = "dk01",
            //                         Password = "123",
            //                         RegisterDate = DateTime.Now
            //                     };
            //                     User user02 = new User()
            //                     {
            //                         Username = "dk01",
            //                         Password = "1989",
            //                         RegisterDate = DateTime.Now
            //                     };
            //                     session.Save(user01);
            //                     session.Save(user02);
            //                     //事务提交
            //                     transaction.Commit();
            //                     //事务关闭
            //                 }
            //                 
            //             }
            //             Console.WriteLine("已经初步解析了！");
            //             Console.ReadKey();
            //         }
            //         catch (Exception e)
            //         {
            //             Console.WriteLine(e);
            //         }
            //         finally
            //         {
            //             transaction?.Dispose();//事务关闭/释放
            //             session?.Close();
            //             if (sessionFactory != null)
            //             {
            //                 sessionFactory.Close();
            //             }
            //         }

            //插入/修改操作
            User user03 = new User()
            {
                Id = 4, //一般情况下，客户端不知道id
                Username = "jk123",
                Password = "123",
                RegisterDate = DateTime.Now
            };
            // UserManager.Instance.Add(user03);
            UserManager.Instance.Update(user03);

            //查询操作，根据id查询
            //User user = UserManager.Instance.GetById(19);
            //Console.WriteLine(user.Id);

            //查询操作，根据用户名查询，利用了CreateCriteria查询
            // User user = UserManager.Instance.GetByUserName("jk123"); //通过用户名获取
            // Console.WriteLine(user.Username);
            // Console.WriteLine(user.Id);
            // Console.WriteLine(user.Password);
            
            //查询操作，（集合查询） 获取所有的用户信息
            // ICollection<User> allUsers = UserManager.Instance.GetAllUsers();
            // foreach (var u in allUsers)
            // {
            //     Console.WriteLine("用户Id为：{0},  用户名为：{1},  用户密码为:{2},  用户注册日期为：{3}", u.Id, u.Username, u.Password,
            //         u.RegisterDate);
            // }

            bool b01 = UserManager.Instance.VerifyUser("dk","123");
            Console.WriteLine(b01 ? "用户名和密码正确！验证成功！" : "用户名或密码错误！请重新检查！");
            bool b02 = UserManager.Instance.VerifyUser("dk","1231");
            Console.WriteLine(b02 ? "用户名和密码正确！验证成功！" : "用户名或密码错误！请重新检查！");
            Console.WriteLine("数据库查询完成！"); 
        }
    }
}
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
三维数字孪生、虚拟仿真
三维平台数据展示、VR沉浸式开发、党建360/720全景开发

联系QQ:2583493258

很惭愧

只做了一点微小的工作
谢谢大家