[.NET] Lazy Row Mapping

前言

在做架构设计的时候，数据对象进出系统边界，可以采用先前的文章介绍的[Architecture Pattern] Repository，来将外部的系统、模块、数据库…等等，隔离在架构之外。而当系统采用关系数据库来做为储存数据库的时候，开发人员必需要在程序内加入ORM(Object Relational Mapping)的功能，才能将数据对象与关系数据库数据做互相的转换。

 

但当开发人员要从数据库查询大量数据的时候，会惊觉上述ORM的运作模式是：将数据库查询到的「所有数据」，转换为数据对象集合放在「内存内」，再交由系统去使用。「所有数据」、「内存内」这两个关键词，决定了在大量数据的处理上，这个运作模式有风险。毕竟就算计算机内存的售价再便宜，使用者大多还是不会为了软件，多投资金钱去购买内存。

 

本篇文章介绍一个「Lazy Row Mapping」实做，用来处理对关系数据库查询大量数据做ORM的需求。为自己做个纪录，也希望能帮助到有需要的开发人员。

 

使用

因为实做的内容有点硬，所以先展示使用范例，看能不能减少开发人员按上一页离开的机率…。

 

?
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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.SqlClient;
using System.Data;
 
namespace LazyRowMappingSample
{
    class Program
    {
        static void Main(string[] args)
        {
            // UserRepositoryProvider
            UserRepositoryProvider userRepositoryProvider = new UserRepositoryProvider();
 
            // QueryAll
            foreach (User user in userRepositoryProvider.QueryAll())
            {               
                Console.WriteLine("Name : " + user.Name);
                Console.WriteLine("Create Time : " + user.CreateTime);
                Console.WriteLine("Read Time : " + DateTime.Now);
                Console.WriteLine();
                System.Threading.Thread.Sleep(2000);
            }
 
            // End
            Console.ReadLine();
        }
    }
 
    public class User
    {
        // Properties
        public string Name { get; set; }
 
        public DateTime CreateTime { get; set; }
    }
 
    public class UserRepositoryProvider
    {
        // Methods
        public IEnumerable<User> QueryAll()
        {
            // Arguments
            string connectionString = @"Data Source=.\SQLEXPRESS;AttachDbFilename=|DataDirectory|\LazyRowMappingSample.mdf;Integrated Security=True;User Instance=True";
 
            string commandText = @"SELECT * FROM [User]";
 
            SqlParameter[] parameters = new SqlParameter[] { };
 
            Func<IDataRecord, User> rowMappingDelegate = delegate(IDataRecord dataRecord)
            {
                User user = new User();
                user.Name = Convert.ToString(dataRecord["Name"]);
                user.CreateTime = DateTime.Now;
                return user;
            };
 
            // Return
            return new SqlLazyRowMappingEnumerable<User>(connectionString, commandText, parameters, rowMappingDelegate);
        }
    }  
}

 

上面的使用范例，展示如何使用实做章节完成的SqlLazyRowMappingEnumerable。SqlLazyRowMappingEnumerable只需要四个参数，就可以对Sql数据库做查询数据以及完成ORM的工作。

 

范例中每次读取一个数据对象就暂停2秒，并且输出数据对象的读取时间与生成时间。在执行结果中可以看到，每个数据对象读取的时间与生成的时间是相同的。也就是说：每次透过SqlLazyRowMappingEnumerable取得的数据对象，都是在取得的当下才去生成数据对象。这样可以避免一次将所有数据对象加载到内存内，造成内存不足的风险。

 

可以说SqlLazyRowMappingEnumerable帮助开发人员简单的处理了，对Sql数据库查询大量数据做ORM的需求。

 

实做

范列下载

实做说明请参照范例程序内容：LazyRowMappingSample点此下载

 

范例结构

下图是简易的范例结构，对照这张图片说明与范例程序，可以帮助开发人员较快速理解本篇文章的思路。

 

LazyDataRecordEnumerable

读取资料可以使用ADO.NET里的DbDataReader类别，来与关连式数据库做连接。开发人员去分析ADO.NET里提供的DbDataReader类别，可以发现DbDataReadr类别是以一次读取一笔数据的方式来处理数据库数据，这看起来能满足查询大量数据的需求。而这个功能主要是由DbDataReader类别实做的IDataReader接口跟IDataRecord接口所定义；IDataReader接口定义了询览下一笔数据的方法、IDataRecord接口则是定义取得数据内容的方式。

 

初步了解DbDataReader类别的运作模式之后，来看看下列这个LazyDataRecordEnumerable对象，LazyDataRecordEnumerable将DbDataReader类别的运作模式封装成为IEnumerable<IDataRecord>的实做。系统在使用foreach列举IEnumerable<IDataRecord>的时候，LazyDataRecordEnumerable才会建立DbDataReader去关连式数据库查询数据。然后以一次读取一笔数据的方式，将数据库数据透过IDataRecord交由系统使用。

 

