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

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

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

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

//模块信息（PTL_Module）
#region"模块信息信息类声明"
namespaceVonPortal.Web.Models
{
///<summary>模块信息信息类</summary>
publicclassModuleInfo
{
#region"PublicProperties"
///<summary>序号</summary>
[Required]
[Display(Name="序号")]
publicintID{get;set;}
///<summary>网站序号</summary>
[Required]
[Display(Name="网站序号")]
publicintSiteIdx{get;set;}
///<summary>模块名称</summary>
[Display(Name="模块名称")]
publicstringModuleName{get;set;}
///<summary>版本信息</summary>
[Display(Name="版本信息")]
publicstringVersion{get;set;}
///<summary>作者</summary>
[Display(Name="作者")]
publicstringAuthor{get;set;}
///<summary>版权所有</summary>
[Display(Name="版权所有")]
publicstringOwner{get;set;}
///<summary>版权说明</summary>
[Display(Name="版权说明")]
publicstringCopyright{get;set;}
///<summary>有效期</summary>
[Display(Name="有效期")]
publicDateTimeAvailDate{get;set;}
#endregion
}
}
#endregion
#region"模块信息信息基础控制类声明"
namespaceVonPortal.Web.Operators
{
///<summary>模块信息控制类</summary>
publicclassModuleCtrl
{
privateModuleDataProviderdataProvider=null;
publicIDbTransactionBeginTrans()
{
dataProvider=ModuleDataProvider.CreateProvider();
returndataProvider.DBBeginTrans();
}
publicModuleCtrl(IDbTransactionDBTrans)
{
if(DBTrans==null)
dataProvider=ModuleDataProvider.Instance();
else
{
dataProvider=ModuleDataProvider.CreateProvider();
dataProvider.DBTrans=DBTrans;
}
}
//ReaddataandwritetoModuleInfoclass
privatevoidsetInfoValue(IDataReaderreader,ModuleInfoinfo)
{
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>
publicstringCheck(ModuleInfoinfo)
{
stringerrInfo="";
returnerrInfo;
}
///<summary>
///根据主键PK_Module提取信息
///</summary>
///<paramname="intID>序号</param>
publicModuleInfoGetByModule(intID)
{
IDataReaderreader=dataProvider.GetByModule(ID);
if(!reader.Read())
{
reader.Close();
returnnull;
}
ModuleInfoinfo=newModuleInfo();
setInfoValue(reader,info);
reader.Close();
returninfo;
}
///<summary>得到模块说明信息</summary>
///<paramname="intID>序号</param>
///<paramname="VonKeyValueCollectionNote">模块说明</param>
publicstringGetNote(intID)
{
returndataProvider.GetNote(ID);
}
///<summary>得到创建SQL信息</summary>
///<paramname="intID>序号</param>
///<paramname="VonKeyValueCollectionInitSQL">创建SQL</param>
publicstringGetInitSQL(intID)
{
returndataProvider.GetInitSQL(ID);
}
///<summary>得到删除SQL信息</summary>
///<paramname="intID>序号</param>
///<paramname="VonKeyValueCollectionDelSQL">删除SQL</param>
publicstringGetDelSQL(intID)
{
returndataProvider.GetDelSQL(ID);
}
///<summary>根据外键FK_MODULE_REF_SITE提取信息</summary>
publicList<ModuleInfo>ListByMODULE_REF_SITE(intSiteIdx,boolIncludePortal)
{
List<ModuleInfo>list=newList<ModuleInfo>();
IDataReaderreader=dataProvider.ListByMODULE_REF_SITE(SiteIdx,IncludePortal);
while(reader.Read())
{
ModuleInfoinfo=newModuleInfo();
setInfoValue(reader,info);
list.Add(info);
}
reader.Close();
returnlist;
}
///<summary>保存Module信息</summary>
///<paramname="TModuleInfoinfo">信息类</param>
publicboolSave(ModuleInfoinfo)
{
info.ID=dataProvider.Save(info.ID,info.SiteIdx,info.ModuleName,info.Version,info.Author,info.Owner,info.Copyright,info.AvailDate);
returninfo.ID>0;
}
///<summary>添加Module信息</summary>
///<paramname="TModuleInfoinfo">信息类</param>
publicintAdd(ModuleInfoinfo)
{
info.ID=dataProvider.Add(info.SiteIdx,info.AvailDate);
returninfo.ID;
}
///<summary>修改Module信息</summary>
///<paramname="TModuleInfoinfo">信息类</param>
publicboolEdit(ModuleInfoinfo)
{
returndataProvider.Edit(info.ID,info.AvailDate)>0;
}
///<summary>编辑模块说明信息</summary>
///<paramname="intID>序号</param>
///<paramname="VonKeyValueCollectionNote">模块说明</param>
publicboolSetNote(intID,stringNote)
{
returndataProvider.EditNote(ID,Note)>0;
}
///<summary>编辑创建SQL信息</summary>
///<paramname="intID>序号</param>
///<paramname="VonKeyValueCollectionInitSQL">创建SQL</param>
publicboolSetInitSQL(intID,stringInitSQL)
{
returndataProvider.EditInitSQL(ID,InitSQL)>0;
}
///<summary>编辑删除SQL信息</summary>
///<paramname="intID>序号</param>
///<paramname="VonKeyValueCollectionDelSQL">删除SQL</param>
publicboolSetDelSQL(intID,stringDelSQL)
{
returndataProvider.EditDelSQL(ID,DelSQL)>0;
}
///<summary>根据PK_Module删除Module信息</summary>
///<paramname="intID>序号</param>
publicintDel(intID)
{
returndataProvider.Del(ID);
}
///<summary>根据FK_MODULE_REF_SITE删除Module信息</summary>
///<paramname="intSiteIdx">网站序号</param>
publicintDelSite(intSiteIdx)
{
returndataProvider.Del(SiteIdx);
}

}
}
#endregion
#region"模块信息信息操作控制类声明"
namespaceVonPortal.Web.Tasks
{
///<summary>模块信息控制类</summary>
publicclassModuleTask:ModuleCtrl
{
///<summary>含数据库事务的构造函数</summary>
publicModuleTask(IDbTransactionDBTrans):base(DBTrans)
{
}
///<summary>
///根据主键PK_Module提取信息
///</summary>
///<paramname="ID">序号</param>
publicnewTask<ModuleInfo>GetByModule(intID)
{
returnTask.Run(()=>
{
returnbase.GetByModule(ID);
});
}
///<summary>得到模块说明信息</summary>
///<paramname="ID">序号</param>
///<paramname="Note">模块说明</param>
publicnewTask<string>GetNote(intID)
{
returnTask.Run(()=>
{
returnbase.GetNote(ID);
});
}
///<summary>编辑模块说明信息</summary>
///<paramname="ID">序号</param>
///<paramname="Note">模块说明</param>
publicnewTask<bool>SetNote(intID,stringNote)
{
returnTask.Run(()=>
{
returnbase.SetNote(ID,Note);
});
}
///<summary>得到创建SQL信息</summary>
///<paramname="ID">序号</param>
///<paramname="InitSQL">创建SQL</param>
publicnewTask<string>GetInitSQL(intID)
{
returnTask.Run(()=>
{
returnbase.GetInitSQL(ID);
});
}
///<summary>编辑创建SQL信息</summary>
///<paramname="ID">序号</param>
///<paramname="InitSQL">创建SQL</param>
publicnewTask<bool>SetInitSQL(intID,stringInitSQL)
{
returnTask.Run(()=>
{
returnbase.SetInitSQL(ID,InitSQL);
});
}
///<summary>得到删除SQL信息</summary>
///<paramname="ID">序号</param>
///<paramname="DelSQL">删除SQL</param>
publicnewTask<string>GetDelSQL(intID)
{
returnTask.Run(()=>
{
returnbase.GetDelSQL(ID);
});
}
///<summary>编辑删除SQL信息</summary>
///<paramname="ID">序号</param>
///<paramname="DelSQL">删除SQL</param>
publicnewTask<bool>SetDelSQL(intID,stringDelSQL)
{
returnTask.Run(()=>
{
returnbase.SetDelSQL(ID,DelSQL);
});
}
///<summary>根据外键FK_MODULE_REF_SITE提取信息</summary>
publicnewTask<List<ModuleInfo>>ListByMODULE_REF_SITE(intSiteIdx,boolIncludePortal)
{
returnTask.Run(()=>
{
returnbase.ListByMODULE_REF_SITE(SiteIdx,IncludePortal);
});
}
///<summary>保存Module信息</summary>
///<paramname="info">信息类</param>
publicnewTask<bool>Save(ModuleInfoinfo)
{
returnTask.Run(()=>
{
returnbase.Save(info);
});
}
///<summary>添加Module信息</summary>
///<paramname="info">信息类</param>
publicnewTask<int>Add(ModuleInfoinfo)
{
returnTask.Run(()=>
{
returnbase.Add(info);
});
}
///<summary>修改Module信息</summary>
///<paramname="info">信息类</param>
publicnewTask<bool>Edit(ModuleInfoinfo)
{
returnTask.Run(()=>
{
returnbase.Edit(info);
});
}
///<summary>根据PK_Module删除Module信息</summary>
///<paramname="ID">序号</param>
publicnewTask<int>Del(intID)
{
returnTask.Run(()=>
{
returnbase.Del(ID);
});
}
///<summary>根据FK_MODULE_REF_SITE删除Module信息</summary>
///<paramname="SiteIdx">网站序号</param>
publicnewTask<int>DelSite(intSiteIdx)
{
returnTask.Run(()=>
{
returnbase.Del(SiteIdx);
});
}

}
}
#endregion
#region"模块信息信息数据库访问基类声明"
namespaceVonPortal.Web.Data
{
///<summary>
///数据及操作控制层
///<seealsocref="VonPortal.Web.Business.ModuleInfo"/>
///<seealsocref="VonPortal.Web.Business.ModuleCtrl"/>
///</summary>
publicabstractclassModuleDataProvider:DataProvider
{
#regionShared/StaticMethods
//singletonreferencetotheinstantiatedobject
privatestaticModuleDataProviderobjProvider=null;

//constructor
staticModuleDataProvider()
{
objProvider=CreateProvider();
}

//dynamicallycreateprovider
publicstaticModuleDataProviderCreateProvider()
{
return(ModuleDataProvider)VonPortal.Web.Reflection.CreateDataProvider("ptl","VonPortal","VonPortal.Web.Data.ModuleDataProvider");
}
///<summary>
///TheinstanceofModuleDataProviderwithdatabsetransaction.
///</summary>
///<paramname="DBTransaction">数据库事物变量，如果为空则表明是事务性调用，则使用静态对象</param>
///<returns>returntheprovider</returns>
publicstaticModuleDataProviderInstance()
{
if(objProvider==null)objProvider=CreateProvider();
returnobjProvider;
}
#endregion

#region"TModuleAbstractMethods"
///<summary>根据主键PK_Module提取信息</summary>
publicabstractIDataReaderGetByModule(intID);
///<summary>编辑模块说明信息</summary>
///<paramname="intID>序号</param>
publicabstractstringGetNote(intID);
///<summary>编辑创建SQL信息</summary>
///<paramname="intID>序号</param>
publicabstractstringGetInitSQL(intID);
///<summary>编辑删除SQL信息</summary>
///<paramname="intID>序号</param>
publicabstractstringGetDelSQL(intID);
///<summary>根据外键FK_MODULE_REF_SITE提取信息</summary>
publicabstractIDataReaderListByMODULE_REF_SITE(intSiteIdx,boolIncludePortal);
///<summary>保存Module信息</summary>
publicabstractintSave(intID,intSiteIdx,stringModuleName,stringVersion,stringAuthor,stringOwner,stringCopyright,DateTimeAvailDate);
///<summary>添加Module信息</summary>
publicabstractintAdd(intSiteIdx,DateTimeAvailDate);
///<summary>修改Module信息</summary>
publicabstractintEdit(intID,DateTimeAvailDate);
///<summary>编辑模块说明信息</summary>
publicabstractintEditNote(intID,stringNote);
///<summary>编辑创建SQL信息</summary>
publicabstractintEditInitSQL(intID,stringInitSQL);
///<summary>编辑删除SQL信息</summary>
publicabstractintEditDelSQL(intID,stringDelSQL);
///<summary>根据PK_Module删除Module信息</summary>
publicabstractintDel(intID);
///<summary>根据FK_MODULE_REF_SITE删除Module信息</summary>
publicabstractintDelSite(intSiteIdx);
#endregion
}
}
#endregion

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

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

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

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

//模块文件（PTL_ModuleFile）
#region"模块文件信息类声明"
namespaceVonPortal.Web.Models
{
///<summary>模块文件信息类</summary>
publicclassModuleFileInfo
{
#region"Constructors"
///<summary>
///构造函数
///</summary>
publicModuleFileInfo()
{
}
///<summary>
///含初始化构造函数
///</summary>
///<paramname="ID">序号</param>
///<paramname="ModuleIdx">模块序号</param>
///<paramname="Filename">文件名称</param>
///<paramname="FileExt">文件类型</param>
///<paramname="FilePath">存放位置</param>
publicModuleFileInfo(intID,intModuleIdx,stringFilename,stringFileExt,stringFilePath)
{
this.ID=ID;
this.ModuleIdx=ModuleIdx;
this.Filename=Filename;
this.FileExt=FileExt;
this.FilePath=FilePath;
}
#endregion
#region"PublicProperties"
///<summary>序号</summary>
[Required]
[Display(Name="序号")]
publicintID{get;set;}
///<summary>模块序号</summary>
[Required]
[Display(Name="模块序号")]
publicintModuleIdx{get;set;}
///<summary>文件名称</summary>
[Display(Name="文件名称")]
publicstringFilename{get;set;}
///<summary>文件类型</summary>
[Display(Name="文件类型")]
publicstringFileExt{get;set;}
///<summary>存放位置</summary>
[Display(Name="存放位置")]
publicstringFilePath{get;set;}
#endregion
}
}
#endregion
#region"模块文件信息基础控制类声明"
namespaceVonPortal.Web.Operators
{
///<summary>模块文件控制类</summary>
publicclassModuleFileCtrl
{
privateModuleFileDataProviderdataProvider=null;
///<summary>启动数据库事务</summary>
publicIDbTransactionBeginTrans()
{
dataProvider=ModuleFileDataProvider.CreateProvider();
returndataProvider.DBBeginTrans();
}
///<summary>含数据库事务的构造函数</summary>
publicModuleFileCtrl(IDbTransactionDBTrans)
{
if(DBTrans==null)
dataProvider=ModuleFileDataProvider.Instance();
else
{
dataProvider=ModuleFileDataProvider.CreateProvider();
dataProvider.DBTrans=DBTrans;
}
}
//ReaddataandwritetoModuleFileInfoclass
privatevoidsetInfoValue(IDataReaderreader,ModuleFileInfoinfo)
{
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>
publicstringCheck(ModuleFileInfoinfo)
{
stringerrInfo="";
returnerrInfo;
}
///<summary>
///根据主键PK_ModuleFile提取信息
///</summary>
///<paramname="ID">序号</param>
publicModuleFileInfoGetByModuleFile(intID)
{
IDataReaderreader=dataProvider.GetByModuleFile(ID);
if(!reader.Read())
{
reader.Close();
returnnull;
}
ModuleFileInfoinfo=newModuleFileInfo();
setInfoValue(reader,info);
reader.Close();
returninfo;
}
///<summary>根据主键IDX_ModuleFile提取信息</summary>
///<paramname="ModuleIdx">模块序号</param>
publicList<ModuleFileInfo>ListByModuleFile(intModuleIdx)
{
List<ModuleFileInfo>list=newList<ModuleFileInfo>();
IDataReaderreader=dataProvider.ListByModuleFile(ModuleIdx);
while(reader.Read())
{
ModuleFileInfoinfo=newModuleFileInfo();
setInfoValue(reader,info);
list.Add(info);
}
reader.Close();
returnlist;
}
///<summary>保存ModuleFile信息</summary>
///<paramname="info">信息类</param>
publicboolSave(ModuleFileInfoinfo)
{
info.ID=dataProvider.Save(info.ID,info.ModuleIdx,info.Filename,info.FileExt,info.FilePath);
returninfo.ID>0;
}
///<summary>添加ModuleFile信息</summary>
///<paramname="info">信息类</param>
publicintAdd(ModuleFileInfoinfo)
{
info.ID=dataProvider.Add(info.ModuleIdx,info.FilePath);
returninfo.ID;
}
///<summary>修改ModuleFile信息</summary>
///<paramname="info">信息类</param>
publicboolEdit(ModuleFileInfoinfo)
{
returndataProvider.Edit(info.ID,info.FilePath)>0;
}
///<summary>根据PK_ModuleFile删除ModuleFile信息</summary>
///<paramname="ID">序号</param>
publicintDel(intID)
{
returndataProvider.Del(ID);
}
///<summary>根据FK_FILE_REF_MODULE删除ModuleFile信息</summary>
///<paramname="ModuleIdx">模块序号</param>
publicintDelModule(intModuleIdx)
{
returndataProvider.Del(ModuleIdx);
}

}
}
#endregion
#region"模块文件信息操作控制类声明"
namespaceVonPortal.Web.Tasks
{
///<summary>模块文件控制类</summary>
publicclassModuleFileTask:ModuleFileCtrl
{
///<summary>含数据库事务的构造函数</summary>
publicModuleFileTask(IDbTransactionDBTrans):base(DBTrans)
{
}
///<summary>
///根据主键PK_ModuleFile提取信息
///</summary>
///<paramname="ID">序号</param>
publicnewTask<ModuleFileInfo>GetByModuleFile(intID)
{
returnTask.Run(()=>
{
returnbase.GetByModuleFile(ID);
});
}
///<summary>根据主键IDX_ModuleFile提取信息</summary>
///<paramname="ModuleIdx">模块序号</param>
publicnewTask<List<ModuleFileInfo>>ListByModuleFile(intModuleIdx)
{
returnTask.Run(()=>
{
returnbase.ListByModuleFile(ModuleIdx);
});
}
///<summary>保存ModuleFile信息</summary>
///<paramname="info">信息类</param>
publicnewTask<bool>Save(ModuleFileInfoinfo)
{
returnTask.Run(()=>
{
returnbase.Save(info);
});
}
///<summary>添加ModuleFile信息</summary>
///<paramname="info">信息类</param>
publicnewTask<int>Add(ModuleFileInfoinfo)
{
returnTask.Run(()=>
{
returnbase.Add(info);
});
}
///<summary>修改ModuleFile信息</summary>
///<paramname="info">信息类</param>
publicnewTask<bool>Edit(ModuleFileInfoinfo)
{
returnTask.Run(()=>
{
returnbase.Edit(info);
});
}
///<summary>根据PK_ModuleFile删除ModuleFile信息</summary>
///<paramname="ID">序号</param>
publicnewTask<int>Del(intID)
{
returnTask.Run(()=>
{
returnbase.Del(ID);
});
}
///<summary>根据FK_FILE_REF_MODULE删除ModuleFile信息</summary>
///<paramname="ModuleIdx">模块序号</param>
publicnewTask<int>DelModule(intModuleIdx)
{
returnTask.Run(()=>
{
returnbase.Del(ModuleIdx);
});
}

}
}
#endregion
#region"模块文件信息数据库访问基类声明"
namespaceVonPortal.Web.Data
{
///<summary>
///数据及操作控制层
///<seealsocref="VonPortal.Web.Business.ModuleFileInfo"/>
///<seealsocref="VonPortal.Web.Business.ModuleFileCtrl"/>
///</summary>
publicabstractclassModuleFileDataProvider:DataProvider
{
#regionShared/StaticMethods
//singletonreferencetotheinstantiatedobject
privatestaticModuleFileDataProviderobjProvider=null;
///<summary>
///constructor
///</summary>
staticModuleFileDataProvider()
{
objProvider=CreateProvider();
}
///<summary>
///dynamicallycreateprovider
///</summary>
///<returns>returntheprovider</returns>
publicstaticModuleFileDataProviderCreateProvider()
{
return(ModuleFileDataProvider)VonPortal.Web.Reflection.CreateDataProvider("ptl","VonPortal.Web.Data.ModuleFileDataProvider");
}
///<summary>
///TheinstanceofModuleFileDataProvider.
///</summary>
///<returns>returntheprovider</returns>
publicstaticModuleFileDataProviderInstance()
{
if(objProvider==null)objProvider=CreateProvider();
returnobjProvider;
}
#endregion

#region"ModuleFileAbstractMethods"
///<summary>根据主键PK_ModuleFile提取信息</summary>
publicabstractIDataReaderGetByModuleFile(intID);
///<summary>根据主键IDX_ModuleFile提取信息</summary>
publicabstractIDataReaderListByModuleFile(intModuleIdx);
///<summary>保存ModuleFile信息</summary>
publicabstractintSave(intID,stringFilePath);
///<summary>添加ModuleFile信息</summary>
publicabstractintAdd(intModuleIdx,stringFilePath);
///<summary>修改ModuleFile信息</summary>
publicabstractintEdit(intID,stringFilePath);
///<summary>根据PK_ModuleFile删除ModuleFile信息</summary>
publicabstractintDel(intID);
///<summary>根据FK_FILE_REF_MODULE删除ModuleFile信息</summary>
publicabstractintDelModule(intModuleIdx);
#endregion
}
}
#endregion
//模块功能（PTL_Action）
#region"模块功能信息类声明"
namespaceVonPortal.Web.Models
{
///<summary>模块功能信息类</summary>
publicclassActionInfo
{
#region"Constructors"
///<summary>
///构造函数
///</summary>
publicActionInfo()
{
}
///<summary>
///含初始化构造函数
///</summary>
///<paramname="ActionName">功能名称</param>
///<paramname="ModuleIdx">所属模块</param>
///<paramname="Kind">类型</param>
publicActionInfo(stringActionName,intKind)
{
this.ActionName=ActionName;
this.ModuleIdx=ModuleIdx;
this.Kind=Kind;
}
#endregion
#region"PublicProperties"
///<summary>功能名称</summary>
[Required]
[Display(Name="功能名称")]
publicstringActionName{get;set;}
///<summary>所属模块</summary>
[Required]
[Display(Name="所属模块")]
publicintModuleIdx{get;set;}
///<summary>类型</summary>
[Display(Name="类型")]
publicintKind{get;set;}
#endregion
}
}
#endregion
#region"模块功能信息基础控制类声明"
namespaceVonPortal.Web.Operators
{
///<summary>模块功能控制类</summary>
publicclassActionCtrl
{
privateActionDataProviderdataProvider=null;
///<summary>启动数据库事务</summary>
publicIDbTransactionBeginTrans()
{
dataProvider=ActionDataProvider.CreateProvider();
returndataProvider.DBBeginTrans();
}
///<summary>含数据库事务的构造函数</summary>
publicActionCtrl(IDbTransactionDBTrans)
{
if(DBTrans==null)
dataProvider=ActionDataProvider.Instance();
else
{
dataProvider=ActionDataProvider.CreateProvider();
dataProvider.DBTrans=DBTrans;
}
}
//ReaddataandwritetoActionInfoclass
privatevoidsetInfoValue(IDataReaderreader,ActionInfoinfo)
{
info.ActionName=reader.GetString(0);//功能名称
info.ModuleIdx=reader.GetInt32(1);//所属模块
info.Kind=reader.GetInt32(2);//类型
}
///<summary>检验Action信息</summary>
publicstringCheck(ActionInfoinfo)
{
stringerrInfo="";
if(info.ActionName=="")errInfo+="功能名称内容不符合系统要求，不能存储。";
returnerrInfo;
}
///<summary>
///根据主键PK_Action提取信息
///</summary>
///<paramname="ActionName">功能名称</param>
publicActionInfoGetByAction(stringActionName)
{
IDataReaderreader=dataProvider.GetByAction(ActionName);
if(!reader.Read())
{
reader.Close();
returnnull;
}
ActionInfoinfo=newActionInfo();
setInfoValue(reader,info);
reader.Close();
returninfo;
}
///<summary>得到功能简介信息</summary>
///<paramname="ID">序号</param>
///<paramname="Description">功能简介</param>
publicstringGetDescription(stringActionName)
{
returndataProvider.GetDescription(ActionName);
}
///<summary>编辑功能简介信息</summary>
///<paramname="ID">序号</param>
///<paramname="Description">功能简介</param>
publicboolSetDescription(stringActionName,stringDescription)
{
returndataProvider.SetDescription(ActionName,Description)>0;
}
///<summary>根据外键FK_ACTION_REF_MODULE提取信息</summary>
publicList<ActionInfo>ListByACTION_REF_MODULE(intModuleIdx)
{
List<ActionInfo>list=newList<ActionInfo>();
IDataReaderreader=dataProvider.ListByACTION_REF_MODULE(ModuleIdx);
while(reader.Read())
{
ActionInfoinfo=newActionInfo();
setInfoValue(reader,info);
list.Add(info);
}
reader.Close();
returnlist;
}
///<summary>保存Action信息</summary>
///<paramname="info">信息类</param>
publicvoidSave(ActionInfoinfo)
{
dataProvider.Save(info.ActionName,info.Kind);
}
///<summary>添加Action信息</summary>
///<paramname="info">信息类</param>
publicvoidAdd(ActionInfoinfo)
{
dataProvider.Add(info.ActionName,info.Kind);
}
///<summary>修改Action信息</summary>
///<paramname="info">信息类</param>
publicvoidEdit(ActionInfoinfo)
{
dataProvider.Edit(info.ActionName,info.Kind);
}
///<summary>根据PK_Action删除Action信息</summary>
///<paramname="ActionName">功能名称</param>
publicvoidDel(stringActionName)
{
dataProvider.Del(ActionName);
}
///<summary>根据FK_ACTION_REF_MODULE删除Action信息</summary>
///<paramname="ModuleIdx">所属模块</param>
publicvoidDelModule(intModuleIdx)
{
dataProvider.DelModule(ModuleIdx);
}

}
}
#endregion
#region"模块功能信息操作控制类声明"
namespaceVonPortal.Web.Tasks
{
///<summary>模块功能控制类</summary>
publicclassActionTask:ActionCtrl
{
///<summary>含数据库事务的构造函数</summary>
publicActionTask(IDbTransactionDBTrans):base(DBTrans)
{
}
///<summary>
///根据主键PK_Action提取信息
///</summary>
///<paramname="ActionName">功能名称</param>
publicnewTask<ActionInfo>GetByAction(stringActionName)
{
returnTask.Run(()=>
{
returnbase.GetByAction(ActionName);
});
}
///<summary>得到功能简介信息</summary>
///<paramname="ID">序号</param>
///<paramname="Description">功能简介</param>
publicnewTask<string>GetDescription(stringActionName)
{
returnTask.Run(()=>
{
returnbase.GetDescription(ActionName);
});
}
///<summary>编辑功能简介信息</summary>
///<paramname="ID">序号</param>
///<paramname="Description">功能简介</param>
publicnewTask<bool>SetDescription(stringActionName,stringDescription)
{
returnTask.Run(()=>
{
returnbase.SetDescription(ActionName,Description);
});
}
///<summary>根据外键FK_ACTION_REF_MODULE提取信息</summary>
publicnewTask<List<ActionInfo>>ListByACTION_REF_MODULE(intModuleIdx)
{
returnTask.Run(()=>
{
returnbase.ListByACTION_REF_MODULE(ModuleIdx);
});
}
///<summary>保存Action信息</summary>
///<paramname="info">信息类</param>
publicnewTaskSave(ActionInfoinfo)
{
returnTask.Run(()=>
{
base.Save(info);
});
}
///<summary>添加Action信息</summary>
///<paramname="info">信息类</param>
publicnewTaskAdd(ActionInfoinfo)
{
returnTask.Run(()=>
{
base.Add(info);
});
}
///<summary>修改Action信息</summary>
///<paramname="info">信息类</param>
publicnewTaskEdit(ActionInfoinfo)
{
returnTask.Run(()=>
{
base.Edit(info);
});
}
///<summary>根据PK_Action删除Action信息</summary>
///<paramname="ActionName">功能名称</param>
publicnewTaskDel(stringActionName)
{
returnTask.Run(()=>
{
base.Del(ActionName);
});
}
///<summary>根据FK_ACTION_REF_MODULE删除Action信息</summary>
///<paramname="ModuleIdx">所属模块</param>
publicnewTaskDelModule(intModuleIdx)
{
returnTask.Run(()=>
{
base.DelModule(ModuleIdx);
});
}

}
}
#endregion
#region"模块功能信息数据库访问基类声明"
namespaceVonPortal.Web.Data
{
///<summary>
///数据及操作控制层
///<seealsocref="VonPortal.Web.Business.ActionInfo"/>
///<seealsocref="VonPortal.Web.Business.ActionCtrl"/>
///</summary>
publicabstractclassActionDataProvider:DataProvider
{
#regionShared/StaticMethods
//singletonreferencetotheinstantiatedobject
privatestaticActionDataProviderobjProvider=null;
///<summary>
///constructor
///</summary>
staticActionDataProvider()
{
objProvider=CreateProvider();
}
///<summary>
///dynamicallycreateprovider
///</summary>
///<returns>returntheprovider</returns>
publicstaticActionDataProviderCreateProvider()
{
return(ActionDataProvider)VonPortal.Web.Reflection.CreateDataProvider("ptl","VonPortal.Web.Data.ActionDataProvider");
}
///<summary>
///TheinstanceofActionDataProvider.
///</summary>
///<returns>returntheprovider</returns>
publicstaticActionDataProviderInstance()
{
if(objProvider==null)objProvider=CreateProvider();
returnobjProvider;
}
#endregion

#region"ActionAbstractMethods"
///<summary>根据主键PK_Action提取信息</summary>
publicabstractIDataReaderGetByAction(stringActionName);
///<summary>编辑功能简介信息</summary>
///<paramname="intID>序号</param>
publicabstractstringGetDescription(stringActionName);
///<summary>编辑功能简介信息</summary>
publicabstractintSetDescription(stringActionName,stringDescription);
///<summary>根据外键FK_ACTION_REF_MODULE提取信息</summary>
publicabstractIDataReaderListByACTION_REF_MODULE(intModuleIdx);
///<summary>保存Action信息</summary>
publicabstractvoidSave(stringActionName,intKind);
///<summary>添加Action信息</summary>
publicabstractvoidAdd(stringActionName,intKind);
///<summary>修改Action信息</summary>
publicabstractvoidEdit(stringActionName,intKind);
///<summary>根据PK_Action删除Action信息</summary>
publicabstractvoidDel(stringActionName);
///<summary>根据FK_ACTION_REF_MODULE删除Action信息</summary>
publicabstractvoidDelModule(intModuleIdx);
#endregion
}
}
#endregion

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

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!