|
花了点时间完成了一个进销存的项目，个人觉得对逻辑分析，架构思想都有一定的体会，故拿出来和大家分享下，首先介绍下项目的功能吧，主要功能有采购管理，销售管理，库存管理，人员信息管理，系统管理等，不过写这篇博客的主要目的并不是讲解如何实现项目功能，而是分享下该项目的架构思想、实现步骤和碰到的一些问题，分享下心得体会罢了......
数据库设计
下面进入主题，首先贴上项目的主界面，由于对界面要求不是很高，所以界面相对来说比较简单，甚至可是说是简陋了，，呵呵，不过重点不在界面上，勇敢的直接上图：
架构：
首先说说项目架构吧，，贴上项目模块图：
从图中可知，项目总共分10个模块，采用三层架构+WCF+反射+抽象工厂来搭建，其中还加入了单例模式，缓存机制。下面分别说说每个模块的作用：
Insigma.PSI.UI：WinForm界面层
Insigma.PSI.Model：模型层，数据实体
Insigma.PSI.IBLLService：业务逻辑接口层，是定义逻辑层的契约层
Insigma.PSI.BLLService：业务逻辑实现层，是对接口的实现
Insigma.PSI.IDAL：数据访问接口层，是定义访问层的契约层
Insigma.PSI.SqlServerDAL：数据访问实现层，实现访问接口层，主要是针对SQL数据库
Insigma.PSI.OracleDAL：数据访问实现层，实现访问接口层，主要是针对Oracle数据库
Insigma.PSI.Utility：工具层，主要存放了Oracle数据库，SQL数据库的数据库操作类
Insigma.PSI.DBFactory：抽象工厂层，主要为考虑可以使项目可以适用Oracle数据库和SQL数据库，就搭建了一个抽象工厂层，分别在Oracle数据库层和SQL数据库层建立一个
工 厂来实现该抽象工厂
C:\..\WcfWebRelease\：web层，主要用来发布WCF服务
项目:
简单的分析完了框架的每个模块的作用，然后讲讲项目，由于篇幅问题，无法讲解项目的所有功能，所以在这里就拿出一个模块来讲解下，我选择了库存模块
从图中可知，库存模块主要实现四个模块的功能，即库存列表、出库/入库、库存明细、库存警报
首先看看库存列表，上图：
库存列表的功能比较简单，只是实现了仓库的增、删、改、查，由于功能比较简单，也就不多做讲解了....
再贴上出库/入库模块图：
这块应该算是库存模块中的核心模块了，因为该块的业务逻辑比较多，比较繁琐，大致讲讲业务逻辑吧，大致的逻辑为：出库单/出库单-->填写订单-->出库/入库-->修改库存信息，按照这个顺序来完成入库出库，顺序不能颠倒，同时还要实现订单的删除，修改，在修改库存信息时由于表和表之间有很多的外键关系，所以要同时删除多张表中含有删除信息的内容，实现联级删除，由于这里考虑到要保证结果的一致性，所以用事务来实现。再看看界面，为了保证用户按照这个逻辑顺序操作，首先我添加了一对单选框(出库单，入库单)，当单选框都没有选中时，保存订单按钮、出库、入库按钮都是不可用状态，当用户选择了订单类型之后，保存订单按钮转为可用状态，需要用户填写订单信息，填写好对应信息之后保存订单，保存成功之后列表框中出现刚生产的订单，同时订单号是自动来生成的，入库单是“S_I”开头，出库单是"S_O"开头，后面五位数字为随机生成，这样生成的订单号易于区别，也避免了订单号的重复，然后根据用户选择的订单类型，对应的按钮转为可用(出库单-->出库按钮)
，这样就保证了用户始终是按照这个顺序来操作，同时订单列表框下有删除订单按钮，点击可以删除选中按钮。
下面那出库为例，看看如何实现入库：
点击【入库】按钮，弹出商品选择窗口，窗口中显示了订单号和仓库编号，同时还有一个【选择】按钮，通过该按钮选择商品
点击【选择】按钮，弹出商品列表窗口，由于我这里商品记录比较少，只有两条，我们就选第二条吧，点击【确定】按钮
这时的"入库信息"窗口中就填写上了刚才选择商品的信息，然后只要在填写上入库数量，点击【确定】就完成了入库操作了，如图：
出库的思路和入库一样，也是先选择出库单，然后填写出库单信息并保存订单，然后再给订单上添加商品，过程也是通过选择实现，由于类同，就不赘述了...
然后是库存明细模块，上图：
该模块主要实现的功能是对存放在各个仓库中的商品进行清点，点击商品的行头就显示出该商品的信息：编号、数量、盘点日期、存放仓库；填写好盘点的数量之后单击【保存】按钮，实现保存盘点数据，这个模块也没什么难点，唯一复杂点的就是因为同样的货品可以存放到不同的仓库中，所以点击时要搜索出该商品所在的所有仓库编号，并在“存放仓库”列表中显示。
最后是库存警报模块，上图：
该模块主要来设置库存上限和库存下限，实现当库存中存放的商品的数量超过库存上限或者低于库存下限时，弹出警告框提醒。
这样，我们就简单的把项目的功能叙述了下，当然还有一些细节的功能，这里就不再罗列了.....
代码：
由于代码端模块较多，我们就按照程序执行调用的层次关系来罗列.这样相对来说看起来思路比较清晰......Model层只是定义了需要用到的实体而已，不再赘述了.....
1>.Insigma.PSI.IBLLService层
可以看到有很多的功能类，无法全部讲解，所以就挑选一块，后面的模块层中也着重讲解挑选的这一块，我挑选了库存管理模块，即IStoreManageBLLService，贴上该类的代码：
IStoreManageBLLService 1 using Insigma.PSI.Model;
using System.ServiceModel;
namespace Insigma.PSI.IBLLService
{
[ServiceContract]
public interface IStoreManageBLLService
{
[OperationContract]
//获取所有仓库
List GetStores(string sqlWhere);
[OperationContract]
//获取所有仓库编号
List GetAllStoreCode();
[OperationContract]
//添加仓库
bool AddStore(StoreHouse store);
[OperationContract]
//修改仓库
bool UpdateStore(StoreHouse store);
[OperationContract]
//删除仓库
bool DeleteStore(string code);
[OperationContract]
//修改库存明细
bool UpdateStoreDetails(GoodsDetailsModel goodDetail);
[OperationContract]
//获取商品明细
List GetStoreDetails(string sqlWhere);
[OperationContract]
//修改商品数量
bool UpdateGoodNum(StoreDetailsModel storeDetail);
}
}
|
由于我们要用到WCF来发布服务，所以这里的每个方法都添加了WCF特性，主要功能是获取仓库、获取仓库编号、对仓库的增、删、改、查；由于出库入库对商品的数量有影响，又由于不存在同一张表格中，所以我们专门定义了一个方法来实现修改商品数量；然后出库入库对应一张库存明细表，执行操作之后要修改该表，记录信息，同时也可以获取该表信息，定义的方法就那么多了.....
2>Insigma.PSI.BLLService层
这层是对上面提及的接口层的实现，但除了实现之外，我还在这里加了一个反射机制，在这层按照原来三层的思路是要调用DAL层来实现对数据库的操作，但因为考虑到要适用于不同的数据库，所以我们不知道要调用哪个数据库层的DAL来操作，这就是这个反射存在的意义了，我们可以通过反射来读取配置文件中定义的数据库信息，从而创建对应数据库类的实例来操作....先贴上StoreManageBLLService的代码，之后再接着讲解，看到了代码思路会清晰点：
StoreManageBLLService 1 using Insigma.PSI.Model;
using Insigma.PSI.IBLLService;
using Insigma.PSI.IDAL;
using Insigma.PSI.DBFactory;
namespace Insigma.PSI.BLL
{
public class StoreManageBLLService:IStoreManageBLLService
{
//通过反射获取对应的抽象产品
private IStoreManageDAL Ismd = Refection.GetFactory().StoreManageProduct;
///
/// 获取StoresHost表数据
///
///
///
public List GetStores(string sqlWhere)
{
return Ismd.GetStores(sqlWhere);
}
///
/// 添加仓库
///
///
///
public bool AddStore(StoreHouse store)
{
int result = Ismd.AddStore(store);
if (result > 0)
{
return true;
}
else
{
return false;
}
}
///
/// 修改仓库
///
/// =
///
public bool UpdateStore(StoreHouse store)
{
int result = Ismd.UpdateStore(store);
if (result > 0)
{
return true;
}
else
{
return false;
}
}
///
/// 删除仓库
///
///
///
public bool DeleteStore(string code)
{
int result = Ismd.DeleteStore(code);
if (result > 0)
{
return true;
}
else
{
return false;
}
}
///
/// 获取所有仓库编号
///
///
public List GetAllStoreCode()
{
return Ismd.GetAllStoreCode();
}
///
/// 修改商品明细的数量信息
///
///
///
public bool UpdateStoreDetails(GoodsDetailsModel goodDetail)
{
int result = Ismd.UpdateStoreDetails(goodDetail);
if (result > 0)
{
return true;
}
else
{
return false;
}
}
///
/// 获取所有库存明细
///
///
///
public List GetStoreDetails(string sqlWhere)
{
return Ismd.GetStoreDetails(sqlWhere);
}
///
/// 修改库存明细的盘点数量
///
///
///
public bool UpdateGoodNum(StoreDetailsModel storeDetail)
{
int result = Ismd.UpdateGoodNum(storeDetail);
if (result > 0)
{
return true;
}
else
{
return false;
}
}
}
}
|
从代码中可以看到我们是通过反射来获取DAL的实例的，然后再调用该实例的方法，那么反射里是怎么实现的呢？贴上代码：
反射
反射 1 using System.Configuration;
using System.Reflection;
using Insigma.PSI.DBFactory;
namespace Insigma.PSI.BLL
{
public class Refection
{
//定义一个抽象工厂类的对象实例 用于保存作用
private static AbstractFactory DataAccess = null;
//获取配置文件中定义的数据库信息
private static string path = ConfigurationManager.AppSettings["DllName"];
private static string className = ConfigurationManager.AppSettings["ClassName"];
//单例模式-----因为每次加载该程序集都会去调用相同的DAL
// 如果已经加载过了 就不要再次加载 提高性能
static Refection()
{
//反射----因为不确定要获取什么类型的DAL 不知道是Oracle还是SQL等等 所以这里添加一个反射机制
string _classname = path + "." + className;
DataAccess = (AbstractFactory)Assembly.Load(path).CreateInstance(_classname);
}
//获取对应数据库的具体工厂
public static AbstractFactory GetFactory()
{
return DataAccess;
}
}
}
|
从代码可知，我们获取了配置文件中定义的程序集以及数据库类的信息，通过加载该程序集来获取该数据库类的实例，同时，添加了单例模式，因为考虑到每次加载该类库的时候都要来获取一次数据库类的实例，但是该数据库类只要配置文件定义不变他就不会变，所以不用每次都去创建实例
，只需要创建一次就可以了，提高性能，所以就是单例模式的作用了，这里首先定义了一个AbstractFactory类型(后面会讲到)变量来接受创建好的实例，该变量也是static类型的，保证唯一性，我这里是将构造函数改为static的方式，然后在静态构造函数中实例化数据库类，并赋值给定义好的变量，因为静态构造函数只会执行一次，之后就不会执行了，这就保证了只实例一次，然后定义一个GetFactory()方法来返回数据库实例，这样就达到了"单例"的效果了，当然单例模式还有一种思路是将构造函数设为private，也同样定义一个静态变量和静态方法来创建实例，同样保证了"单例"。
然后看看配置文件中定义的数据库信息：
web.config1 <configuration>
<!--定义数据库信息-->
<appSettings>
<!--程序集名称-->
<add key="DLLName" value="Insigma.PSI.OracleDAL"/>
<!--数据库类名-->
<add key="ClassName" value="OracleFactory"/>
</appSettings>
|
可以看到配置文件中定义了程序集的名称，数据库类的名称，但其实这个数据库类就是工厂类的名称。反射中提到了AbstractFactory类型，这是抽象工厂模块中的内容，那么为什么要有这个抽象工厂呢？？存在的意义是什么呢？我们就来看看抽象工厂，我的思路：定义一个抽象工厂，里面是一些抽象产品，对应于IDAL中定义的类型的产品，然后在每个数据库类库中定义一个具体工厂，该具体工厂继承抽象工厂，重写抽象产品，返回具体产品，即对IDAL接口类的实现类(DAL)的对应实例，那你会想到了，如没有工厂我们照样可以实现用反射类获取实例的呀，但你想想这时候获取到得实例是什么？它就是我们工厂类中的单个产品而已，当我们的产品有很多的时候怎么办呢，一个DAL类库中的每个类都是一个产品，那难道我们把每个产品都在配置文件中去定义，然后用到的时候通过反射去获取么？？显然不可能，所以我们加了抽象工厂模式了，在DAL类库中有一个具体的工厂类，我们所有的产品都由该工厂来创建，那我们获取的是时候只需要获取工厂实例，然后通过该实例来创建我们需要的产品就可以了......
3>Insigma.PSI.IDAL层
同样的拿IStoreManageDAL类讲解，上代码：
IStoreManageDAL 1 using Insigma.PSI.Model;
namespace Insigma.PSI.IDAL
{
public interface IStoreManageDAL
{
List GetStores(string sqlWhere);
List GetAllStoreCode();
int AddStore(StoreHouse store);
int UpdateStore(StoreHouse store);
int DeleteStore(string code);
int UpdateStoreDetails(GoodsDetailsModel goodDetail);
List GetStoreDetails(string sqlWhere);
int UpdateGoodNum(StoreDetailsModel storeDetail);
}
}
|
这也是一个接口类，接口的作用就是规范行为，定义一种契约，继承该接口的类都必须实现契约，所以这里主要来约束DAL实现层的行
4>.Insigma.PSI.DBFactory
抽象工厂模块中就一个抽象工厂类，就直接贴上类代码：
AbstractFactory 1 using Insigma.PSI.IDAL;
namespace Insigma.PSI.DBFactory
{
//定义一个抽象工厂 便于适用于不同的数据库 每个数据库都可以建立一个具体工厂 继承该工厂
public abstract class AbstractFactory
{
//抽象产品类---对应于IDAL层
public abstract ISysUserDAL SysUserProduct { get; }
public abstract IStoreManageDAL StoreManageProduct { get;}
public abstract IDepartmentDAL DepartmentProduct { get; }
public abstract IHandleGeneralsDAL HandleGeneralsProduct { get; }
public abstract IGoodsDAL GoodsProduct { get; }
public abstract IHandle_GoodDetailsDAL Handle_GoodDetailsProduct { get; }
public abstract IStaffsDAL StaffsProduct { get; }
public abstract ICompanyDAL CompanyProduct { get; }
}
}
|
在抽象类中为每个在IDAL中定义的类型都对应的建立了一个属性(也可以定义成方法)，因为加了抽象工厂之后，IDAL中的每个类都是一个抽象产品类，是产品类的基类，而DAL中的每个类都是该基类的派生类，都实现了基类中定义的方法，最终返回的具体产品的类型都为抽象产品类型(子类赋值给基类)。
5>.Insigma.PSI.OracleDAL
有一个工厂类，用于创建具体产品实例，贴上工厂类代码：
Oracle工厂 1 using Insigma.PSI.DBFactory;
using System.Web;
using Insigma.PSI.IDAL;
namespace Insigma.PSI.OracleDAL
{
//具体工厂：Oracle
public class OracleFactory:AbstractFactory
{
//定义DAL类型变量，用于保存
private SysUserDAL sud = null;
private DepartmentDAL dp = null;
private StoreManageDAL sm = null;
private HandleGeneralsDAL hg = null;
private GoodsDAL gd = null;
private Handle_GoodDetailsDAL h_g = null;
private StaffsDAL sd = null;
private CompanyDAL cd = null;
//具体产品：SysUserDAL
public override ISysUserDAL SysUserProduct
{
get
{
//首先搜索缓存 看看是否有对应的产品
if (HttpRuntime.Cache.Get("sysuserdal") == null)
{
sud = new SysUserDAL();
//添加缓存机制-----将sud添加到缓存 因为每个用户调用都会去实例化同一个对象 加入缓存机制
// 如果要获取相同类型的对象 则可以直接从缓存中获取 提高性能
HttpRuntime.Cache.Insert("sysuserdal", sud,null,DateTime.Now.AddMinutes(5),TimeSpan.Zero);
}
//返回存储在缓存中的值
return (SysUserDAL)HttpRuntime.Cache.Get("sysuserdal");
}
}
//具体产品：DepartmentDAL
public override IDepartmentDAL DepartmentProduct
{
get
{
//首先搜索缓存 看看是否有对应的产品
if (HttpRuntime.Cache.Get("departmentdal") == null)
{
dp = new DepartmentDAL();
//添加缓存机制-----将sud添加到缓存 因为每个用户调用都会去实例化同一个对象 加入缓存机制
// 如果要获取相同类型的对象 则可以直接从缓存中获取 提高性能
HttpRuntime.Cache.Insert("departmentdal", dp, null, DateTime.Now.AddMinutes(5), TimeSpan.Zero);
}
//返回存储在缓存中的值
return (DepartmentDAL)HttpRuntime.Cache.Get("departmentdal");
}
}
//具体产品：StoreManageDAL
public override IStoreManageDAL StoreManageProduct
{
get
{
//首先搜索缓存 看看是否有对应的产品
if (HttpRuntime.Cache.Get("storemanagedal") == null)
{
sm = new StoreManageDAL();
//添加缓存机制-----将sud添加到缓存 因为每个用户调用都会去实例化同一个对象 加入缓存机制
// 如果要获取相同类型的对象 则可以直接从缓存中获取 提高性能
HttpRuntime.Cache.Insert("storemanagedal", sm, null, DateTime.Now.AddMinutes(5), TimeSpan.Zero);
}
//返回存储在缓存中的值
return (StoreManageDAL)HttpRuntime.Cache.Get("storemanagedal");
}
}
//具体产品：HandleGeneralsDAL
public override IHandleGeneralsDAL HandleGeneralsProduct
{
get
{
if(HttpRuntime.Cache.Get("handlegenerals")==null)
{
hg = new HandleGeneralsDAL();
HttpRuntime.Cache.Insert("handlegenerals", hg);
}
return (HandleGeneralsDAL)HttpRuntime.Cache.Get("handlegenerals");
}
}
//具体产品：GoodsDAL
public override IGoodsDAL GoodsProduct
{
get
{
if (HttpRuntime.Cache.Get("good") == null)
{
gd = new GoodsDAL();
HttpRuntime.Cache.Insert("good", gd);
}
return (GoodsDAL)HttpRuntime.Cache.Get("good");
}
}
//具体产品：Handle_GoodDetailsDAL
public override IHandle_GoodDetailsDAL Handle_GoodDetailsProduct
{
get
{
if (HttpRuntime.Cache.Get("hand_good") == null)
{
h_g = new Handle_GoodDetailsDAL();
HttpRuntime.Cache.Insert("hand_good", h_g);
}
return (Handle_GoodDetailsDAL)HttpRuntime.Cache.Get("hand_good");
}
}
//具体产品：StaffsDAL
public override IStaffsDAL StaffsProduct
{
get
{
if (HttpRuntime.Cache.Get("staff") == null)
{
sd = new StaffsDAL();
HttpRuntime.Cache.Insert("staff", sd);
}
return (StaffsDAL)HttpRuntime.Cache.Get("staff");
}
}
//具体产品：CompanyDAL
public override ICompanyDAL CompanyProduct
{
get
{
if (HttpRuntime.Cache.Get("company") == null)
{
cd = new CompanyDAL();
HttpRuntime.Cache.Insert("company", cd);
}
return (CompanyDAL)HttpRuntime.Cache.Get("company");
}
}
}
}
|
在创建具体产品实例的时候我们还用到了缓存机制，每次使用产品功能的时候都回去实例化一个具体的产品返回，所以多次使用同一产品的时候就做了很多无谓的实例化，所以我加了一层缓存，用来将产品的实例缓存起来，下次再需要该产品时直接从缓存中读取就可以了，提高了性能。
我这里用的是Runtime.Cache.Get()来获取存，Runtime.Cache.Insert()来添加缓存。
当然还有一种方法是用HttpContext.Current.Cache.Get()来取,HttpContext.Current.Cache.Insert()来添加缓存。
至于这两者的区别，要涉及到asp.net生命周期和其他方面的一些内容了，这里就不解析了.....
SqlDAL中的内容和Oracle类似，也是建立了一个工厂创建具体产品，同样继承并实现了IDAL中定义的方法，这里也不罗列了......
到这里抽象工厂的角色都出现了，那么来总结下：
抽象工厂：AbstractFactory类
抽象产品：IDAL类库中每个类
具体工厂：1.OracleFactory
2.SqlFactory
具体产品：DAL层中定义的每个类
6>.WCF
我们仍然拿StoreManageBLL.svc来讲解，贴上代码：
<%@ ServiceHost Language="C#" Debug="true" Service="Insigma.PSI.BLL.StoreManageBLLService" %>
|
定义了程序集的名称和服务类名，然后在web.config中配置服信息，上代码:
web.config<system.web>
<compilation debug="true" targetFramework="4.0" />
</system.web>
<system.serviceModel>
<behaviors>
<serviceBehaviors>
<behavior>
<!-- 为避免泄漏元数据信息，请在部署前将以下值设置为 false 并删除上面的元数据终结点 -->
<serviceMetadata httpGetEnabled="true"/>
<!-- 要接收故障异常详细信息以进行调试，请将以下值设置为 true。在部署前设置为 false 以避免泄漏异常信息 -->
<serviceDebug includeExceptionDetailInFaults="true"/>
</behavior>
</serviceBehaviors>
</behaviors>
<serviceHostingEnvironment multipleSiteBindingsEnabled="true" />
</system.serviceModel>
<system.webServer>
<modules runAllManagedModulesForAllRequests="true"/>
</system.webServer> |
7>.Insigma.PSI.UI
服务配置好了，那我们客户端怎么调用呢？？所以我们需要在客户端的app.config配置文件中添加终结点信息，上代码：
app.config 1 <configuration>
<system.serviceModel>
<client>
<endpoint address="http://localhost:33864/WcfWebRelease/SysUserBLL.svc"
binding="basicHttpBinding" bindingConfiguration="" contract="Insigma.PSI.IBLLService.ISysUserBLLSerivce"
name="SysUserService" />
<endpoint address="http://localhost:33864/WcfWebRelease/DepartmentBLL.svc"
binding="basicHttpBinding" bindingConfiguration="" contract="Insigma.PSI.IBLLService.IDepartmentBLLService"
name="DepartmentBLLService" />
<endpoint address="http://localhost:33864/WcfWebRelease/StoreManageBLL.svc"
binding="basicHttpBinding" bindingConfiguration="" contract="Insigma.PSI.IBLLService.IStoreManageBLLService"
name="StoreManageBLLService" />
<endpoint address="http://localhost:33864/WcfWebRelease/HandleGeneralsBLL.svc"
binding="basicHttpBinding" bindingConfiguration="" contract="Insigma.PSI.IBLLService.IHandleGeneralsBLLService"
name="HandleGeneralsBLLService" />
<endpoint address="http://localhost:33864/WcfWebRelease/GoodsBLL.svc"
binding="basicHttpBinding" bindingConfiguration="" contract="Insigma.PSI.IBLLService.IGoodsBLLService"
name="GoodsBLLService" />
<endpoint address="http://localhost:33864/WcfWebRelease/Handle_GoodDetails.svc"
binding="basicHttpBinding" bindingConfiguration="" contract="Insigma.PSI.IBLLService.IHandle_GoodDetailsBLLService"
name="Handle_GoodDetailsBLLService" />
<endpoint address="http://localhost:33864/WcfWebRelease/StaffsBLL.svc"
binding="basicHttpBinding" bindingConfiguration="" contract="Insigma.PSI.IBLLService.IStaffsBLLService"
name="StaffsBLLService" />
<endpoint address="http://localhost:33864/WcfWebRelease/CompanyBLL.svc"
binding="basicHttpBinding" bindingConfiguration="" contract="Insigma.PSI.IBLLService.ICompanyBLLService"
name="CompanyBLLService" />
</client>
</system.serviceModel> |
同时，我在客户端专门定义了一个类用来创建wcf代理，返回BLL实例，上代码：
代理类
代理类 1 namespace Insigma.PSI.UI
{
public class GetServiceFromWcf
{
private static ISysUserBLLSerivce _SysUserBLLSerivceProxy;
private static IDepartmentBLLService _DepartmentBLLService;
private static IStoreManageBLLService _StoreManageBLLService;
private static IHandleGeneralsBLLService _HandleGeneralsBLLService;
private static IGoodsBLLService _GoodsBLLService;
private static IHandle_GoodDetailsBLLService _Handle_GoodDetailsBLLService;
private static IStaffsBLLService _StaffsBLLService;
private static ICompanyBLLService _CompanyBLLService;
//获取SysUser代理
public static ISysUserBLLSerivce GetSysUserBLLSerivceProxy()
{
if (_SysUserBLLSerivceProxy == null)
{
ChannelFactory channelFactory = new ChannelFactory("SysUserService");
_SysUserBLLSerivceProxy = channelFactory.CreateChannel();
}
return _SysUserBLLSerivceProxy;
}
//获取Department代理
public static IDepartmentBLLService GetDepartmentBLLServiceProxy()
{
if (_DepartmentBLLService == null)
{
ChannelFactory channelFactory = new ChannelFactory("DepartmentBLLService");
_DepartmentBLLService = channelFactory.CreateChannel();
}
return _DepartmentBLLService;
}
//获取StoreHost代理
public static IStoreManageBLLService GetStoreManageBLLServiceProxy()
{
if (_StoreManageBLLService == null)
{
ChannelFactory channelFactory = new ChannelFactory("StoreManageBLLService");
_StoreManageBLLService = channelFactory.CreateChannel();
}
return _StoreManageBLLService;
}
//获取HandleGenerals代理
public static IHandleGeneralsBLLService GetHandleGeneralsBLLServiceProxy()
{
if (_HandleGeneralsBLLService == null)
{
ChannelFactory channelFactory = new ChannelFactory("HandleGeneralsBLLService");
_HandleGeneralsBLLService = channelFactory.CreateChannel();
}
return _HandleGeneralsBLLService;
}
//获取Goods代理
public static IGoodsBLLService GetGoodsBLLService()
{
if (_GoodsBLLService == null)
{
ChannelFactory channelFactory = new ChannelFactory("GoodsBLLService");
_GoodsBLLService = channelFactory.CreateChannel();
}
return _GoodsBLLService;
}
//获取Handle_GoodDetails代理
public static IHandle_GoodDetailsBLLService GetHandle_GoodDetails()
{
if (_Handle_GoodDetailsBLLService == null)
{
ChannelFactory channelFactory = new ChannelFactory("Handle_GoodDetailsBLLService");
_Handle_GoodDetailsBLLService = channelFactory.CreateChannel();
}
return _Handle_GoodDetailsBLLService;
}
//获取Staffs代理
public static IStaffsBLLService GetStaffsBLLService()
{
if (_StaffsBLLService == null)
{
ChannelFactory channelFactory = new ChannelFactory("StaffsBLLService");
_StaffsBLLService = channelFactory.CreateChannel();
}
return _StaffsBLLService;
}
///获取Company代理
public static ICompanyBLLService GetCompanyBLLService()
{
if (_CompanyBLLService == null)
{
ChannelFactory channelFactory = new ChannelFactory("CompanyBLLService");
_CompanyBLLService = channelFactory.CreateChannel();
}
return _CompanyBLLService;
}
}
}
|
Utility层没什么好讲的，就是两个数据库操作类，一个Oracle类，一个SQL类，这里就不贴图贴代码了....
疑问解答
架构、项目、代码端都讲解完成了....接下来和大家分享项目中碰到的一个绑定的问题....
首先贴上要绑定的Model层信息：
外键对象
外键对象 1 namespace Insigma.PSI.Model
{
[DataContract]
public class Handles_GoodDetailsModel
{
//外键对象
[DataMember]
public HandelGeneralsModel Handles;
[DataMember]
public GoodsDetailsModel GoodsDetails;
}
}
|
讲讲要求吧，就是希望当页面载入是显示订单表_商品详细表的综合信息，由于是不同的表，所以我在Model层建立了一个单独的Model类，里面是一对外键对象，因为存在主外键的关系，所以我就考虑到了用外键对象来存放数据，然后通过外键建立两张表的视图，然后获取视图数据，OK，获取完全没有问题，获取到了就是页面端的绑定了，按照原来的思路，上代码：
错误绑定
1 //【错误】绑定
2 List hand_goodList = GetServiceFromWcf.GetHandle_GoodDetails().GetHandle_GoodDetails(sqlWhere);
3 dgv_DetailShow.DataSource = hand_goodList;
|
结果就是，始终绑不上，经过深思熟虑之后，才觉得应该是外界对象的问题，所以收集资料，终于发现错误点确实在外键对象上，外键对象无法直接直接绑定上去，至少DataGridView无法直接绑定，web中的Eval()、Bind()可以绑定外键对象(经测试)........好了，问题找到了就要开始解决了，最后终于发现了一种手动绑定的方法，上代码：
正确绑定
正确绑定 1 //【正确】手工绑定
List hand_goodList = GetServiceFromWcf.GetHandle_GoodDetails().GetHandle_GoodDetails(sqlWhere);
//由于存在外键对象 无法直接绑定 需要手工绑定
dgv_DetailShow.Rows.Clear();
foreach (Handles_GoodDetailsModel model in hand_goodList)
{
//新增一行，该值会随着循环绑定自增
int i = dgv_DetailShow.Rows.Add();
//给对应行绑定数据
dgv_DetailShow.Rows[i].Cells["HandCode"].Value = model.Handles.HandCode;
dgv_DetailShow.Rows[i].Cells["ContCode"].Value = model.Handles.ContCode;
dgv_DetailShow.Rows[i].Cells["HandDate"].Value = model.Handles.HandDate;
dgv_DetailShow.Rows[i].Cells["StaffCode"].Value = model.Handles.StaffCode;
dgv_DetailShow.Rows[i].Cells["StoreDate"].Value = model.Handles.StoreDate;
dgv_DetailShow.Rows[i].Cells["DetailCode"].Value = model.GoodsDetails.DetailCode;
dgv_DetailShow.Rows[i].Cells["GooCode"].Value = model.GoodsDetails.GooCode;
dgv_DetailShow.Rows[i].Cells["GooNum"].Value = model.GoodsDetails.GooNum;
dgv_DetailShow.Rows[i].Cells["GooPrice"].Value = model.GoodsDetails.GooPrice;
dgv_DetailShow.Rows[i].Cells["StoreCodeIn"].Value = model.GoodsDetails.StoreCodeIn;
dgv_DetailShow.Rows[i].Cells["StoreCodeOut"].Value = model.GoodsDetails.StoreCodeOut;
}
}
|
| 
