大恶人吉日嘎拉之走火入魔闭门造车之.NET疯狂架构经验分享系列之（七）WCF支持

前后购买了N个WCF的书籍，中国人写书，就怕文字不够数一样，密密麻麻写了一大堆，又难看懂，又浪费时间，其实我们都想快速见效，文字太多看来看去看得头大、容易导致晕书症，建议出书的人多插图，少写字。



本文只做入门参考用，WCF服务器端注意事项

1：WCF服务器端配置文件如何写很关键、例如多个服务怎么一同发布？

2：如何用最简单的程序，把WCF服务器发布好？

3：配置文件如何配置，客户端才能正常引用已发布的服务？

其实这3个问题，是服务器端编写程序的核心关键问题，这解决了，就算是好入门了，接着可以深入某个问题了。



工程的效果图如下：





以下程序是启动WCF服务用的程序参考：



// 读取配置文件
Configuration configuration = ConfigurationManager.OpenExeConfiguration(Assembly.GetEntryAssembly().Location);
ServiceModelSectionGroup serviceModelSectionGroup = (ServiceModelSectionGroup)configuration.GetSectionGroup("system.serviceModel");
// 开启每个服务
foreach (ServiceElement serviceElement in serviceModelSectionGroup.Services.Services)
{
var serviceHost = new ServiceHost(Assembly.Load("DotNet.Service").GetType(serviceElement.Name), serviceElement.Endpoints[0].Address);
serviceHost.Opened += delegate { Console.WriteLine("{0}", serviceHost.BaseAddresses[0]); };
serviceHost.Open();
}




以下文件为 WCF的服务器端配置文件：

<?xml version="1.0" encoding="utf-8"?>
<configuration>
<system.serviceModel>
<services>
<service name="DotNet.Service.BusinessCardService" behaviorConfiguration="Internet">
<endpoint address="http://localhost:8888/DotNet.Service/BusinessCardService/" binding="basicHttpBinding" contract="DotNet.IService.IBusinessCardService">
</endpoint>
</service>
<service name="DotNet.Service.ExceptionService" behaviorConfiguration="Internet">
<endpoint address="http://localhost:8888/DotNet.Service/ExceptionService/" binding="basicHttpBinding" contract="DotNet.IService.IExceptionService">
</endpoint>
</service>
<service name="DotNet.Service.FileService" behaviorConfiguration="Internet">
<endpoint address="http://localhost:8888/DotNet.Service/FileService/" binding="basicHttpBinding" contract="DotNet.IService.IFileService">
</endpoint>
</service>
<service name="DotNet.Service.FolderService" behaviorConfiguration="Internet">
<endpoint address="http://localhost:8888/DotNet.Service/FolderService/" binding="basicHttpBinding" contract="DotNet.IService.IFolderService">
</endpoint>
</service>
<service name="DotNet.Service.ItemDetailsService" behaviorConfiguration="Internet">
<endpoint address="http://localhost:8888/DotNet.Service/ItemDetailsService/" binding="basicHttpBinding" contract="DotNet.IService.IItemDetailsService">
</endpoint>
</service>
<service name="DotNet.Service.ItemsService" behaviorConfiguration="Internet">
<endpoint address="http://localhost:8888/DotNet.Service/ItemsService/" binding="basicHttpBinding" contract="DotNet.IService.IItemsService">
</endpoint>
</service>
<service name="DotNet.Service.LoginService" behaviorConfiguration="Internet">
<endpoint address="http://localhost:8888/DotNet.Service/LoginService/" binding="basicHttpBinding" contract="DotNet.IService.ILoginService">
</endpoint>
</service>
<service name="DotNet.Service.LogService" behaviorConfiguration="Internet">
<endpoint address="http://localhost:8888/DotNet.Service/LogService/" binding="basicHttpBinding" contract="DotNet.IService.ILogService">
</endpoint>
</service>
<service name="DotNet.Service.MessageService" behaviorConfiguration="Internet">
<endpoint address="http://localhost:8888/DotNet.Service/MessageService/" binding="basicHttpBinding" contract="DotNet.IService.IMessageService">
</endpoint>
</service>
<service name="DotNet.Service.ModuleService" behaviorConfiguration="Internet">
<endpoint address="http://localhost:8888/DotNet.Service/ModuleService/" binding="basicHttpBinding" contract="DotNet.IService.IModuleService">
</endpoint>
</service>
<service name="DotNet.Service.OrganizeService" behaviorConfiguration="Internet">
<endpoint address="http://localhost:8888/DotNet.Service/OrganizeService/" binding="basicHttpBinding" contract="DotNet.IService.IOrganizeService">
</endpoint>
</service>
<service name="DotNet.Service.ParameterService" behaviorConfiguration="Internet">
<endpoint address="http://localhost:8888/DotNet.Service/ParameterService/" binding="basicHttpBinding" contract="DotNet.IService.IParameterService">
</endpoint>
</service>
<service name="DotNet.Service.PermissionAdminService" behaviorConfiguration="Internet">
<endpoint address="http://localhost:8888/DotNet.Service/PermissionAdminService/" binding="basicHttpBinding" contract="DotNet.IService.IPermissionAdminService">
</endpoint>
</service>
<service name="DotNet.Service.PermissionService" behaviorConfiguration="Internet">
<endpoint address="http://localhost:8888/DotNet.Service/PermissionService/" binding="basicHttpBinding" contract="DotNet.IService.IPermissionService">
</endpoint>
</service>
<service name="DotNet.Service.RoleService" behaviorConfiguration="Internet">
<endpoint address="http://localhost:8888/DotNet.Service/RoleService/" binding="basicHttpBinding" contract="DotNet.IService.IRoleService">
</endpoint>
</service>
<service name="DotNet.Service.SequenceService" behaviorConfiguration="Internet">
<endpoint address="http://localhost:8888/DotNet.Service/SequenceService/" binding="basicHttpBinding" contract="DotNet.IService.ISequenceService">
</endpoint>
</service>
<service name="DotNet.Service.StaffService" behaviorConfiguration="Internet">
<endpoint address="http://localhost:8888/DotNet.Service/StaffService/" binding="basicHttpBinding" contract="DotNet.IService.IStaffService">
</endpoint>
</service>
<service name="DotNet.Service.UserService" behaviorConfiguration="Internet">
<endpoint address="http://localhost:8888/DotNet.Service/UserService/" binding="basicHttpBinding" contract="DotNet.IService.IUserService">
</endpoint>
</service>
<service name="DotNet.Service.WorkReportService" behaviorConfiguration="Internet">
<endpoint address="http://localhost:8888/DotNet.Service/WorkReportService/" binding="basicHttpBinding" contract="DotNet.IService.IWorkReportService">
</endpoint>
</service>
</services>
<behaviors>
<serviceBehaviors>
<behavior name="Internet">
<serviceMetadata httpGetEnabled="true" />
</behavior>
</serviceBehaviors>
</behaviors>
</system.serviceModel>
</configuration>