关于LazyDataRecordEnumerable的设计细节，可以参考：
[.NET] LINQ Deferred Execution

 

?
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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Data.Common;
 
namespace LazyRowMappingSample
{
    public abstract class LazyDataRecordEnumerable: IEnumerable<IDataRecord>
    {
        // Methods
        protected abstract LazyDataRecordEnumerator CreateEnumerator();
 
        public IEnumerator<IDataRecord> GetEnumerator()
        {
            return this.CreateEnumerator();
        }
 
        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return this.GetEnumerator();
        }       
    }
 
    public abstract class LazyDataRecordEnumerator : IEnumerator<IDataRecord>
    {
        // Constructor      
        public void Dispose()
        {
            this.EndEnumerate();
        }
 
 
        // Properties
        protected abstract DbDataReader DataReader { get; }
 
        public IDataRecord Current
        {
            get
            {
                return this.DataReader;
            }
        }
 
        object System.Collections.IEnumerator.Current
        {
            get
            {
                return this.Current;
            }
        }
 
 
        // Methods
        protected abstract void BeginEnumerate();
 
        protected abstract void EndEnumerate();                     
 
        public bool MoveNext()
        {
            if (this.DataReader == null) this.BeginEnumerate();
            if (this.DataReader != null)
            {
                while (this.DataReader.Read() == true)
                {
                    return true;
                }
            }
            return false;
        }
 
        public void Reset()
        {
            this.EndEnumerate();
        }
    }   
}

 

*LazyDataRecordEnumerable也可以使用.NET提供的yield关键词来实做，有兴趣的开发人员可以找相关数据来学习。

 

CastingEnumerable

LazyDataRecordEnumerable实做的IEnumerable<IDataRecord>接口所提供的IDataRecord，并不是开发人员想要得到的数据对象。要将IDataRecord转换为数据对象，可以在LazyDataRecordEnumerable外面套用一层CastingEnumerable。透过CastingEnumerable提供的功能，以一次一笔的方式，将LazyDataRecordEnumerable提供的IDataRecord转变成为数据对象交由系统使用。

 

关于CastingEnumerable的设计细节，可以参考：
[.NET] CastingEnumerable

 

LazyRowMappingEnumerable

LazyDataRecordEnumerable套用一层CastingEnumerable的方式，已经可以完成Lazy Row Mapping的功能。但为了让开发人员方便使用，另外建立了一个LazyRowMappingEnumerable，用来封装了LazyDataRecordEnumerable、CastingEnumerable的生成跟运作。

 

?
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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
 
namespace LazyRowMappingSample
{
    public abstract class LazyRowMappingEnumerable<T> : IEnumerable<T>
        where T : class
    {
        // Fields
        private readonly Func<IDataRecord, T> _rowMappingDelegate = null;
 
        private IEnumerable<T> _enumerable = null;
 
 
        // Constructor  
        public LazyRowMappingEnumerable(Func<IDataRecord, T> rowMappingDelegate)
        {
            #region Require
 
            if (rowMappingDelegate == null) throw new ArgumentNullException();
 
            #endregion
            _rowMappingDelegate = rowMappingDelegate;
        }
 
 
        // Methods
        protected abstract LazyDataRecordEnumerable CreateEnumerable();
 
        private T CreateObject(IDataRecord dataRecord)
        {
            return _rowMappingDelegate(dataRecord);
        }
 
        public IEnumerator<T> GetEnumerator()
        {
            if (_enumerable == null)
            {
                LazyDataRecordEnumerable lazyDataRecordEnumerable  = this.CreateEnumerable();
                CastingEnumerable<T, IDataRecord> castingEnumerable = new CastingEnumerable<T, IDataRecord>(lazyDataRecordEnumerable, this.CreateObject);
                _enumerable = castingEnumerable;
            }
            return _enumerable.GetEnumerator();
        }
 
        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return this.GetEnumerator();
        }
    }
}

 

SqlLazyRowMappingEnumerable

一直到建立LazyDataRecordEnumerable为止，整个范例处理目标都是抽象的DbDataReader，而不是连接各种数据库的DbDataReader实做。最后一个范例，就用来说明如何建立LazyRowMappingEnumerable的Sql版本实做。开发人员使用这个SqlLazyRowMappingEnumerable，就可以简单处理对Sql数据库查询大量数据做ORM的需求。

 

关于SqlLazyRowMappingEnumerable的设计细节，可以参考：
KB-当心SqlDataReader.Close时的额外数据传输量 - 黑暗线程

 

?
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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.SqlClient;
using System.Data;
 
