Angular2是一个前端开发框架，在引入ts之后使得我们这些C#开发者能够更快的熟悉该框架，angular2开发首先要知道这是一个SPA（单页应用），我们要摆脱以往的asp.net中的MVC模式的固有思路，angular2开发重点是组件（Component），所以开发之前尤其要能清楚这个概念。
在与angular2配合使用的后端（RestFul）我采用的是基于asp.net的web api2.0，这也是目前比较流行的一种方式。我在webapi开发中在数据层使用的是基于NHibernate的Repository+UnitWork模式，自然也会用到依赖注入，我选的依赖注入工具是AutoFac。在前端与后端的数据传递使用DTO，为了方便，使用的是AutoMapper做数据映射。下面从底层开始，以一个简单实例演示整个过程。
领域模型
在建模时曾考虑使用EF6，目前也有很多关于EF6的争议就是EF中实际已包含了Repository和UnitOfWork模式，那么在使用EF时就不必再使用这种模式了，为了能够熟练这种模式我选用了NHibernate作为ORM框架。
数据实体类
publicclassTGroup:EntityBase{
publicTGroup(){
Users=newList<TUser>();
}
publicvirtualstringID{get;set;}
publicvirtualstringGROUPNAME{get;set;}
publicvirtualdecimal?NORDER{get;set;}
publicvirtualstringPARENTID{get;set;}
publicvirtualDateTime?CREATED{get;set;}
publicvirtualstringGROUPTYPE{get;set;}
publicvirtualstringGROUPCODE{get;set;}
publicvirtualIList<TUser>Users{get;set;}
}
数据实体类都继承于EntityBase，EntityBase是一个空的类，目前没有任何属性及方法，只是为了在使用Repositroy模式时方便，其实可以抽象出诸如ID这样的公共属性出来。
关系映射
<?xmlversion="1.0"encoding="utf-8"?>
<hibernate-mappingassembly="URS.Data"namespace="URS.Data.Model"xmlns="urn:nhibernate-mapping-2.2">
<classname="TGroup"table="T_GROUP"lazy="true">
<idname="ID"column="ID"/>
<propertyname="GROUPNAME">
<columnname="GROUPNAME"sql-type="VARCHAR2"not-null="false"/>
</property>
<propertyname="NORDER">
<columnname="NORDER"sql-type="NUMBER"not-null="false"/>
</property>
<propertyname="PARENTID">
<columnname="PARENTID"sql-type="VARCHAR2"not-null="false"/>
</property>
<propertyname="CREATED">
<columnname="CREATED"sql-type="DATE"not-null="false"/>
</property>
<propertyname="GROUPTYPE">
<columnname="GROUPTYPE"sql-type="VARCHAR2"not-null="false"/>
</property>
<propertyname="GROUPCODE">
<columnname="GROUPCODE"sql-type="VARCHAR2"not-null="true"/>
</property>
<bagname="Users"inverse="true"cascade="all">
<keycolumn="GROUPID"/>
<one-to-manyclass="TUser"/>
</bag>
</class>
</hibernate-mapping>
在实体类中就可以看出这是一个一对多关系，TGroup包含了一个TUser集合，所以在映射时使用的bag中描绘了这个一对多关系，这里需要说明的是我所使用的是oracle数据库。
NHibernate配置
<?xmlversion="1.0"encoding="utf-8"?>
<hibernate-configurationxmlns="urn:nhibernate-configuration-2.2">
<session-factory>
<propertyname="connection.driver_class">NHibernate.Driver.OracleManagedDataClientDriver</property>
<propertyname="connection.connection_string">UserId=urs;Password=urs;DataSource=(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=localhost)(PORT=1521))(CONNECT_DATA=(SERVICE_NAME=ORA11G)))</property>
<propertyname="show_sql">true</property>
<propertyname="dialect">NHibernate.Dialect.Oracle10gDialect</property>
<propertyname="query.substitutions">true1,false0,yes'Y',no'N'</property>
<propertyname="current_session_context_class">call</property>
<mappingassembly="URS.Data"/>
</session-factory>
</hibernate-configuration>
这是一个使用oracle的odp的连接配置，这个配置文件需要放在WebAPI解决方案下
Repository模式
IRepository接口
publicinterfaceIRepository<TEntity>:IDependencywhereTEntity:EntityBase
{
TEntityGet(objectid);
IList<TEntity>GetAll();
voidAdd(TEntityentity);
voidUpdate(TEntityentity);
voidDelete(TEntityentity);
voidDelete(objectid);
}
这里的IRepository接口只提取了部分通用的CURD操作，这里需要注意的是该接口继承了IDependency，这是为了我们下面使用依赖注入的一个空接口，下面会说到这样的目的。
Repository基类
publicclassNHRepositoryBase<TEntity>:IRepository<TEntity>whereTEntity:EntityBase
{
protectedvirtualISessionSession
{
get
{
returnSessionBuilder.GetCurrentSession();
}
}
publicvirtualTEntityGet(objectid)
{
returnSession.Get<TEntity>(id);
}
publicvirtualIList<TEntity>GetAll()
{
returnSession.CreateCriteria<TEntity>()
.List<TEntity>();
}
publicvirtualvoidAdd(TEntityentity)
{
try
{
Session.Save(entity);
}
catch(Exceptionex)
{
throwex;
}
}
publicvirtualvoidUpdate(TEntityentity)
{
try
{
Session.SaveOrUpdate(entity);
}
catch(Exceptionex)
{
throwex;
}
}
publicvirtualvoidDelete(TEntityentity)
{
try
{
Session.Delete(entity);
}
catch(Exceptionex)
{
throwex;
}
}
publicvirtualvoidDelete(objectid)
{
try
{
TEntityentity=this.Get(id);
Session.Delete(entity);
}
catch(Exceptionex)
{
throwex;
}
}
}
由于我们使用的是NHibernate，所以我们需要一个全局的ISession，SessionBuilder是我封装的一个类，用来处理ISession，保障一个应用中只有一个ISession实例。
业务Repository
publicclassGroupRepository:NHRepositoryBase<TGroup>,IGroupRepository
{
}
由于Repository基类中包含了通用的CURD操作，所以这个GroupRepository只需继承这个基类即可，如果还有其他操作或属性则再进一步抽象出IGroupRepository，这里我还没打算加入其他操作所以IGroupRepository是个空的接口，以后也许会加入其他方法或属性。
UnitOfWork模式
unitofwork模式重点是处理事务，对变化的数据一次提交保证数据完整性。
IUnitOfWork接口
publicinterfaceIUnitOfWork:IDisposable,IDependency
{
IRepository<TEntity>BaseRepository<TEntity>()whereTEntity:EntityBase;
voidBeginTransaction();
voidCommit();
voidRollback();
}
这个接口同样也继承了IDependency，也是为了后面的依赖注入。在这个接口中我还定义了一个IRepository<TEntity>的属性，这是一个能够根据实体类来获取其对应的Repository。
UnitOfWork实现
publicclassNHUnitOfWork:IUnitOfWork
{
privateITransaction_transaction;
privateHashtable_repositories;
publicISessionSession
{
get
{
returnSessionBuilder.GetCurrentSession();
}
}
publicNHUnitOfWork()
{
}
publicvoidBeginTransaction()
{
this._transaction=Session.BeginTransaction();
}
publicvoidCommit()
{
try
{
//committransactionifthereisoneactive
if(_transaction!=null&&_transaction.IsActive)
_transaction.Commit();
}
catch
{
//rollbackiftherewasanexception
if(_transaction!=null&&_transaction.IsActive)
_transaction.Rollback();
throw;
}
//finally
//{
//Session.Dispose();
//}
}
publicvoidRollback()
{
//try
{
if(_transaction!=null&&_transaction.IsActive)
_transaction.Rollback();
}
//finally
//{
//Session.Dispose();
//}
}
publicvoidDispose()
{
Session.Dispose();
}
publicIRepository<T>BaseRepository<T>()whereT:EntityBase
{
if(_repositories==null)
_repositories=newHashtable();
vartype=typeof(T).Name;
if(!_repositories.ContainsKey(type))
{
varrepositoryType=typeof(NHRepositoryBase<>);
varrepositoryInstance=
Activator.CreateInstance(repositoryType
.MakeGenericType(typeof(T)));
_repositories.Add(type,repositoryInstance);
}
return(IRepository<T>)_repositories[type];
}
}
这里使用了反射创建Repository实例，这里是创建的通用基类型的Repository实例，好处就是当我们在业务逻辑层使用UnitOfWork时如果是通用的操作，则不用注入Repository了，否则可能要构造中可能要注入很多业务Repository，比较麻烦，当然如果不是通用操作的话，还是要注入的，下面会讲到。
业务逻辑层应用
publicclassGroupService:IGroupService
{
privateIUnitOfWork_unitOfWork;
privateIGroupRepository_groupRepository;
publicGroupService(IUnitOfWorkunitOfWork,IGroupRepositorygroupRepository)
{
_unitOfWork=unitOfWork;
_groupRepository=groupRepository;
}
publicIList<TGroup>GetAll()
{
IRepository<TGroup>repo=_unitOfWork.BaseRepository<TGroup>();
returnrepo.GetAll();
}
publicTGroupGetByID(stringid)
{
IRepository<TGroup>repo=_unitOfWork.BaseRepository<TGroup>();
returnrepo.Get(id);
}
publicvoidAdd(TGroupentity)
{
_unitOfWork.BeginTransaction();
IRepository<TGroup>repo=_unitOfWork.BaseRepository<TGroup>();
repo.Add(entity);
_unitOfWork.Commit();
}
publicvoidDelete(stringid)
{
_unitOfWork.BeginTransaction();
IRepository<TGroup>repo=_unitOfWork.BaseRepository<TGroup>();
repo.Delete(id);
_unitOfWork.Commit();
}
publicvoidUpdate(TGroupentity)
{
_unitOfWork.BeginTransaction();
IRepository<TGroup>repo=_unitOfWork.BaseRepository<TGroup>();
repo.Update(entity);
_unitOfWork.Commit();
}
}
这里通过在构造函数中注入IUnitOfWork，IGroupRepository，这里可以看到，由于在本例中使用的都是通用的数据CURD，所以实际上IGroupRepository并没有使用，而实际使用的是IUnitOfWork中创建的IRepository<TGroup>，由于这个例子比较简单，如果是由复杂业务逻辑的话，那么需要在_unitOfWork.BeginTransaction()到_unitOfWork.Commit()之间完成业务处理即可保障数据提交的一致性，如果这中间有异常，IUnitOfWork会回滚，这就意味着要么全部提交，要不都不提交。
这里的GroupService继承了IGroupService，而IGroupService也会继承IDependency，下面将在WebApi的解决方案中介绍AutoFac的依赖注入使用方法。