接口文件参考：

//------------------------------------------------------------
// All Rights Reserved , Copyright (C) 2010 , Jirisoft , Ltd.
//------------------------------------------------------------

using System.Data;
using System.ServiceModel;

namespace DotNet.IService
{
using DotNet.Utilities;

/// <summary>
/// ILoginService
///
/// 修改纪录
///
/// 2009.04.15 版本：1.0 JiRiGaLa 添加接口定义。
///
/// 版本：1.0
///
/// <author>
/// <name>JiRiGaLa</name>
/// <date>2009.04.15</date>
/// </author>
/// </summary>
[ServiceContract]
public interface ILoginService
{
/// <summary>
/// 获得登录用户列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <returns>数据表</returns>
[OperationContract]
DataTable GetUserDT(BaseUserInfo userInfo);

/// <summary>
/// 获得内部员工列表
/// </summary>
/// <param name="userInfo"></param>
/// <returns></returns>
[OperationContract]
DataTable GetStaffDT(BaseUserInfo userInfo);

/// <summary>
/// 按唯一识别码登录
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="suid">唯一识别码</param>
/// <param name="statusCode">返回状态码</param>
/// <param name="statusMessage">返回状消息</param>
/// <returns>用户实体</returns>
[OperationContract]
BaseUserInfo LoginBySuid(BaseUserInfo userInfo, string suid, out string statusCode, out string statusMessage);

/// <summary>
/// 按用户名登录
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="userName">用户名</param>
/// <param name="statusCode">返回状态码</param>
/// <param name="statusMessage">返回状消息</param>
/// <returns>用户实体</returns>
[OperationContract]
BaseUserInfo LoginByUserName(BaseUserInfo userInfo, string userName, out string statusCode, out string statusMessage);

/// <summary>
/// 登录
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="userName">用户名</param>
/// <param name="password">密码</param>
/// <param name="ipAddress">IP地址</param>
/// <param name="statusCode">返回状态码</param>
/// <param name="statusMessage">返回状消息</param>
/// <returns>登录实体类</returns>
[OperationContract]
BaseUserInfo UserLogin(BaseUserInfo userInfo, string userName, string password, out string statusCode, out string statusMessage);

/// <summary>
/// 操作员退出应用程序
/// </summary>
/// <param name="userInfo">用户</param>
[OperationContract]
void OnExit(BaseUserInfo userInfo);

/// <summary>
/// 检查在线状态(服务器专用)
/// </summary>
/// <returns>离线人数</returns>
[OperationContract]
int ServerCheckOnLine();

/// <summary>
/// 检查在线状态
/// </summary>
/// <param name="userInfo">用户</param>
/// <returns>离线人数</returns>
[OperationContract]
int CheckOnLine(BaseUserInfo userInfo);

/// <summary>
/// 获取在线用户列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <returns>数据表</returns>
[OperationContract]
DataTable GetOnLineState(BaseUserInfo userInfo);

/// <summary>
/// 设置密码
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="userIds">被设置的用户主键</param>
/// <param name="password">新密码</param>
/// <param name="statusCode">返回状态码</param>
/// <param name="statusMessage">返回状消息</param>
/// <returns>影响行数</returns>
[OperationContract]
int SetPassword(BaseUserInfo userInfo, string[] userIds, string password, out string statusCode, out string statusMessage);

/// <summary>
/// 修改密码
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="oldPassword">原始密码</param>
/// <param name="newPassword">新密码</param>
/// <param name="statusCode">返回状态码</param>
/// <param name="statusMessage">返回状消息</param>
/// <returns>影响行数</returns>
[OperationContract]
int ChangePassword(BaseUserInfo userInfo, string oldPassword, string newPassword, out string statusCode, out string statusMessage);
}
}





