在MVC下如何使用ajax实现表单内容的管理

摘要: 在表单中往往我们要进行添加，修改和删除的操作，这里我们将探讨如何进行表单的ajax管理。探索一种通用的模式来完成类似任务的管理与实现。

在应用中我们会经常遇到表单的展现与管理问题，现在为了更加灵活的管理和操作，更多的人采用了ajax的方式来进行，MVC为我们提供了一个良好的系统架构，简单而言我们只要通过view中的ajax就可以直接访问Controller中的对应方法来实现ajax的请求，从而完成数据的交互，达到管理的目的。

我们下面将分别对列表、添加、修改和删除进行讲解，该实例来自VonPortal中的模块管理，分别实现模块中的文件上传以及文件功能的注册管理。



在这里涉及到三个表结构，这里不再详细说明，对应的结构类代码如下：

//模块信息（PTL_Module）
#region "模块信息信息类声明"
namespace VonPortal.Web.Models
{
/// <summary>模块信息 信息类</summary>
public class ModuleInfo
{
#region "Public Properties"
/// <summary>序号</summary>
[Required]
[Display(Name = "序号")]
public int ID { get; set; }
/// <summary>网站序号</summary>
[Required]
[Display(Name = "网站序号")]
public int SiteIdx { get; set; }
/// <summary>模块名称</summary>
[Display(Name = "模块名称")]
public string ModuleName { get; set; }
/// <summary>版本信息</summary>
[Display(Name = "版本信息")]
public string Version { get; set; }
/// <summary>作者</summary>
[Display(Name = "作者")]
public string Author { get; set; }
/// <summary>版权所有</summary>
[Display(Name = "版权所有")]
public string Owner { get; set; }
/// <summary>版权说明</summary>
[Display(Name = "版权说明")]
public string Copyright { get; set; }
/// <summary>有效期</summary>
[Display(Name = "有效期")]
public DateTime AvailDate { get; set; }
#endregion
}
}
#endregion
#region "模块信息信息基础控制类声明"
namespace VonPortal.Web.Operators
{
/// <summary>模块信息 控制类</summary>
public class ModuleCtrl
{
private ModuleDataProvider dataProvider = null;
public IDbTransaction BeginTrans()
{
dataProvider = ModuleDataProvider.CreateProvider();
return dataProvider.DBBeginTrans();
}
public ModuleCtrl(IDbTransaction DBTrans)
{
if (DBTrans == null)
dataProvider = ModuleDataProvider.Instance();
else
{
dataProvider = ModuleDataProvider.CreateProvider();
dataProvider.DBTrans = DBTrans;
}
}
//Read data and write to ModuleInfo class
private void setInfoValue(IDataReader reader, ModuleInfo info)
{
info.ID = reader.GetInt32(0);  //序号
info.SiteIdx = reader.GetInt32(1);  //网站序号
info.ModuleName = reader.GetString(2);  //模块名称
info.Version = reader.GetString(3);  //版本信息
info.Author = reader.GetString(4);  //作者
info.Owner = reader.GetString(5);  //版权所有
info.Copyright = reader.GetString(6);  //版权说明
info.AvailDate = reader.GetDateTime(7); ;  //有效期
}
/// <summary>检验Module信息</summary>
public string Check(ModuleInfo info)
{
string errInfo = "";
return errInfo;
}
/// <summary>
/// 根据主键 PK_Module 提取信息
/// </summary>
/// <param name="int ID>序号</param>
public ModuleInfo GetByModule(int ID)
{
IDataReader reader = dataProvider.GetByModule(ID);
if (!reader.Read())
{
reader.Close();
return null;
}
ModuleInfo info = new ModuleInfo();
setInfoValue(reader, info);
reader.Close();
return info;
}
/// <summary>得到模块说明信息</summary>
///<param name="int ID>序号</param>
///<param name="VonKeyValueCollection Note">模块说明</param>
public string GetNote(int ID)
{
return dataProvider.GetNote(ID);
}
/// <summary>得到创建SQL信息</summary>
///<param name="int ID>序号</param>
///<param name="VonKeyValueCollection InitSQL">创建SQL</param>
public string GetInitSQL(int ID)
{
return dataProvider.GetInitSQL(ID);
}
/// <summary>得到删除SQL信息</summary>
///<param name="int ID>序号</param>
///<param name="VonKeyValueCollection DelSQL">删除SQL</param>
public string GetDelSQL(int ID)
{
return dataProvider.GetDelSQL(ID);
}
/// <summary>根据外键 FK_MODULE_REF_SITE 提取信息</summary>
public List<ModuleInfo> ListByMODULE_REF_SITE(int SiteIdx, bool IncludePortal)
{
List<ModuleInfo> list = new List<ModuleInfo>();
IDataReader reader = dataProvider.ListByMODULE_REF_SITE(SiteIdx, IncludePortal);
while (reader.Read())
{
ModuleInfo info = new ModuleInfo();
setInfoValue(reader, info);
list.Add(info);
}
reader.Close();
return list;
}
/// <summary>保存Module信息</summary>
///<param name="TModuleInfo info">信息类</param>
public bool Save(ModuleInfo info)
{
info.ID = dataProvider.Save(info.ID, info.SiteIdx, info.ModuleName, info.Version, info.Author, info.Owner, info.Copyright, info.AvailDate);
return info.ID > 0;
}
/// <summary>添加Module信息</summary>
///<param name="TModuleInfo info">信息类</param>
public int Add(ModuleInfo info)
{
info.ID = dataProvider.Add(info.SiteIdx, info.ModuleName, info.Version, info.Author, info.Owner, info.Copyright, info.AvailDate);
return info.ID;
}
/// <summary>修改Module信息</summary>
///<param name="TModuleInfo info">信息类</param>
public bool Edit(ModuleInfo info)
{
return dataProvider.Edit(info.ID, info.SiteIdx, info.ModuleName, info.Version, info.Author, info.Owner, info.Copyright, info.AvailDate) > 0;
}
/// <summary>编辑模块说明信息</summary>
///<param name="int ID>序号</param>
///<param name="VonKeyValueCollection Note">模块说明</param>
public bool SetNote(int ID, string Note)
{
return dataProvider.EditNote(ID, Note) > 0;
}
/// <summary>编辑创建SQL信息</summary>
///<param name="int ID>序号</param>
///<param name="VonKeyValueCollection InitSQL">创建SQL</param>
public bool SetInitSQL(int ID, string InitSQL)
{
return dataProvider.EditInitSQL(ID, InitSQL) > 0;
}
/// <summary>编辑删除SQL信息</summary>
///<param name="int ID>序号</param>
///<param name="VonKeyValueCollection DelSQL">删除SQL</param>
public bool SetDelSQL(int ID, string DelSQL)
{
return dataProvider.EditDelSQL(ID, DelSQL) > 0;
}
/// <summary>根据PK_Module删除Module信息</summary>
/// <param name="int ID>序号</param>
public int Del(int ID)
{
return dataProvider.Del(ID);
}
/// <summary>根据FK_MODULE_REF_SITE删除Module信息</summary>
///<param name="int SiteIdx">网站序号</param>
public int DelSite(int SiteIdx)
{
return dataProvider.Del(SiteIdx);
}

}
}
#endregion
#region "模块信息信息操作控制类声明"
namespace VonPortal.Web.Tasks
{
/// <summary>模块信息 控制类</summary>
public class ModuleTask : ModuleCtrl
{
/// <summary>含数据库事务的构造函数</summary>
public ModuleTask(IDbTransaction DBTrans) : base(DBTrans)
{
}
/// <summary>
/// 根据主键 PK_Module 提取信息
/// </summary>
/// <param name="ID">序号</param>
public new Task<ModuleInfo> GetByModule(int ID)
{
return Task.Run(() =>
{
return base.GetByModule(ID);
});
}
/// <summary>得到模块说明信息</summary>
///<param name="ID">序号</param>
///<param name="Note">模块说明</param>
public new Task<string> GetNote(int ID)
{
return Task.Run(() =>
{
return base.GetNote(ID);
});
}
/// <summary>编辑模块说明信息</summary>
///<param name="ID">序号</param>
///<param name="Note">模块说明</param>
public new Task<bool> SetNote(int ID, string Note)
{
return Task.Run(() =>
{
return base.SetNote(ID, Note);
});
}
/// <summary>得到创建SQL信息</summary>
///<param name="ID">序号</param>
///<param name="InitSQL">创建SQL</param>
public new Task<string> GetInitSQL(int ID)
{
return Task.Run(() =>
{
return base.GetInitSQL(ID);
});
}
/// <summary>编辑创建SQL信息</summary>
///<param name="ID">序号</param>
///<param name="InitSQL">创建SQL</param>
public new Task<bool> SetInitSQL(int ID, string InitSQL)
{
return Task.Run(() =>
{
return base.SetInitSQL(ID, InitSQL);
});
}
/// <summary>得到删除SQL信息</summary>
///<param name="ID">序号</param>
///<param name="DelSQL">删除SQL</param>
public new Task<string> GetDelSQL(int ID)
{
return Task.Run(() =>
{
return base.GetDelSQL(ID);
});
}
/// <summary>编辑删除SQL信息</summary>
///<param name="ID">序号</param>
///<param name="DelSQL">删除SQL</param>
public new Task<bool> SetDelSQL(int ID, string DelSQL)
{
return Task.Run(() =>
{
return base.SetDelSQL(ID, DelSQL);
});
}
/// <summary>根据外键 FK_MODULE_REF_SITE 提取信息</summary>
public new Task<List<ModuleInfo>> ListByMODULE_REF_SITE(int SiteIdx, bool IncludePortal)
{
return Task.Run(() =>
{
return base.ListByMODULE_REF_SITE(SiteIdx, IncludePortal);
});
}
/// <summary>保存Module信息</summary>
///<param name="info">信息类</param>
public new Task<bool> Save(ModuleInfo info)
{
return Task.Run(() =>
{
return base.Save(info);
});
}
/// <summary>添加Module信息</summary>
///<param name="info">信息类</param>
public new Task<int> Add(ModuleInfo info)
{
return Task.Run(() =>
{
return base.Add(info);
});
}
/// <summary>修改Module信息</summary>
///<param name="info">信息类</param>
public new Task<bool> Edit(ModuleInfo info)
{
return Task.Run(() =>
{
return base.Edit(info);
});
}
/// <summary>根据PK_Module删除Module信息</summary>
/// <param name="ID">序号</param>
public new Task<int> Del(int ID)
{
return Task.Run(() =>
{
return base.Del(ID);
});
}
/// <summary>根据FK_MODULE_REF_SITE删除Module信息</summary>
///<param name="SiteIdx">网站序号</param>
public new Task<int> DelSite(int SiteIdx)
{
return Task.Run(() =>
{
return base.Del(SiteIdx);
});
}

}
}
#endregion
#region "模块信息信息数据库访问基类声明"
namespace VonPortal.Web.Data
{
/// <summary>
/// 数据及操作控制层
/// <seealso cref="VonPortal.Web.Business.ModuleInfo"/>
/// <seealso cref="VonPortal.Web.Business.ModuleCtrl"/>
/// </summary>
public abstract class ModuleDataProvider : DataProvider
{
#region Shared/Static Methods
// singleton reference to the instantiated object
private static ModuleDataProvider objProvider = null;

// constructor
static ModuleDataProvider()
{
objProvider = CreateProvider();
}

// dynamically create provider
public static ModuleDataProvider CreateProvider()
{
return (ModuleDataProvider)VonPortal.Web.Reflection.CreateDataProvider("ptl", "VonPortal", "VonPortal.Web.Data.ModuleDataProvider");
}
/// <summary>
/// The instance of ModuleDataProvider with databse transaction.
/// </summary>
/// <param name="DBTransaction">数据库事物变量，如果为空则表明是事务性调用，则使用静态对象</param>
/// <returns>return the provider</returns>
public static ModuleDataProvider Instance()
{
if (objProvider == null) objProvider = CreateProvider();
return objProvider;
}
#endregion

#region "TModule Abstract Methods"
/// <summary>根据主键 PK_Module 提取信息</summary>
public abstract IDataReader GetByModule(int ID);
/// <summary>编辑模块说明信息</summary>
///<param name="int ID>序号</param>
public abstract string GetNote(int ID);
/// <summary>编辑创建SQL信息</summary>
///<param name="int ID>序号</param>
public abstract string GetInitSQL(int ID);
/// <summary>编辑删除SQL信息</summary>
///<param name="int ID>序号</param>
public abstract string GetDelSQL(int ID);
/// <summary>根据外键 FK_MODULE_REF_SITE 提取信息</summary>
public abstract IDataReader ListByMODULE_REF_SITE(int SiteIdx, bool IncludePortal);
/// <summary>保存Module信息</summary>
public abstract int Save(int ID, int SiteIdx, string ModuleName, string Version, string Author, string Owner, string Copyright, DateTime AvailDate);
/// <summary>添加Module信息</summary>
public abstract int Add(int SiteIdx, string ModuleName, string Version, string Author, string Owner, string Copyright, DateTime AvailDate);
/// <summary>修改Module信息</summary>
public abstract int Edit(int ID, int SiteIdx, string ModuleName, string Version, string Author, string Owner, string Copyright, DateTime AvailDate);
/// <summary>编辑模块说明信息</summary>
public abstract int EditNote(int ID, string Note);
/// <summary>编辑创建SQL信息</summary>
public abstract int EditInitSQL(int ID, string InitSQL);
/// <summary>编辑删除SQL信息</summary>
public abstract int EditDelSQL(int ID, string DelSQL);
/// <summary>根据PK_Module删除Module信息</summary>
public abstract int Del(int ID);
/// <summary>根据FK_MODULE_REF_SITE删除Module信息</summary>
public abstract int DelSite(int SiteIdx);
#endregion
}
}
#endregion