namespace LazyRowMappingSample
{
    public class SqlLazyRowMappingEnumerable<T> : LazyRowMappingEnumerable<T>
        where T : class
    {
        // Fields
        private readonly string _connectionString = null;
 
        private readonly string _commandText = null;
 
        private readonly SqlParameter[] _parameters = null;       
 
 
        // Constructor    
        public SqlLazyRowMappingEnumerable(string connectionString, string commandText, SqlParameter[] parameters, Func<IDataRecord, T> rowMappingDelegate)
            : base(rowMappingDelegate)
        {
            #region Require
 
            if (string.IsNullOrEmpty(connectionString) == true) throw new ArgumentException();
            if (string.IsNullOrEmpty(commandText) == true) throw new ArgumentException();
            if (parameters == null) throw new ArgumentNullException();
 
            #endregion
            _connectionString = connectionString;
            _commandText = commandText;
            _parameters = parameters;
        }
 
 
        // Methods
        protected override LazyDataRecordEnumerable CreateEnumerable()
        {
            return new SqlLazyDataRecordEnumerable(_connectionString, _commandText, _parameters); 
        }
    }
}

 

?
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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.Common;
using System.Data.SqlClient;
 
namespace LazyRowMappingSample
{
    public class SqlLazyDataRecordEnumerable : LazyDataRecordEnumerable
    {
        // Fields
        private readonly string _connectionString = null;
 
        private readonly string _commandText = null;
 
        private readonly SqlParameter[] _parameters = null;
 
 
        // Constructor    
        public SqlLazyDataRecordEnumerable(string connectionString, string commandText, SqlParameter[] parameters)
        {
            #region Require
 
            if (string.IsNullOrEmpty(connectionString) == true) throw new ArgumentException();
            if (string.IsNullOrEmpty(commandText) == true) throw new ArgumentException();
            if (parameters == null) throw new ArgumentNullException();
 
            #endregion
            _connectionString = connectionString;
            _commandText = commandText;
            _parameters = parameters;
        }
 
 
        // Methods
        protected override LazyDataRecordEnumerator CreateEnumerator()
        {
            return new SqlLazyDataRecordEnumerator(_connectionString, _commandText, _parameters);
        }
    }
 
    public class SqlLazyDataRecordEnumerator : LazyDataRecordEnumerator
    {
        // Fields
        private readonly string _connectionString = null;
 
        private readonly string _commandText = null;
             
        private readonly  SqlParameter[] _parameters = null;
 
        private SqlConnection _connection = null;
 
        private SqlCommand _command = null;
 
        private SqlDataReader _dataReader = null;
 
 
        // Constructor    
        public SqlLazyDataRecordEnumerator(string connectionString, string commandText, SqlParameter[] parameters)
        {
            #region Require
 
            if (string.IsNullOrEmpty(connectionString) == true) throw new ArgumentException();
            if (string.IsNullOrEmpty(commandText) == true) throw new ArgumentException();
            if (parameters == null) throw new ArgumentNullException();
 
            #endregion
            _connectionString = connectionString;
            _commandText = commandText;
            _parameters = parameters;
        }
 
 
        // Properties
        protected override DbDataReader DataReader
        {
            get { return _dataReader; }
        }
 
 
        // Methods
        protected override void BeginEnumerate()
        {
            // End
            this.EndEnumerate();
 
            // Begin
            _connection = new SqlConnection(_connectionString);
            _command = new SqlCommand(_commandText, _connection);
            _command.Parameters.AddRange(_parameters);
            _connection.Open();
            _dataReader = _command.ExecuteReader();
        }
 
        protected override void EndEnumerate()
        {
            // End
            if(_dataReader!=null)
            {
                _command.Cancel();
                _dataReader.Close();
                _dataReader.Dispose();
                _dataReader = null;
            }
             
            if(_command!=null)
            {
                _command.Dispose();
                _command = null;
            }
 
            if(_connection!=null)
            {
                _connection.Close();
                _connection.Dispose();
                _connection = null;
            }
        }
    }
}

 

后记

了解整个LazyRowMappingEnumerable的运作之后，开发人员遇到对关系数据库查询大量数据做ORM的需求。如果目标关系数据库有提供DbDataReadr对象来查询数据，开发人员可以实做LazyRowMappingEnumerable的子类别来满足需求。如果没有提供DbDataReadr对象或是根本不是关系数据库，也可以依照本章的思路建立一个LazyXxxMappingEnumerable来完成这个功能需求。


posted @   Clark159  阅读(1435)  评论(1)  编辑  收藏  举报
编辑推荐：
· go语言实现终端里的倒计时
· 如何编写易于单元测试的代码
· 10年+ .NET Coder 心语，封装的思维：从隐藏、稳定开始理解其本质意义
· .NET Core 中如何实现缓存的预热？
· 从 HTTP 原因短语缺失研究 HTTP/2 和 HTTP/3 的设计差异
阅读排行：
· 周边上新：园子的第一款马克杯温暖上架
· Open-Sora 2.0 重磅开源！
· 分享 3 个 .NET 开源的文件压缩处理库，助力快速实现文件压缩解压功能！
· Ollama——大语言模型本地部署的极速利器
· DeepSeek如何颠覆传统软件测试？测试工程师会被淘汰吗？
点击右上角即可分享
微信分享提示
AI IDE Trae