服务实现参考：

//------------------------------------------------------------
// All Rights Reserved , Copyright (C) 2010 , Jirisoft , Ltd.
//------------------------------------------------------------

using System;
using System.Data;
using System.Reflection;

namespace DotNet.Service
{
using DotNet.Business;
using DotNet.DbUtilities;
using DotNet.IService;
using DotNet.Model;
using DotNet.Utilities;

/// <summary>
/// ILoginService
///
/// 修改纪录
///
/// 2009.04.15 版本：1.0 JiRiGaLa 添加接口定义。
///
/// 版本：1.0
///
/// <author>
/// <name>JiRiGaLa</name>
/// <date>2009.04.15</date>
/// </author>
/// </summary>
public class LoginService : System.MarshalByRefObject, ILoginService
{
#region public void Load()
/// <summary>
/// 加载服务层
/// </summary>
public void Load()
{
}
#endregion

#region public DataTable GetUserDT(BaseUserInfo userInfo) 获得用户列表
/// <summary>
/// 获得用户列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <returns>数据表</returns>
public DataTable GetUserDT(BaseUserInfo userInfo)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
DataTable dataTable = new DataTable(BaseStaffTable.TableName);

IDbHelper dbHelper = DbHelperFactory.GetHelper();
try
{
dbHelper.Open();
// 检查用户在线状态(服务器专用)
BaseUserManager userManager = new BaseUserManager(dbHelper, userInfo);
userManager.CheckOnLine();
// 获取允许登录列表
string[] names = new string[] { BaseUserTable.FieldEnabled, BaseUserTable.FieldDeleteMark};
Object[] values = new Object[] { 1, 0};
dataTable = userManager.GetDT(names, values);
BaseLogManager.Instance.Add(dbHelper, userInfo, MethodBase.GetCurrentMethod());
}
catch (Exception ex)
{
BaseExceptionManager.LogException(dbHelper, userInfo, ex);
throw ex;
}
finally
{
dbHelper.Close();
}

// 写入调试信息
#if (DEBUG)
BaseBusinessLogic.EndDebug(MethodBase.GetCurrentMethod(), milliStart);
#endif
return dataTable;
}
#endregion

#region public DataTable GetUserDT(BaseUserInfo userInfo) 获得内部职员列表
/// <summary>
/// 获得内部职员列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <returns>数据表</returns>
public DataTable GetStaffDT(BaseUserInfo userInfo)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
DataTable dataTable = new DataTable(BaseStaffTable.TableName);

IDbHelper dbHelper = DbHelperFactory.GetHelper();
try
{
dbHelper.Open();
// 检查用户在线状态(服务器专用)
BaseUserManager userManager = new BaseUserManager(dbHelper);
userManager.CheckOnLine();
// 获取允许登录列表
string[] names = new string[]{BaseUserTable.FieldEnabled, BaseUserTable.FieldDeleteMark, BaseUserTable.FieldIsStaff};
Object[] values = new Object[] { 1, 0, 1 };
dataTable = userManager.GetDT(names, values);
BaseLogManager.Instance.Add(dbHelper, userInfo, MethodBase.GetCurrentMethod());
}
catch (Exception ex)
{
BaseExceptionManager.LogException(dbHelper, userInfo, ex);
throw ex;
}
finally
{
dbHelper.Close();
}

// 写入调试信息
#if (DEBUG)
BaseBusinessLogic.EndDebug(MethodBase.GetCurrentMethod(), milliStart);
#endif
return dataTable;
}
#endregion