namespace VonPortal.Web.Models.ModuleInfo 数据表对应的结构信息

namespace VonPortal.Web.Operators.ModuleCtrl 表结构的对应的操作及控制，包含查询、添加等功能

namespace VonPortal.Web.tasks.ModuleTask 表结构的对应的异步操作类功能

namespace VonPortal.Web.Data.ModuleDataProvider 表结构的数据库访问接口，具体实现大家可能根据自己的数据库来具体实现。

下面是模块文件表结构信息类和模块功能注册信息类结构，这里只给出代码就不在详述了。

//模块文件（PTL_ModuleFile）
#region "模块文件信息类声明"
namespace VonPortal.Web.Models
{
/// <summary>模块文件 信息类</summary>
public class ModuleFileInfo
{
#region "Constructors"
/// <summary>
/// 构造函数
/// </summary>
public ModuleFileInfo()
{
}
/// <summary>
/// 含初始化构造函数
/// </summary>
/// <param name="ID">序号</param>
/// <param name="ModuleIdx">模块序号</param>
/// <param name="Filename">文件名称</param>
/// <param name="FileExt">文件类型</param>
/// <param name="FilePath">存放位置</param>
public ModuleFileInfo(int ID, int ModuleIdx, string Filename, string FileExt, string FilePath)
{
this.ID = ID;
this.ModuleIdx = ModuleIdx;
this.Filename = Filename;
this.FileExt = FileExt;
this.FilePath = FilePath;
}
#endregion
#region "Public Properties"
/// <summary>序号</summary>
[Required]
[Display(Name = "序号")]
public int ID { get; set; }
/// <summary>模块序号</summary>
[Required]
[Display(Name = "模块序号")]
public int ModuleIdx { get; set; }
/// <summary>文件名称</summary>
[Display(Name = "文件名称")]
public string Filename { get; set; }
/// <summary>文件类型</summary>
[Display(Name = "文件类型")]
public string FileExt { get; set; }
/// <summary>存放位置</summary>
[Display(Name = "存放位置")]
public string FilePath { get; set; }
#endregion
}
}
#endregion
#region "模块文件信息基础控制类声明"
namespace VonPortal.Web.Operators
{
/// <summary>模块文件 控制类</summary>
public class ModuleFileCtrl
{
private ModuleFileDataProvider dataProvider = null;
/// <summary>启动数据库事务</summary>
public IDbTransaction BeginTrans()
{
dataProvider = ModuleFileDataProvider.CreateProvider();
return dataProvider.DBBeginTrans();
}
/// <summary>含数据库事务的构造函数</summary>
public ModuleFileCtrl(IDbTransaction DBTrans)
{
if (DBTrans == null)
dataProvider = ModuleFileDataProvider.Instance();
else
{
dataProvider = ModuleFileDataProvider.CreateProvider();
dataProvider.DBTrans = DBTrans;
}
}
//Read data and write to ModuleFileInfo class
private void setInfoValue(IDataReader reader, ModuleFileInfo info)
{
info.ID = reader.GetInt32(0);  //序号
info.ModuleIdx = reader.GetInt32(1);  //模块序号
info.Filename = reader.GetString(2);  //文件名称
info.FileExt = reader.GetString(3);  //文件类型
info.FilePath = reader.GetString(4);  //存放位置
}
/// <summary>检验ModuleFile信息</summary>
public string Check(ModuleFileInfo info)
{
string errInfo = "";
return errInfo;
}
/// <summary>
/// 根据主键 PK_ModuleFile 提取信息
/// </summary>
/// <param name="ID">序号</param>
public ModuleFileInfo GetByModuleFile(int ID)
{
IDataReader reader = dataProvider.GetByModuleFile(ID);
if (!reader.Read())
{
reader.Close();
return null;
}
ModuleFileInfo info = new ModuleFileInfo();
setInfoValue(reader, info);
reader.Close();
return info;
}
/// <summary>根据主键 IDX_ModuleFile 提取信息</summary>
/// <param name="ModuleIdx">模块序号</param>
public List<ModuleFileInfo> ListByModuleFile(int ModuleIdx)
{
List<ModuleFileInfo> list = new List<ModuleFileInfo>();
IDataReader reader = dataProvider.ListByModuleFile(ModuleIdx);
while (reader.Read())
{
ModuleFileInfo info = new ModuleFileInfo();
setInfoValue(reader, info);
list.Add(info);
}
reader.Close();
return list;
}
/// <summary>保存ModuleFile信息</summary>
///<param name="info">信息类</param>
public bool Save(ModuleFileInfo info)
{
info.ID = dataProvider.Save(info.ID, info.ModuleIdx, info.Filename, info.FileExt, info.FilePath);
return info.ID > 0;
}
/// <summary>添加ModuleFile信息</summary>
///<param name="info">信息类</param>
public int Add(ModuleFileInfo info)
{
info.ID = dataProvider.Add(info.ModuleIdx, info.Filename, info.FileExt, info.FilePath);
return info.ID;
}
/// <summary>修改ModuleFile信息</summary>
///<param name="info">信息类</param>
public bool Edit(ModuleFileInfo info)
{
return dataProvider.Edit(info.ID, info.ModuleIdx, info.Filename, info.FileExt, info.FilePath) > 0;
}
/// <summary>根据PK_ModuleFile删除ModuleFile信息</summary>
/// <param name="ID">序号</param>
public int Del(int ID)
{
return dataProvider.Del(ID);
}
/// <summary>根据FK_FILE_REF_MODULE删除ModuleFile信息</summary>
///<param name="ModuleIdx">模块序号</param>
public int DelModule(int ModuleIdx)
{
return dataProvider.Del(ModuleIdx);
}

}
}
#endregion
#region "模块文件信息操作控制类声明"
namespace VonPortal.Web.Tasks
{
/// <summary>模块文件 控制类</summary>
public class ModuleFileTask : ModuleFileCtrl
{
/// <summary>含数据库事务的构造函数</summary>
public ModuleFileTask(IDbTransaction DBTrans) : base(DBTrans)
{
}
/// <summary>
/// 根据主键 PK_ModuleFile 提取信息
/// </summary>
/// <param name="ID">序号</param>
public new Task<ModuleFileInfo> GetByModuleFile(int ID)
{
return Task.Run(() =>
{
return base.GetByModuleFile(ID);
});
}
/// <summary>根据主键 IDX_ModuleFile 提取信息</summary>
/// <param name="ModuleIdx">模块序号</param>
public new Task<List<ModuleFileInfo>> ListByModuleFile(int ModuleIdx)
{
return Task.Run(() =>
{
return base.ListByModuleFile(ModuleIdx);
});
}
/// <summary>保存ModuleFile信息</summary>
///<param name="info">信息类</param>
public new Task<bool> Save(ModuleFileInfo info)
{
return Task.Run(() =>
{
return base.Save(info);
});
}
/// <summary>添加ModuleFile信息</summary>
///<param name="info">信息类</param>
public new Task<int> Add(ModuleFileInfo info)
{
return Task.Run(() =>
{
return base.Add(info);
});
}
/// <summary>修改ModuleFile信息</summary>
///<param name="info">信息类</param>
public new Task<bool> Edit(ModuleFileInfo info)
{
return Task.Run(() =>
{
return base.Edit(info);
});
}
/// <summary>根据PK_ModuleFile删除ModuleFile信息</summary>
/// <param name="ID">序号</param>
public new Task<int> Del(int ID)
{
return Task.Run(() =>
{
return base.Del(ID);
});
}
/// <summary>根据FK_FILE_REF_MODULE删除ModuleFile信息</summary>
///<param name="ModuleIdx">模块序号</param>
public new Task<int> DelModule(int ModuleIdx)
{
return Task.Run(() =>
{
return base.Del(ModuleIdx);
});
}

}
}
#endregion
#region "模块文件信息数据库访问基类声明"
namespace VonPortal.Web.Data
{
/// <summary>
/// 数据及操作控制层
/// <seealso cref="VonPortal.Web.Business.ModuleFileInfo"/>
/// <seealso cref="VonPortal.Web.Business.ModuleFileCtrl"/>
/// </summary>
public abstract class ModuleFileDataProvider : DataProvider
{
#region Shared/Static Methods
// singleton reference to the instantiated object
private static ModuleFileDataProvider objProvider = null;
/// <summary>
/// constructor
/// </summary>
static ModuleFileDataProvider()
{
objProvider = CreateProvider();
}
/// <summary>
/// dynamically create provider
/// </summary>
/// <returns>return the provider</returns>
public static ModuleFileDataProvider CreateProvider()
{
return (ModuleFileDataProvider)VonPortal.Web.Reflection.CreateDataProvider("ptl", "VonPortal", "VonPortal.Web.Data.ModuleFileDataProvider");
}
/// <summary>
/// The instance of ModuleFileDataProvider.
/// </summary>
/// <returns>return the provider</returns>
public static ModuleFileDataProvider Instance()
{
if (objProvider == null) objProvider = CreateProvider();
return objProvider;
}
#endregion

#region "ModuleFile Abstract Methods"
/// <summary>根据主键 PK_ModuleFile 提取信息</summary>
public abstract IDataReader GetByModuleFile(int ID);
/// <summary>根据主键 IDX_ModuleFile 提取信息</summary>
public abstract IDataReader ListByModuleFile(int ModuleIdx);
/// <summary>保存ModuleFile信息</summary>
public abstract int Save(int ID, int ModuleIdx, string Filename, string FileExt, string FilePath);
/// <summary>添加ModuleFile信息</summary>
public abstract int Add(int ModuleIdx, string Filename, string FileExt, string FilePath);
/// <summary>修改ModuleFile信息</summary>
public abstract int Edit(int ID, int ModuleIdx, string Filename, string FileExt, string FilePath);
/// <summary>根据PK_ModuleFile删除ModuleFile信息</summary>
public abstract int Del(int ID);
/// <summary>根据FK_FILE_REF_MODULE删除ModuleFile信息</summary>
public abstract int DelModule(int ModuleIdx);
#endregion
}
}
#endregion
//模块功能（PTL_Action）
#region "模块功能信息类声明"
namespace VonPortal.Web.Models
{
/// <summary>模块功能 信息类</summary>
public class ActionInfo
{
#region "Constructors"
/// <summary>
/// 构造函数
/// </summary>
public ActionInfo()
{
}
/// <summary>
/// 含初始化构造函数
/// </summary>
/// <param name="ActionName">功能名称</param>
/// <param name="ModuleIdx">所属模块</param>
/// <param name="Kind">类型</param>
public ActionInfo(string ActionName, int ModuleIdx, int Kind)
{
this.ActionName = ActionName;
this.ModuleIdx = ModuleIdx;
this.Kind = Kind;
}
#endregion
#region "Public Properties"
/// <summary>功能名称</summary>
[Required]
[Display(Name = "功能名称")]
public string ActionName { get; set; }
/// <summary>所属模块</summary>
[Required]
[Display(Name = "所属模块")]
public int ModuleIdx { get; set; }
/// <summary>类型</summary>
[Display(Name = "类型")]
public int Kind { get; set; }
#endregion
}
}
#endregion
#region "模块功能信息基础控制类声明"
namespace VonPortal.Web.Operators
{
/// <summary>模块功能 控制类</summary>
public class ActionCtrl
{
private ActionDataProvider dataProvider = null;
/// <summary>启动数据库事务</summary>
public IDbTransaction BeginTrans()
{
dataProvider = ActionDataProvider.CreateProvider();
return dataProvider.DBBeginTrans();
}
/// <summary>含数据库事务的构造函数</summary>
public ActionCtrl(IDbTransaction DBTrans)
{
if (DBTrans == null)
dataProvider = ActionDataProvider.Instance();
else
{
dataProvider = ActionDataProvider.CreateProvider();
dataProvider.DBTrans = DBTrans;
}
}
//Read data and write to ActionInfo class
private void setInfoValue(IDataReader reader, ActionInfo info)
{
info.ActionName = reader.GetString(0);  //功能名称
info.ModuleIdx = reader.GetInt32(1);  //所属模块
info.Kind = reader.GetInt32(2);  //类型
}
/// <summary>检验Action信息</summary>
public string Check(ActionInfo info)
{
string errInfo = "";
if (info.ActionName == "") errInfo += " 功能名称内容不符合系统要求，不能存储。";
return errInfo;
}
/// <summary>
/// 根据主键 PK_Action 提取信息
/// </summary>
/// <param name="ActionName">功能名称</param>
public ActionInfo GetByAction(string ActionName)
{
IDataReader reader = dataProvider.GetByAction(ActionName);
if (!reader.Read())
{
reader.Close();
return null;
}
ActionInfo info = new ActionInfo();
setInfoValue(reader, info);
reader.Close();
return info;
}
/// <summary>得到功能简介信息</summary>
///<param name="ID">序号</param>
///<param name="Description">功能简介</param>
public string GetDescription(string ActionName)
{
return dataProvider.GetDescription(ActionName);
}
/// <summary>编辑功能简介信息</summary>
///<param name="ID">序号</param>
///<param name="Description">功能简介</param>
public bool SetDescription(string ActionName, string Description)
{
return dataProvider.SetDescription(ActionName, Description) > 0;
}
/// <summary>根据外键 FK_ACTION_REF_MODULE 提取信息</summary>
public List<ActionInfo> ListByACTION_REF_MODULE(int ModuleIdx)
{
List<ActionInfo> list = new List<ActionInfo>();
IDataReader reader = dataProvider.ListByACTION_REF_MODULE(ModuleIdx);
while (reader.Read())
{
ActionInfo info = new ActionInfo();
setInfoValue(reader, info);
list.Add(info);
}
reader.Close();
return list;
}
/// <summary>保存Action信息</summary>
///<param name="info">信息类</param>
public void Save(ActionInfo info)
{
dataProvider.Save(info.ActionName, info.ModuleIdx, info.Kind);
}
/// <summary>添加Action信息</summary>
///<param name="info">信息类</param>
public void Add(ActionInfo info)
{
dataProvider.Add(info.ActionName, info.ModuleIdx, info.Kind);
}
/// <summary>修改Action信息</summary>
///<param name="info">信息类</param>
public void Edit(ActionInfo info)
{
dataProvider.Edit(info.ActionName, info.ModuleIdx, info.Kind);
}
/// <summary>根据PK_Action删除Action信息</summary>
/// <param name="ActionName">功能名称</param>
public void Del(string ActionName)
{
dataProvider.Del(ActionName);
}
/// <summary>根据FK_ACTION_REF_MODULE删除Action信息</summary>
///<param name="ModuleIdx">所属模块</param>
public void DelModule(int ModuleIdx)
{
dataProvider.DelModule(ModuleIdx);
}

}
}
#endregion
#region "模块功能信息操作控制类声明"
namespace VonPortal.Web.Tasks
{
/// <summary>模块功能 控制类</summary>
public class ActionTask : ActionCtrl
{
/// <summary>含数据库事务的构造函数</summary>
public ActionTask(IDbTransaction DBTrans) : base(DBTrans)
{
}
/// <summary>
/// 根据主键 PK_Action 提取信息
/// </summary>
/// <param name="ActionName">功能名称</param>
public new Task<ActionInfo> GetByAction(string ActionName)
{
return Task.Run(() =>
{
return base.GetByAction(ActionName);
});
}
/// <summary>得到功能简介信息</summary>
///<param name="ID">序号</param>
///<param name="Description">功能简介</param>
public new Task<string> GetDescription(string ActionName)
{
return Task.Run(() =>
{
return base.GetDescription(ActionName);
});
}
/// <summary>编辑功能简介信息</summary>
///<param name="ID">序号</param>
///<param name="Description">功能简介</param>
public new Task<bool> SetDescription(string ActionName, string Description)
{
return Task.Run(() =>
{
return base.SetDescription(ActionName, Description);
});
}
/// <summary>根据外键 FK_ACTION_REF_MODULE 提取信息</summary>
public new Task<List<ActionInfo>> ListByACTION_REF_MODULE(int ModuleIdx)
{
return Task.Run(() =>
{
return base.ListByACTION_REF_MODULE(ModuleIdx);
});
}
/// <summary>保存Action信息</summary>
///<param name="info">信息类</param>
public new Task Save(ActionInfo info)
{
return Task.Run(() =>
{
base.Save(info);
});
}
/// <summary>添加Action信息</summary>
///<param name="info">信息类</param>
public new Task Add(ActionInfo info)
{
return Task.Run(() =>
{
base.Add(info);
});
}
/// <summary>修改Action信息</summary>
///<param name="info">信息类</param>
public new Task Edit(ActionInfo info)
{
return Task.Run(() =>
{
base.Edit(info);
});
}
/// <summary>根据PK_Action删除Action信息</summary>
/// <param name="ActionName">功能名称</param>
public new Task Del(string ActionName)
{
return Task.Run(() =>
{
base.Del(ActionName);
});
}
/// <summary>根据FK_ACTION_REF_MODULE删除Action信息</summary>
///<param name="ModuleIdx">所属模块</param>
public new Task DelModule(int ModuleIdx)
{
return Task.Run(() =>
{
base.DelModule(ModuleIdx);
});
}

}
}
#endregion
#region "模块功能信息数据库访问基类声明"
namespace VonPortal.Web.Data
{
/// <summary>
/// 数据及操作控制层
/// <seealso cref="VonPortal.Web.Business.ActionInfo"/>
/// <seealso cref="VonPortal.Web.Business.ActionCtrl"/>
/// </summary>
public abstract class ActionDataProvider : DataProvider
{
#region Shared/Static Methods
// singleton reference to the instantiated object
private static ActionDataProvider objProvider = null;
/// <summary>
/// constructor
/// </summary>
static ActionDataProvider()
{
objProvider = CreateProvider();
}
/// <summary>
/// dynamically create provider
/// </summary>
/// <returns>return the provider</returns>
public static ActionDataProvider CreateProvider()
{
return (ActionDataProvider)VonPortal.Web.Reflection.CreateDataProvider("ptl", "VonPortal", "VonPortal.Web.Data.ActionDataProvider");
}
/// <summary>
/// The instance of ActionDataProvider.
/// </summary>
/// <returns>return the provider</returns>
public static ActionDataProvider Instance()
{
if (objProvider == null) objProvider = CreateProvider();
return objProvider;
}
#endregion

#region "Action Abstract Methods"
/// <summary>根据主键 PK_Action 提取信息</summary>
public abstract IDataReader GetByAction(string ActionName);
/// <summary>编辑功能简介信息</summary>
///<param name="int ID>序号</param>
public abstract string GetDescription(string ActionName);
/// <summary>编辑功能简介信息</summary>
public abstract int SetDescription(string ActionName, string Description);
/// <summary>根据外键 FK_ACTION_REF_MODULE 提取信息</summary>
public abstract IDataReader ListByACTION_REF_MODULE(int ModuleIdx);
/// <summary>保存Action信息</summary>
public abstract void Save(string ActionName, int ModuleIdx, int Kind);
/// <summary>添加Action信息</summary>
public abstract void Add(string ActionName, int ModuleIdx, int Kind);
/// <summary>修改Action信息</summary>
public abstract void Edit(string ActionName, int ModuleIdx, int Kind);
/// <summary>根据PK_Action删除Action信息</summary>
public abstract void Del(string ActionName);
/// <summary>根据FK_ACTION_REF_MODULE删除Action信息</summary>
public abstract void DelModule(int ModuleIdx);
#endregion
}
}
#endregion

下面我们将一步一步实现模块中文件列表的实现，文件上传功能的实现，文件删除功能的实现做出讲解，然后我们再对功能注册信息部分进行讲解。