[.NET] Lazy Row Mapping

前言

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

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

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

使用

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

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

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的生成跟运作。

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时的额外数据传输量 - 黑暗线程

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);  
        }
    }
}

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来完成这个功能需求。