#region public BaseUserInfo LoginBySuid(BaseUserInfo userInfo, string suid, out string statusCode, out string statusMessage) 按唯一识别码登录
/// <summary>
/// 按唯一识别码登录
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="suid">唯一识别码</param>
/// <param name="statusCode">返回状态码</param>
/// <param name="statusMessage">返回状消息</param>
/// <returns>用户实体</returns>
public BaseUserInfo LoginBySuid(BaseUserInfo userInfo, string suid, out string statusCode, out string statusMessage)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif

BaseUserInfo returnUserInfo = null;
statusCode = string.Empty;
statusMessage = string.Empty;

IDbHelper dbHelper = DbHelperFactory.GetHelper();
try
{
dbHelper.Open();
BaseUserManager userManager = new BaseUserManager(dbHelper, userInfo);
// 先侦测是否在线
userManager.CheckOnLine();
// 再进行登录
returnUserInfo = userManager.LoginBySuid(suid, userInfo.IPAddress, userInfo.MACAddress, out statusCode);
statusMessage = userManager.GetStateMessage(statusCode);
// 登录时会自动记录进行日志记录，所以不需要进行重复日志记录
// BaseLogManager.Instance.Add(dbHelper, userInfo, MethodBase.GetCurrentMethod());
}
catch (Exception ex)
{
BaseExceptionManager.LogException(dbHelper, userInfo, ex);
throw ex;
}
finally
{
dbHelper.Close();
}

// 写入调试信息
#if (DEBUG)
BaseBusinessLogic.EndDebug(MethodBase.GetCurrentMethod(), milliStart);
#endif
return returnUserInfo;
}
#endregion

#region public BaseUserInfo LoginByUserName(BaseUserInfo userInfo, string userName, out string statusCode, out string statusMessage) 按用户名登录
/// <summary>
/// 按用户名登录
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="userName">用户名</param>
/// <param name="statusCode">返回状态码</param>
/// <param name="statusMessage">返回状消息</param>
/// <returns>用户实体</returns>
public BaseUserInfo LoginByUserName(BaseUserInfo userInfo, string userName, out string statusCode, out string statusMessage)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif

BaseUserInfo returnUserInfo = null;
statusCode = string.Empty;
statusMessage = string.Empty;

IDbHelper dbHelper = DbHelperFactory.GetHelper();
try
{
dbHelper.Open();
BaseUserManager userManager = new BaseUserManager(dbHelper, userInfo);
// 先侦测是否在线
userManager.CheckOnLine();
// 再进行登录
returnUserInfo = userManager.LoginByUserName(userName, userInfo.IPAddress, userInfo.MACAddress, out statusCode);
statusMessage = userManager.GetStateMessage(statusCode);
// 登录时会自动记录进行日志记录，所以不需要进行重复日志记录
// BaseLogManager.Instance.Add(dbHelper, userInfo, MethodBase.GetCurrentMethod());
}
catch (Exception ex)
{
BaseExceptionManager.LogException(dbHelper, userInfo, ex);
throw ex;
}
finally
{
dbHelper.Close();
}

// 写入调试信息
#if (DEBUG)
BaseBusinessLogic.EndDebug(MethodBase.GetCurrentMethod(), milliStart);
#endif
return returnUserInfo;
}
#endregion

#region public BaseUserInfo UserLogin(BaseUserInfo userInfo, string userName, string password, out string statusCode, out string statusMessage) 用户登录
/// <summary>
/// 用户登录
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="userName">用户名</param>
/// <param name="password">密码</param>
/// <param name="ipAddress">IP地址</param>
/// <param name="statusCode">返回状态码</param>
/// <param name="statusMessage">返回状消息</param>
/// <returns>用户实体</returns>
public BaseUserInfo UserLogin(BaseUserInfo userInfo, string userName, string password, out string statusCode, out string statusMessage)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif

BaseUserInfo returnUserInfo = null;
statusCode = string.Empty;
statusMessage = string.Empty;

IDbHelper dbHelper = DbHelperFactory.GetHelper();
try
{
dbHelper.Open();
BaseUserManager userManager = new BaseUserManager(dbHelper, userInfo);
// 先侦测是否在线
userManager.CheckOnLine();
// 再进行登录
returnUserInfo = userManager.Login(userName, password, userInfo.IPAddress, userInfo.MACAddress, out statusCode);
if (returnUserInfo != null)
{
PermissionService permissionService = new PermissionService();
returnUserInfo.IsAdministrator = permissionService.IsAdministratorByUser(dbHelper, userInfo, returnUserInfo.Id);
}
statusMessage = userManager.GetStateMessage(statusCode);
// 登录时会自动记录进行日志记录，所以不需要进行重复日志记录
// BaseLogManager.Instance.Add(dbHelper, userInfo, MethodBase.GetCurrentMethod());
}
catch (Exception ex)
{
BaseExceptionManager.LogException(dbHelper, userInfo, ex);
throw ex;
}
finally
{
dbHelper.Close();
}

