(Object/(DataSet,DataReader) Relational Mapping)ODRM模式更新20070131

新修改ODRM函数库
1.增加SortedList对象，并且IBatisNet支持SortedList作为参数传递
ODRM模式下载地址:
https://files.cnblogs.com/mail-ricklee/ODRM.part01.rar
https://files.cnblogs.com/mail-ricklee/ODRM.part02.rar
https://files.cnblogs.com/mail-ricklee/ODRM.part03.rar

ODRMTemp_Default.cs演示代码

ODRMTemp_Default
using System;
using System.Data;
using System.Configuration;
using System.Collections;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
自定义命名空间#region 自定义命名空间
using System.Collections.Generic;
using System.Collections.Specialized;

using NickLee.Common;
using IBatisNet.DataMapper;
using IBatisNet.DataMapper.Exceptions;
#endregion

public partial class ODRMTemp_Default : System.Web.UI.Page
{
    /**//// <summary>
    /// 页面载入函数
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void Page_Load(object sender, EventArgs e)
    {
    }

    一级函数.公共#region 一级函数.公共

    模拟函数(ODRM.EvalMethod)#region 模拟函数(ODRM.EvalMethod)
    public static string xx(ref string jj, int yy)
    {
        string temp = jj;
        jj = jj + "_Add";
        return temp;
    }

    public virtual string GG(ref string jj, int yy)
    {
        string temp = jj;
        jj = jj + "_Add";
        return temp;
    }

    public string MM(ref string jj, int yy)
    {
        string temp = jj;
        jj = jj + "_Add";
        return temp;
    }

    #endregion

    #endregion

    /**//// <summary>
    /// 模拟函数(ODRM.EvalMethod)按钮事件
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void Button1_Click(object sender, EventArgs e)
    {
        ODRMTemp_Default objModel = new ODRMTemp_Default();
        Hashtable table = new Hashtable();
        table.Add("jj", "sdfdsfds");
        table.Add("yy", 55);

        SortedList list = new SortedList();
        list.Add("jj", "sdfdsfds");
        list.Add("yy", 55);

        object[] xx = new object[table.Count];
        object returnobj = new object();

        xx = ODRM.EvalMethod(objModel, "xx", table, ref returnobj);
        xx = ODRM.EvalMethod(objModel, "MM", table, ref returnobj);
        xx = ODRM.EvalMethod(objModel, "GG", table, ref returnobj);
    }

    /**//// <summary>
    /// parameterClass='System.Collections.IDictionary'测试
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void Button2_Click(object sender, EventArgs e)
    {
        try
        {
            键值对测试#region 键值对测试
            //通过:泛型键值对通过
            Dictionary<object, object> test = new Dictionary<object, object>();
            test.Add("NAME", "nick");
            test.Add("LOGINNAME", "nick");
            //通过:无排序键值对通过
            //Hashtable test = new Hashtable();
            //test.Add("NAME", "nick");
            //test.Add("LOGINNAME", "nick");
            //通过:可排序键值对通过
            //SortedList test = new SortedList();
            //test.Add("NAME", "nick");
            //test.Add("LOGINNAME", "nick");
            //通过:但不建议用ListDictionary作为传递参数
            //可以用Hashtable，SortedList替代,因NickLee.ODRM不提供ListDictionary与其他对象互换函数
            //ListDictionary test = new ListDictionary();
            //test.Add("NAME", "nick");
            //test.Add("LOGINNAME", "nick");
            #endregion
           
            单个函数测试#region 单个函数测试
            //通过:string,int,等单个类型通过，那么所有单个类型都通过
            //但仅仅用于非动态情况，如:Select * from xx where Name=#Name# and User=#User#,
            //不能包含动态配置
            //string test = "nick";
            //int test = 1;
            #endregion

            /**//*
             * 注意:null也通过
             */
            //DataSet set1=Mapper.Instance().QueryForDataSet("SelectXTM_UserListTemp_Test",null);
            DataSet set1 = Mapper.Instance().QueryForDataSet("Selectbasedata_UserListTest", test);

            Dictionary<object,object> dic=new Dictionary<object,object>();
            if(set1.Tables[0].Rows[0]!=null)
            {
                dic=ODRM.DataRowConvertDictionary(set1.Tables[0].Rows[0]);
            }
            
            GridView1.DataSource = set1.Tables[0];
            GridView1.DataBind();
            /**//*
             *    测试说明
             * 1.如果parameterClass='System.Collections.IDictionary',
             *   那么无论键值对类型还是普通的string,int单个类型,
             *   在传入的时候，如果有#Name#,#User#等多个函数的情况下,
             *   键值对类型会一一对应，而普通的string,int,等单个类型会直接吧#Name#,#User#等多个函数都替换为单个值和类型
             * 2.不包括对象类型数据
             * 3.普通的string,int单个类型,可以直接替换#value#,但不能包含动态配置，如isNotEmpty等
             * 4.建议
             *   4.1:parameterClass='System.Collections.IDictionary'，全部使用System.Collections.IDictionary传递，以满足更好的可扩充参数类型性
             *       ODRM.rar包中最新的IBatis代码生成器：LLBLGen.exe可以自动生成parameterClass='System.Collections.IDictionary'
             *   4.2:
             *       键值对，Hashtable,DataSet,对象实体之间互换函数参考：NickLee.Common.ODRM命名空间下函数
             *   
             */
        }
        catch (System.Exception ee)
        {
            throw ee;
        }
    }

    
}