// 写入调试信息
#if (DEBUG)
BaseBusinessLogic.EndDebug(MethodBase.GetCurrentMethod(), milliStart);
#endif
return returnUserInfo;
}
#endregion

#region public void OnExit(BaseUserInfo userInfo) 用户退出应用程序
/// <summary>
/// 用户退出应用程序
/// </summary>
/// <param name="userInfo">用户</param>
public void OnExit(BaseUserInfo userInfo)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif

IDbHelper dbHelper = DbHelperFactory.GetHelper();
try
{
dbHelper.Open();
BaseLogManager.Instance.Add(dbHelper, userInfo, MethodBase.GetCurrentMethod());
BaseUserManager userManager = new BaseUserManager(dbHelper, userInfo);
userManager.OnExit(userInfo.Id);
}
catch (Exception ex)
{
BaseExceptionManager.LogException(dbHelper, userInfo, ex);
throw ex;
}
finally
{
dbHelper.Close();
}

// 写入调试信息
#if (DEBUG)
BaseBusinessLogic.EndDebug(MethodBase.GetCurrentMethod(), milliStart);
#endif
}
#endregion

#region public int ServerCheckOnLine() 服务器端检查在线状态
/// <summary>
/// 服务器端检查在线状态
/// </summary>
/// <returns>离线人数</returns>
public int ServerCheckOnLine()
{
int returnValue = 0;
IDbHelper dbHelper = DbHelperFactory.GetHelper();
try
{
dbHelper.Open();
BaseUserManager userManager = new BaseUserManager(dbHelper);
returnValue = userManager.CheckOnLine();
}
catch (Exception ex)
{
BaseInterfaceLogic.WriteException(ex);
throw ex;
}
finally
{
dbHelper.Close();
}
return returnValue;
}
#endregion

#region public int CheckOnLine(BaseUserInfo userInfo) 检查在线状态
/// <summary>
/// 检查在线状态
/// </summary>
/// <param name="userInfo">用户</param>
/// <returns>离线人数</returns>
public int CheckOnLine(BaseUserInfo userInfo)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
int returnValue = 0;

IDbHelper dbHelper = DbHelperFactory.GetHelper();
try
{
dbHelper.Open();
BaseUserManager userManager = new BaseUserManager(dbHelper);
// 设置为在线状态
userManager.OnLine(userInfo.Id);
returnValue = userManager.CheckOnLine();
}
catch (Exception ex)
{
BaseInterfaceLogic.WriteException(ex);
throw ex;
}
finally
{
dbHelper.Close();
}

// 写入调试信息
#if (DEBUG)
BaseBusinessLogic.EndDebug(MethodBase.GetCurrentMethod(), milliStart);
#endif
return returnValue;
}
#endregion

#region public DataTable GetOnLineState(BaseUserInfo userInfo) 获取在线用户列表
/// <summary>
/// 获取在线用户列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <returns>数据表</returns>
public DataTable GetOnLineState(BaseUserInfo userInfo)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
DataTable dataTable = new DataTable();

IDbHelper dbHelper = DbHelperFactory.GetHelper();
try
{
dbHelper.Open();
BaseUserManager userManager = new BaseUserManager(dbHelper, userInfo);
if (MessageService.LaseCheck == DateTime.MinValue)
{
// 设置为在线状态
userManager.OnLine(userInfo.Id);
// 检查用户在线状态(服务器专用)
userManager.CheckOnLine();
MessageService.LaseCheck = DateTime.Now;
}
else
{
// 2008.01.23 JiRiGaLa 修正错误
TimeSpan timeSpan = DateTime.Now - MessageService.LaseCheck;
if ((timeSpan.Minutes * 60 + timeSpan.Seconds) >= BaseSystemInfo.OnLineCheck)
{
// 设置为在线状态
userManager.OnLine(userInfo.Id);
// 检查用户在线状态(服务器专用)
userManager.CheckOnLine();
MessageService.LaseCheck = DateTime.Now;
}
}
// 获取在线状态列表
dataTable = userManager.GetOnLineStateDT();
// BaseLogManager.Instance.Add(dbHelper, userInfo, MethodBase.GetCurrentMethod());
}
catch (Exception ex)
{
BaseExceptionManager.LogException(dbHelper, userInfo, ex);
throw ex;
}
finally
{
dbHelper.Close();
}

// 写入调试信息
#if (DEBUG)
BaseBusinessLogic.EndDebug(MethodBase.GetCurrentMethod(), milliStart);
#endif
return dataTable;
}
#endregion

#region public int SetPassword(BaseUserInfo userInfo, string[] userIds, string password, out string statusCode, out string statusMessage) 设置密码
/// <summary>
/// 设置密码
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="userId">被设置的职员主键</param>
/// <param name="password">新密码</param>
/// <param name="statusCode">返回状态码</param>
/// <param name="statusMessage">返回状消息</param>
/// <returns>影响行数</returns>
public int SetPassword(BaseUserInfo userInfo, string[] userIds, string password, out string statusCode, out string statusMessage)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
statusCode = string.Empty;
statusMessage = string.Empty;
int returnValue = 0;

IDbHelper dbHelper = DbHelperFactory.GetHelper();
try
{
dbHelper.Open();
BaseLogManager.Instance.Add(dbHelper, userInfo, MethodBase.GetCurrentMethod());
BaseUserManager userManager = new BaseUserManager(dbHelper, userInfo);
returnValue = userManager.BatchSetPassword(userIds, password, out statusCode);
// 获得状态消息
statusMessage = userManager.GetStateMessage(statusCode);
}
catch (Exception ex)
{
BaseExceptionManager.LogException(dbHelper, userInfo, ex);
throw ex;
}
finally
{
dbHelper.Close();
}

// 写入调试信息
#if (DEBUG)
BaseBusinessLogic.EndDebug(MethodBase.GetCurrentMethod(), milliStart);
#endif
return returnValue;
}
#endregion

#region public int ChangePassword(BaseUserInfo userInfo, string oldPassword, string newPassword, out string statusCode, out string statusMessage) 修改密码
/// <summary>
/// 修改密码
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="oldPassword">原始密码</param>
/// <param name="newPassword">新密码</param>
/// <param name="statusCode">返回状态码</param>
/// <param name="statusMessage">返回状消息</param>
/// <returns>影响行数</returns>
public int ChangePassword(BaseUserInfo userInfo, string oldPassword, string newPassword, out string statusCode, out string statusMessage)
{
// 写入调试信息
#if (DEBUG)
int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
#endif
statusCode = string.Empty;
statusMessage = string.Empty;
int returnValue = 0;

IDbHelper dbHelper = DbHelperFactory.GetHelper();
try
{
dbHelper.Open();
// 事务开始
// dbHelper.BeginTransaction();
BaseLogManager.Instance.Add(dbHelper, userInfo, MethodBase.GetCurrentMethod());
BaseUserManager userManager = new BaseUserManager(dbHelper, userInfo);
returnValue = userManager.ChangePassword(oldPassword, newPassword, out statusCode);
// 获得状态消息
statusMessage = userManager.GetStateMessage(statusCode);
// 事务递交
// dbHelper.CommitTransaction();
}
catch (Exception ex)
{
// 事务回滚
// dbHelper.RollbackTransaction();
BaseExceptionManager.LogException(dbHelper, userInfo, ex);
throw ex;
}
finally
{
dbHelper.Close();
}

// 写入调试信息
#if (DEBUG)
BaseBusinessLogic.EndDebug(MethodBase.GetCurrentMethod(), milliStart);
#endif
return returnValue;
}
#endregion
}
}





WCF 客户端程序注意事项

1：如何不用一个个引用，用程序方式，实现各服务的灵活调用？

2：返回值的长度限制问题解决、如何进行设置？

3：客户端多个endpoint的定义如何设置？最少的配置文件写法？