函数库说明：

ODRM
using System;
using System.Collections;
using System.Data;
using System.Reflection;

namespace NickLee.Common
{
    // 摘要:
    //     Object/DataSet Relational Mapping(对象/数据集关系映射)
    public class ODRM
    {
        public ODRM();

        // 摘要:
        //     转换为DataTable
        //
        // 参数:
        //   Source:
        //     数据源
        //
        //   DataMember:
        //     数据表名称
        public static DataTable ConvertDataTable(object Source, string DataMember);
        //
        // 摘要:
        //     返回DataTable为哈希表键值对
        //
        // 参数:
        //   SourceRow:
        //     数据行对象
        //
        // 返回结果:
        //     填充后哈希表
        public static Hashtable DataRowConvertHashtable(DataRow SourceRow);
        //
        // 摘要:
        //     返回DataTable为哈希表键值对
        //
        // 参数:
        //   SourceRow:
        //     数据行对象
        //
        // 返回结果:
        //     填充后哈希表
        public static SortedList DataRowConvertSortedList(DataRow SourceRow);
        //
        // 摘要:
        //     数据集中一行DataRow转换为指定对象，并填充数据
        //
        // 参数:
        //   row:
        //     数据集中一行
        //
        //   objModel:
        //     指定对象
        //
        // 返回结果:
        //     填充后对象
        public static object DataTableConvertObject(DataRow row, object objModel);
        //
        // 摘要:
        //     数据集中一行DataRow转换为指定对象，并填充数据 baseAssembly请使用:System.Reflection.Assembly.LoadFrom()获取程序集
        //
        // 参数:
        //   row:
        //     数据集中一行
        //
        //   baseAssembly:
        //     程序集
        //
        //   className:
        //     完整路径类名称
        //
        // 返回结果:
        //     填充后对象
        public static object DataTableConvertObject(DataRow row, Assembly baseAssembly, string className);
        //
        // 摘要:
        //     数据集中一行DataRow转换为指定对象，并填充数据
        //
        // 参数:
        //   row:
        //     数据集中一行
        //
        //   AssemblyPath:
        //     程序集路径
        //
        //   className:
        //     完整路径类名称
        //
        // 返回结果:
        //     填充后对象
        public static object DataTableConvertObject(DataRow row, string AssemblyPath, string className);
        //
        // 摘要:
        //     执行指定对象函数(公共,静态) 函数可以ref、out、普通参数传递
        //
        // 参数:
        //   objModel:
        //     传入对象
        //
        //   methodName:
        //     函数名称
        //
        //   table:
        //     传入参数(Hashtable类型)
        //
        //   returnobj:
        //     执行制定函数返回值
        //
        // 返回结果:
        //     返回执行指定对象函数的传入数据(ref,out数据经过修改)
        public static object[] EvalMethod(object objModel, string methodName, Hashtable table, ref object returnobj);
        //
        // 摘要:
        //     执行指定对象函数(公共,静态) 函数可以ref、out、普通参数传递
        //
        // 参数:
        //   objModel:
        //     传入对象
        //
        //   methodName:
        //     函数名称
        //
        //   list:
        //     传入参数(SortedList类型)
        //
        //   returnobj:
        //     执行制定函数返回值
        //
        // 返回结果:
        //     返回执行指定对象函数的传入数据(ref,out数据经过修改)
        public static object[] EvalMethod(object objModel, string methodName, SortedList list, ref object returnobj);
        //
        // 摘要:
        //     执行指定对象函数(公共,静态) 函数可以ref、out、普通参数传递
        //
        // 参数:
        //   baseAssembly:
        //     程序集对象
        //
        //   className:
        //     对象名称
        //
        //   table:
        //     传入参数(Hashtable类型)
        //
        //   returnobj:
        //     执行制定函数返回值
        //
        // 返回结果:
        //     返回执行指定对象函数的传入数据(ref,out数据经过修改)
        public static object[] EvalMethod(Assembly baseAssembly, string className, string methodName, Hashtable table, ref object returnobj);
        //
        // 摘要:
        //     执行指定对象函数(公共,静态) 函数可以ref、out、普通参数传递
        //
        // 参数:
        //   baseAssembly:
        //     程序集对象
        //
        //   className:
        //     对象名称
        //
        //   list:
        //     传入参数(SortedList类型)
        //
        //   returnobj:
        //     执行制定函数返回值
        //
        // 返回结果:
        //     返回执行指定对象函数的传入数据(ref,out数据经过修改)
        public static object[] EvalMethod(Assembly baseAssembly, string className, string methodName, SortedList list, ref object returnobj);
        //
        // 摘要:
        //     执行指定对象函数(公共,静态) 函数可以ref、out、普通参数传递
        //
        // 参数:
        //   AssemblyPath:
        //     程序集路径
        //
        //   className:
        //     对象名称
        //
        //   table:
        //     传入参数(Hashtable类型)
        //
        //   returnobj:
        //     执行制定函数返回值
        //
        // 返回结果:
        //     返回执行指定对象函数的传入数据(ref,out数据经过修改)
        public static object[] EvalMethod(string AssemblyPath, string className, string methodName, Hashtable table, ref object returnobj);
        //
        // 摘要:
        //     执行指定对象函数(公共,静态) 函数可以ref、out、普通参数传递
        //
        // 参数:
        //   AssemblyPath:
        //     程序集路径
        //
        //   className:
        //     对象名称
        //
        //   list:
        //     传入参数(SortedList类型)
        //
        //   returnobj:
        //     执行制定函数返回值
        //
        // 返回结果:
        //     返回执行指定对象函数的传入数据(ref,out数据经过修改)
        public static object[] EvalMethod(string AssemblyPath, string className, string methodName, SortedList list, ref object returnobj);
        //
        // 摘要:
        //     哈希表对象转换为DataTable，并有一行DataRow
        //
        // 参数:
        //   hTable:
        //     包含数据的哈希表
        //
        // 返回结果:
        //     填充后数据表
        public static DataTable HashtableConvertDataTableWidthRow(Hashtable hTable);
        //
        // 摘要:
        //     哈希表对象转换为DataTable，并有一行DataRow
        //
        // 参数:
        //   hTable:
        //     包含数据的哈希表
        //
        //   DataMember:
        //     生成数据表名称
        //
        // 返回结果:
        //     填充后数据表
        public static DataTable HashtableConvertDataTableWidthRow(Hashtable hTable, string DataMember);
        //
        // 摘要:
        //     哈希表转换为对象
        //
        // 参数:
        //   hTable:
        //     包含数据的哈希表
        //
        //   objModel:
        //     指定对象
        //
        // 返回结果:
        //     填充后对象
        public static object HashtableConvertObject(Hashtable hTable, object objModel);
        //
        // 摘要:
        //     哈希表转换为对象 baseAssembly请使用:System.Reflection.Assembly.LoadFrom()获取程序集
        //
        // 参数:
        //   hTable:
        //     包含数据的哈希表
        //
        //   baseAssembly:
        //     程序集
        //
        //   className:
        //     完整路径类名称
        //
        // 返回结果:
        //     填充后对象
        public static object HashtableConvertObject(Hashtable hTable, Assembly baseAssembly, string className);
        //
        // 摘要:
        //     哈希表转换为对象
        //
        // 参数:
        //   hTable:
        //     包含数据的哈希表
        //
        //   AssemblyPath:
        //     程序集路径
        //
        //   className:
        //     完整路径类名称
        //
        // 返回结果:
        //     填充后对象
        public static object HashtableConvertObject(Hashtable hTable, string AssemblyPath, string className);
        //
        // 摘要:
        //     Hashtable转化为SortedList
        //
        // 参数:
        //   table:
        //     传入的Hashtable
        //
        // 返回结果:
        //     返回的SortedList
        public static SortedList HashtableConvertSortedList(Hashtable table);
        //
        // 摘要:
        //     哈希数据比较 作为在修改的时候或者其他时候判断是否做过处理
        //
        // 参数:
        //   Fristobj:
        //     比较哈希表
        //
        //   Equalobj:
        //     被比较哈希表
        //
        //   errMethod:
        //     返回比较不一致对象
        //
        // 返回结果:
        //     比较状态
        public static bool HashtableDataEqual(Hashtable Fristobj, Hashtable Equalobj, ref string errMethod);
        //
        // 摘要:
        //     对象转换为DataTable，并有单行DataRow
        //
        // 参数:
        //   objModel:
        //     有数据的对象
        //
        // 返回结果:
        //     填充后数据表
        public static DataTable ObjectConvertDataTableWidthRow(object objModel);
        //
        // 摘要:
        //     对象转换为DataTable，并有单行DataRow
        //
        // 参数:
        //   objModel:
        //     有数据的对象
        //
        //   DataMember:
        //     生成数据表名称
        //
        // 返回结果:
        //     填充后数据表
        public static DataTable ObjectConvertDataTableWidthRow(object objModel, string DataMember);
        //
        // 摘要:
        //     对象转换为DataTable，并有多行DataRow
        //
        // 参数:
        //   objModel:
        //     有数据的对象
        //
        // 返回结果:
        //     填充后数据表
        public static DataTable ObjectConvertDataTableWidthRows(object[] objModel);
        //
        // 摘要:
        //     对象转换为DataTable，并有多行DataRow
        //
        // 参数:
        //   objModel:
        //     有数据的对象
        //
        //   DataMember:
        //     生成数据表名称
        //
        // 返回结果:
        //     填充后数据表
        public static DataTable ObjectConvertDataTableWidthRows(object[] objModel, string DataMember);
        //
        // 摘要:
        //     对象转化为哈希表
        //
        // 参数:
        //   objModel:
        //     对象
        //
        // 返回结果:
        //     填充后哈希表
        public static Hashtable ObjectConvertHashtable(object objModel);
        //
        // 摘要:
        //     对象转化为哈希表
        //
        // 参数:
        //   objModel:
        //     对象
        //
        // 返回结果:
        //     填充后哈希表
        public static SortedList ObjectConvertSortedList(object objModel);
        //
        // 摘要:
        //     对象数据比较 作为在修改的时候或者其他时候判断是否做过处理
        //
        // 参数:
        //   Fristobj:
        //     比较对象
        //
        //   Equalobj:
        //     被比较对象
        //
        //   errMethod:
        //     返回比较不一致对象或者类不一致提示
        //
        // 返回结果:
        //     比较状态(false不一致,true一致)
        public static bool ObjectDataEqual(object Fristobj, object Equalobj, ref string errMethod);
        //
        // 摘要:
        //     SortedList对象转换为DataTable，并有一行DataRow
        //
        // 参数:
        //   hTable:
        //     包含数据的SortedList
        //
        // 返回结果:
        //     填充后数据表
        public static DataTable SortedListConvertDataTableWidthRow(SortedList hTable);
        //
        // 摘要:
        //     SortedList对象转换为DataTable，并有一行DataRow
        //
        // 参数:
        //   hTable:
        //     包含数据的SortedList
        //
        //   DataMember:
        //     生成数据表名称
        //
        // 返回结果:
        //     填充后数据表
        public static DataTable SortedListConvertDataTableWidthRow(SortedList hTable, string DataMember);
        //
        // 摘要:
        //     SortedList转化为Hashtable
        //
        // 参数:
        //   list:
        //     传入的SortedList
        //
        // 返回结果:
        //     返回的Hashtable
        public static Hashtable SortedListConvertHashtable(SortedList list);
        //
        // 摘要:
        //     SortedList转换为对象
        //
        // 参数:
        //   hTable:
        //     包含数据的SortedList
        //
        //   objModel:
        //     指定对象
        //
        // 返回结果:
        //     填充后对象
        public static object SortedListConvertObject(SortedList hTable, object objModel);
        //
        // 摘要:
        //     SortedList转换为对象 baseAssembly请使用:System.Reflection.Assembly.LoadFrom()获取程序集
        //
        // 参数:
        //   hTable:
        //     包含数据的SortedList
        //
        //   baseAssembly:
        //     程序集
        //
        //   className:
        //     完整路径类名称
        //
        // 返回结果:
        //     填充后对象
        public static object SortedListConvertObject(SortedList hTable, Assembly baseAssembly, string className);
        //
        // 摘要:
        //     SortedList转换为对象
        //
        // 参数:
        //   hTable:
        //     包含数据的SortedList
        //
        //   AssemblyPath:
        //     程序集路径
        //
        //   className:
        //     完整路径类名称
        //
        // 返回结果:
        //     填充后对象
        public static object SortedListConvertObject(SortedList hTable, string AssemblyPath, string className);
        //
        // 摘要:
        //     SortedList数据比较 作为在修改的时候或者其他时候判断是否做过处理
        //
        // 参数:
        //   Fristobj:
        //     比较SortedList
        //
        //   Equalobj:
        //     被比较SortedList
        //
        //   errMethod:
        //     返回比较不一致对象
        //
        // 返回结果:
        //     比较状态
        public static bool SortedListDataEqual(SortedList Fristobj, SortedList Equalobj, ref string errMethod);
    }
}