以下是客户端的配置文件参考

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<system.serviceModel>
<client>
<endpoint address="http://localhost:8888/DotNet.Service/BusinessCardService/" binding="basicHttpBinding" bindingConfiguration="HTTP" contract="DotNet.IService.IBusinessCardService" name="DotNet.Service.BusinessCardService"></endpoint>
<endpoint address="http://localhost:8888/DotNet.Service/ExceptionService/" binding="basicHttpBinding" bindingConfiguration="HTTP" contract="DotNet.IService.IExceptionService" name="DotNet.Service.ExceptionService"></endpoint>
<endpoint address="http://localhost:8888/DotNet.Service/FileService/" binding="basicHttpBinding" bindingConfiguration="HTTP" contract="DotNet.IService.IFileService" name="DotNet.Service.FileService"></endpoint>
<endpoint address="http://localhost:8888/DotNet.Service/FolderService/" binding="basicHttpBinding" bindingConfiguration="HTTP" contract="DotNet.IService.IFolderService" name="DotNet.Service.FolderService"></endpoint>
<endpoint address="http://localhost:8888/DotNet.Service/ItemDetailsService/" binding="basicHttpBinding" bindingConfiguration="HTTP" contract="DotNet.IService.IItemDetailsService" name="DotNet.Service.ItemDetailsService"></endpoint>
<endpoint address="http://localhost:8888/DotNet.Service/ItemsService/" binding="basicHttpBinding" bindingConfiguration="HTTP" contract="DotNet.IService.IItemsService" name="DotNet.Service.ItemsService"></endpoint>
<endpoint address="http://localhost:8888/DotNet.Service/LoginService/" binding="basicHttpBinding" bindingConfiguration="HTTP" contract="DotNet.IService.ILoginService" name="DotNet.Service.LoginService"></endpoint>
<endpoint address="http://localhost:8888/DotNet.Service/LogService/" binding="basicHttpBinding" bindingConfiguration="HTTP" contract="DotNet.IService.ILogService" name="DotNet.Service.LogService"></endpoint>
<endpoint address="http://localhost:8888/DotNet.Service/MessageService/" binding="basicHttpBinding" bindingConfiguration="HTTP" contract="DotNet.IService.IMessageService" name="DotNet.Service.MessageService"></endpoint>
<endpoint address="http://localhost:8888/DotNet.Service/ModuleService/" binding="basicHttpBinding" bindingConfiguration="HTTP" contract="DotNet.IService.IModuleService" name="DotNet.Service.ModuleService"></endpoint>
<endpoint address="http://localhost:8888/DotNet.Service/OrganizeService/" binding="basicHttpBinding" bindingConfiguration="HTTP" contract="DotNet.IService.IOrganizeService" name="DotNet.Service.OrganizeService"></endpoint>
<endpoint address="http://localhost:8888/DotNet.Service/ParameterService/" binding="basicHttpBinding" bindingConfiguration="HTTP" contract="DotNet.IService.IParameterService" name="DotNet.Service.ParameterService"></endpoint>
<endpoint address="http://localhost:8888/DotNet.Service/PermissionAdminService/" binding="basicHttpBinding" bindingConfiguration="HTTP" contract="DotNet.IService.IPermissionAdminService" name="DotNet.Service.PermissionAdminService"></endpoint>
<endpoint address="http://localhost:8888/DotNet.Service/PermissionService/" binding="basicHttpBinding" bindingConfiguration="HTTP" contract="DotNet.IService.IPermissionService" name="DotNet.Service.PermissionService"></endpoint>
<endpoint address="http://localhost:8888/DotNet.Service/RoleService/" binding="basicHttpBinding" bindingConfiguration="HTTP" contract="DotNet.IService.IRoleService" name="DotNet.Service.RoleService"></endpoint>
<endpoint address="http://localhost:8888/DotNet.Service/SequenceService/" binding="basicHttpBinding" bindingConfiguration="HTTP" contract="DotNet.IService.ISequenceService" name="DotNet.Service.SequenceService"></endpoint>
<endpoint address="http://localhost:8888/DotNet.Service/StaffService/" binding="basicHttpBinding" bindingConfiguration="HTTP" contract="DotNet.IService.IStaffService" name="DotNet.Service.StaffService"></endpoint>
<endpoint address="http://localhost:8888/DotNet.Service/UserService/" binding="basicHttpBinding" bindingConfiguration="HTTP" contract="DotNet.IService.IUserService" name="DotNet.Service.UserService"></endpoint>
<endpoint address="http://localhost:8888/DotNet.Service/WorkReportService/" binding="basicHttpBinding" bindingConfiguration="HTTP" contract="DotNet.IService.IWorkReportService" name="DotNet.Service.WorkReportService"></endpoint>
</client>
<bindings>
<basicHttpBinding>
<binding name="HTTP" maxBufferPoolSize="2147483647" maxReceivedMessageSize="2147483647">
</binding>
</basicHttpBinding>
</bindings>
</system.serviceModel>
</configuration>




以下是客户端调用服务器端代码的实现参考

//------------------------------------------------------------
// All Rights Reserved , Copyright (C) 2009 , Jirisoft , Ltd.
//------------------------------------------------------------

using System.ServiceModel;

namespace DotNet.WCFClient
{
using DotNet.IService;

/// <summary>
/// ServiceFactory
/// 本地服务的具体实现接口
///
/// 修改纪录
///
/// 2009.09.20 版本：1.0 JiRiGaLa 创建。
///
/// 版本：1.0
///
/// <author>
/// <name>JiRiGaLa</name>
/// <date>2009.09.20</date>
/// </author>
/// </summary>
public class ServiceFactory : IServiceFactory
{
public ISequenceService CreateSequenceService()
{
ChannelFactory<ISequenceService> channelFactory = new ChannelFactory<ISequenceService>("DotNet.Service.SequenceService");
ISequenceService proxy = channelFactory.CreateChannel();
return proxy;
}

public IUserService CreateUserService()
{
ChannelFactory<IUserService> channelFactory = new ChannelFactory<IUserService>("DotNet.Service.UserService");
IUserService proxy = channelFactory.CreateChannel();
return proxy;
}

public ILoginService CreateLoginService()
{
ChannelFactory<ILoginService> channelFactory = new ChannelFactory<ILoginService>("DotNet.Service.LoginService");
ILoginService proxy = channelFactory.CreateChannel();
return proxy;
}

public ILogService CreateLogService()
{
ChannelFactory<ILogService> channelFactory = new ChannelFactory<ILogService>("DotNet.Service.LogService");
ILogService proxy = channelFactory.CreateChannel();
return proxy;
}

public IExceptionService CreateExceptionService()
{
ChannelFactory<IExceptionService> channelFactory = new ChannelFactory<IExceptionService>("DotNet.Service.ExceptionService");
IExceptionService proxy = channelFactory.CreateChannel();
return proxy;
}

public IPermissionAdminService CreatePermissionAdminService()
{
ChannelFactory<IPermissionAdminService> channelFactory = new ChannelFactory<IPermissionAdminService>("DotNet.Service.PermissionAdminService");
IPermissionAdminService proxy = channelFactory.CreateChannel();
return proxy;
}

public IOrganizeService CreateOrganizeService()
{
ChannelFactory<IOrganizeService> channelFactory = new ChannelFactory<IOrganizeService>("DotNet.Service.OrganizeService");
IOrganizeService proxy = channelFactory.CreateChannel();
return proxy;
}

public IItemsService CreateItemsService()
{
ChannelFactory<IItemsService> channelFactory = new ChannelFactory<IItemsService>("DotNet.Service.ItemsService");
IItemsService proxy = channelFactory.CreateChannel();
return proxy;
}

public IItemDetailsService CreateItemDetailsService()
{
ChannelFactory<IItemDetailsService> channelFactory = new ChannelFactory<IItemDetailsService>("DotNet.Service.ItemDetailsService");
IItemDetailsService proxy = channelFactory.CreateChannel();
return proxy;
}

public IModuleService CreateModuleService()
{
ChannelFactory<IModuleService> channelFactory = new ChannelFactory<IModuleService>("DotNet.Service.ModuleService");
IModuleService proxy = channelFactory.CreateChannel();
return proxy;
}

public IStaffService CreateStaffService()
{
ChannelFactory<IStaffService> channelFactory = new ChannelFactory<IStaffService>("DotNet.Service.StaffService");
IStaffService proxy = channelFactory.CreateChannel();
return proxy;
}

public IRoleService CreateRoleService()
{
ChannelFactory<IRoleService> channelFactory = new ChannelFactory<IRoleService>("DotNet.Service.RoleService");
IRoleService proxy = channelFactory.CreateChannel();
return proxy;
}

public IMessageService CreateMessageService()
{
ChannelFactory<IMessageService> channelFactory = new ChannelFactory<IMessageService>("DotNet.Service.MessageService");
IMessageService proxy = channelFactory.CreateChannel();
return proxy;
}

public IFileService CreateFileService()
{
ChannelFactory<IFileService> channelFactory = new ChannelFactory<IFileService>("DotNet.Service.FileService");
IFileService proxy = channelFactory.CreateChannel();
return proxy;
}

public IFolderService CreateFolderService()
{
ChannelFactory<IFolderService> channelFactory = new ChannelFactory<IFolderService>("DotNet.Service.FolderService");
IFolderService proxy = channelFactory.CreateChannel();
return proxy;
}

public IParameterService CreateParameterService()
{
ChannelFactory<IParameterService> channelFactory = new ChannelFactory<IParameterService>("DotNet.Service.ParameterService");
IParameterService proxy = channelFactory.CreateChannel();
return proxy;
}

public IPermissionService CreatePermissionService()
{
ChannelFactory<IPermissionService> channelFactory = new ChannelFactory<IPermissionService>("DotNet.Service.PermissionService");
IPermissionService proxy = channelFactory.CreateChannel();
return proxy;
}

public IBusinessCardService CreateBusinessCardService()
{
ChannelFactory<IBusinessCardService> channelFactory = new ChannelFactory<IBusinessCardService>("DotNet.Service.BusinessCardService");
IBusinessCardService proxy = channelFactory.CreateChannel();
return proxy;
}
}
}


程序的运行效果如下图：






以上的写法核心解决的问题有：

WCF服务器端、WCF客户端配置文件的正确写法。

多个服务的定义及调用方法。

用程序、接口的方式调用WCF服务，减少命名空间不同，无法正常调用远程WCF服务的问题，这样程序用最少的改动量，支持WCF技术了。

只要入门了，接下就是肯投入多少时间，在于研究什么细节问题了，铺平了入门的道路了，进入了轨道了，发展就快了。


将权限管理、工作流管理做到我能力的极致，一个人只能做好那么很少的几件事情。

if ($ != jQuery) {
$ = jQuery.noConflict();
}