public void connect(String url, IAudioServiceCallBack callback, EventHandler openedEvt = null, EventHandler faultEvt = null) //url = "net.tcp://localhost:8080/AudioService"
{
try
{
duplex = new DuplexChannelFactory<IAudioService>(callback, new NetTcpBinding(),
new EndpointAddress(url));
service = duplex.CreateChannel();
channel = (ICommunicationObject)service;
IClientChannel c = (IClientChannel)channel;
c.OperationTimeout = TimeSpan.FromSeconds(5);
channel.Opened += new EventHandler(delegate(object o, EventArgs e)
{
Console.WriteLine("Connection ok!");
});
if(openedEvt != null)
channel.Opened += openedEvt;
if(faultEvt != null)
channel.Faulted += faultEvt;
channel.Faulted += new EventHandler(delegate(object o, EventArgs e)
{
Console.WriteLine("Connection lost");
});
}
catch (Exception e)
{
Console.WriteLine("Connection error: " + e.Message);
}
}
public void BeginTest()
{
repo = new MockRepository();
channelFactory = repo.StrictMock<ICanCreateChannels<IService>>();
communicationObject = repo.StrictMultiMock<ICommunicationObject>(typeof(IService));
manager = new SingleActionChannelManager<IService>(channelFactory);
}
/// <summary>
/// Creates a new client channel if the communication object is null or
/// is faulted, closed or closing.
/// </summary>
private void InitChannel()
{
lock (_padlock)
{
if (_commObj == null ||
(_commObj.State != CommunicationState.Opened &&
_commObj.State != CommunicationState.Opening))
{
if (!string.IsNullOrEmpty(_configurationName))
{
_client = new ChannelFactory<IProxyTraceService>(_configurationName).CreateChannel();
}
else
{
// Todo - is None really the best choice of security mode?
// maybe we should secure the transport by default???
NetNamedPipeBinding binding = new NetNamedPipeBinding(NetNamedPipeSecurityMode.None);
EndpointAddress address = new EndpointAddress(DefaultEndpointAddress);
_client = ChannelFactory<IProxyTraceService>.CreateChannel(binding, address);
}
_commObj = (ICommunicationObject)_client;
}
}
}
public static void CloseCommunicationObject(ICommunicationObject communicationObject, TimeSpan timeout)
{
if (communicationObject == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("communicationObject");
}
bool flag = true;
try
{
if (communicationObject.State == CommunicationState.Opened)
{
communicationObject.Close(timeout);
flag = false;
}
}
catch (CommunicationException communicatioException)
{
DiagnosticUtility.TraceHandledException(communicatioException, TraceEventType.Information);
}
catch (TimeoutException timeoutException)
{
DiagnosticUtility.TraceHandledException(timeoutException, TraceEventType.Information);
}
finally
{
if (flag)
{
communicationObject.Abort();
}
}
}
/// <summary>
/// The constructor.
/// </summary>
/// <param name="binding">The binding.</param>
/// <param name="endpointAddress">The endpoint address.</param>
/// <param name="hostReconnectIntervalMilliseconds">The cache host reconnect interval, in milliseconds.</param>
public CommunicationClient(Binding binding, EndpointAddress endpointAddress, int hostReconnectIntervalMilliseconds)
{
// Sanitize
if (binding == null)
{
throw new ArgumentNullException("binding");
}
if (endpointAddress == null)
{
throw new ArgumentNullException("endpointAddress");
}
if (hostReconnectIntervalMilliseconds <= 0)
{
throw new ArgumentException("must be greater than 0", "hostReconnectIntervalMilliseconds");
}
// Initialize the channel factory with the binding and endpoint address
_channelFactory = new ChannelFactory<IClientToCacheContract>(binding, endpointAddress);
// Set the cache host reconnect interval
_hostReconnectIntervalMilliseconds = hostReconnectIntervalMilliseconds;
// Initialize WCF
_proxy = _channelFactory.CreateChannel();
_proxyComm = _proxy as ICommunicationObject;
// Set connected before opening to avoid a race
_isConnected = true;
// Initialize and configure the reconnect timer to never fire
_reconnectTimer = new Timer(ReconnectToServer, null, Timeout.Infinite, Timeout.Infinite);
}
/// <summary>
/// Stores the given value into backing store for retrieval later.
/// </summary>
/// <param name="newValue">The object being stored.</param>
protected override void SynchronizedSetValue(object newValue)
{
_communicationObject = newValue as ICommunicationObject;
if (_communicationObject == null)
throw new InvalidOperationException(
"newValue is not an ICommunicationObject. The ContainerControlledCommunicationObjectLifetimeManager is only meant to be used for WCF channels and other communication objects.");
}
// ReSharper restore MemberCanBePrivate.Global
#endregion
#region Protected Methods
private void CloseProxy(ICommunicationObject co)
{
if (!m_Disposed)
{
CommunicationProxyHelper.Close(co);
}
}
protected RandomDelaySendsAsyncResult(int numSends, TimeSpan maxDelay, ICommunicationObject channel, Random random, AsyncCallback callback, object state)
: base(callback, state)
{
Fx.Assert(numSends > 0, "The numSends must be positive.");
Fx.Assert(maxDelay >= TimeSpan.Zero, "The maxDelay must be non negative.");
this.onTimerCallback = new Action<object>(OnTimer);
this.onSendCompletedCallback = Fx.ThunkCallback(new AsyncCallback(OnSendCompleted));
this.channel = channel;
if (this.channel != null)
{
this.onCloseCompletedCallback = Fx.ThunkCallback(new AsyncCallback(OnCloseCompleted));
}
this.numSends = numSends;
this.maxDelay = maxDelay;
this.completesCounter = 0;
this.sendCompletesCounter = 0;
this.cancelled = false;
this.thisLock = new object();
if (maxDelay != TimeSpan.Zero)
{
this.delaysInTicks = new long[numSends];
Random innerRandom = (random != null) ? random : new Random();
for (int i = 0; i < this.numSends; i++)
{
this.delaysInTicks[i] = RandomDelay(innerRandom, maxDelay.Ticks);
}
Array.Sort<long>(this.delaysInTicks);
}
}
/// <summary>Disposes the service client. </summary>
/// <param name="service">The service client. </param>
/// <param name="isDisposed">The reference to a value indicating whether the service is disposed. </param>
public static void Dispose(ICommunicationObject service, ref bool isDisposed)
{
if (isDisposed)
return;
try
{
if (service.State == CommunicationState.Faulted)
service.Abort();
else
{
try
{
service.Close();
}
catch (Exception closeException)
{
try
{
service.Abort();
}
catch (Exception abortException)
{
throw new AggregateException(closeException, abortException);
}
throw;
}
}
}
finally
{
isDisposed = true;
}
}
private static Task OpenAsync(ICommunicationObject commObj)
{
return Task.Factory.FromAsync(
(c, s) => ((ICommunicationObject)s).BeginOpen(c, s),
r => ((ICommunicationObject)r.AsyncState).EndOpen(r),
commObj);
}
public OrationiSlave()
{
Binding binding = new NetTcpBinding(SecurityMode.None);
EndpointAddress defaultEndpointAddress = new EndpointAddress("net.tcp://localhost:57344/Orationi/Master/v1/");
EndpointAddress discoveredEndpointAddress = DiscoverMaster();
ContractDescription contractDescription = ContractDescription.GetContract(typeof(IOrationiMasterService));
ServiceEndpoint serviceEndpoint = new ServiceEndpoint(contractDescription, binding, discoveredEndpointAddress ?? defaultEndpointAddress);
var channelFactory = new DuplexChannelFactory<IOrationiMasterService>(this, serviceEndpoint);
try
{
channelFactory.Open();
}
catch (Exception ex)
{
channelFactory?.Abort();
}
try
{
_masterService = channelFactory.CreateChannel();
_communicationObject = (ICommunicationObject)_masterService;
_communicationObject.Open();
}
catch (Exception ex)
{
if (_communicationObject != null && _communicationObject.State == CommunicationState.Faulted)
_communicationObject.Abort();
}
}
/// <summary>
/// Creates a <see cref="Scope"/> that safely closes the specified <see cref="ICommunicationObject"/>.
/// </summary>
/// <remarks>The Scope, when disposed, will Close or Abort the session, as appropriate. </remarks>
/// <param name="client">The client.</param>
/// <returns></returns>
public static Scope CreateScope(ICommunicationObject client)
{
if (client == null)
throw new ArgumentNullException("client");
return Scope.Create(() => client.CloseOrAbort());
}
protected override void OnStop()
{
if (CommunicationObject != null)
{
CommunicationObject.Close();
CommunicationObject = null;
}
base.OnStop();
}
public void Init()
{
_browserApi = Substitute.For<IBrowsersManagerApi, ICommunicationObject>();
_serviceStarter = Substitute.For<IServiceBuilder<IBrowsersManagerApi>>();
_serviceStarter.CreateServiceAndTryToConnect().Returns(_browserApi);
_uiHelper = Substitute.For<IUiHelper>();
_log = Substitute.For<ILogger>();
_communicationObject = (ICommunicationObject)_browserApi;
_browserWindowsCommunicator = new BrowserWindowsCommunicator(_serviceStarter, _uiHelper, _log);
}
internal static void Abort(ICommunicationObject commObj, object identifier)
{
if (TD.RoutingServiceAbortingChannelIsEnabled())
{
TD.RoutingServiceAbortingChannel(identifier != null ? identifier.ToString() : string.Empty);
}
//The Exception contract for ICommunicationObject.Abort is to never throw, anything else is a fatal error.
commObj.Abort();
}
public void Init()
{
_service = Substitute.For<IBrowsersManagerApi, ICommunicationObject>();
_serviceStarter = Substitute.For<IServiceBuilder<IBrowsersManagerApi>>();
_serviceStarter.CreateServiceAndTryToConnect().Returns(_service);
_uiHelper = Substitute.For<IUiHelper>();
_log = Substitute.For<ILogger>();
_communicationObject = (ICommunicationObject)_service;
_serviceClient = new AbstractServiceClient<IBrowsersManagerApi>(_serviceStarter, _uiHelper, _log);
}
public static void CloseClient(ICommunicationObject client)
{
if (client != null && client.State == CommunicationState.Faulted)
{
client.Abort();
}
else
{
client.Close();
}
}
public FileSaver(Entity.UserIdentity userIdentity, IFileInfoProvider fileInfoProvider, bool useTempFile)
{
_userIdentity = userIdentity;
_fileInfoProvider = fileInfoProvider;
_useTempFile = useTempFile;
if (OperationContext.Current != null && OperationContext.Current.Channel != null)
{
_communicationObject = OperationContext.Current.Channel;
_communicationObject.Faulted += new EventHandler(Abort);
}
_beginTime = DateTime.Now;
}
/// <summary>
/// Disposes the Lifetime manager an the attached communication object.
/// </summary>
/// <param name="disposing"></param>
protected virtual void Dispose(bool disposing)
{
if (_communicationObject != null)
{
ChannelHelper.ProperClose(_communicationObject);
var disposable = _communicationObject as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
_communicationObject = null;
}
}
/// <summary>
/// 查找记录表中最旧的一条记录
/// </summary>
/// <returns></returns>
public virtual T FindFirst()
{
T result = null;
IBaseService <T> service = CreateClient();
ICommunicationObject comm = service as ICommunicationObject;
comm.Using(client =>
{
result = service.FindFirst();
});
return(result);
}
public void CreateNewChannel()
{
Channel = _factory.CreateChannel();
ICommunicationObject c = Channel as ICommunicationObject;
if (null == c)
{
throw new ArgumentException(
typeof(T) + " Can not be used as an ICommunicationObject");
}
c.Closed += OnClose;
c.Faulted += OnFaulted;
c.Open();
}
public List <MenuInfo> GetTopMenu(string systemType)
{
List <MenuInfo> result = new List <MenuInfo>();
IMenuService service = CreateSubClient();
ICommunicationObject comm = service as ICommunicationObject;
comm.Using(client =>
{
result = service.GetTopMenu(systemType);
});
return(result);
}
/// <summary>
/// 医疗绩效奖金明细表
/// </summary>
public List <YljxkhInfo> Yljxkh_FWP(int intRecordCount, int intPageSize, int intPageCount, string where)
{
List <YljxkhInfo> result = new List <YljxkhInfo>();
IYljxkhService service = CreateSubClient();
ICommunicationObject comm = service as ICommunicationObject;
comm.Using(client =>
{
result = service.Yljxkh_FWP(intRecordCount, intPageSize, intPageCount, where);
});
return(result);
}
/// <summary>
/// Checks that the service is initialized and raises an exception when it isn't
/// </summary>
/// <param name="comObject">The communication object to verify initialization</param>
/// <returns>True if the object is initialized, false if the object was opened</returns>
/// <exception cref="InvalidOperationException">When the client didn't initialize
/// </exception>
private bool CheckInitialized(ICommunicationObject comObject)
{
if (comObject == null)
{
throw new InvalidOperationException("Must call Initialize first");
}
else if (comObject.State == CommunicationState.Created)
{
comObject.Open();
proxies.Add(comObject);
return(false);
}
return(true);
}
/// <summary>
/// Returns an observable sequence of terminating state changes for the <see cref="ICommunicationObject"/>.
/// </summary>
/// <param name="obj">An object that transitions between states.</param>
/// <returns>An observable sequence that contains <see cref="CommunicationState"/> values representing the
/// terminating states (<see cref="CommunicationState.Closing"/>, <see cref="CommunicationState.Closed"/>
/// and <see cref="CommunicationState.Faulted"/>) of the <see cref="ICommunicationObject"/> as it transitions
/// between them.</returns>
/// <seealso href="http://msdn.microsoft.com/en-us/library/ms789041.aspx"/>
public static IObservable <CommunicationState> TerminationObservable(this ICommunicationObject obj)
{
Contract.Requires(obj != null);
Contract.Ensures(Contract.Result <IObservable <CommunicationState> >() != null);
return(Observable.Defer(() =>
{
var closed = obj.ClosedObservable().PublishLast().RefCount();
var closing = obj.ClosingObservable().TakeUntil(closed).PublishLast().RefCount();
var faulted = obj.FaultedObservable().TakeUntil(closing.Amb(closed)).PublishLast().RefCount();
return faulted.Merge(closing.Concat(closed));
}));
}
/// <summary>
/// 根据指定条件,从数据库中删除指定对象
/// </summary>
/// <param name="condition">删除记录的条件语句</param>
/// <returns>执行成功返回<c>true</c>，否则为<c>false</c>。</returns>
public virtual bool DeleteByCondition(string condition)
{
bool result = false;
IBaseService <T> service = CreateClient();
ICommunicationObject comm = service as ICommunicationObject;
comm.Using(client =>
{
result = service.DeleteByCondition(condition);
});
return(result);
}
private static IObservable <CommunicationState> CreatedObservable(this ICommunicationObject obj)
{
Contract.Requires(obj != null);
Contract.Ensures(Contract.Result <IObservable <CommunicationState> >() != null);
if (obj.State == CommunicationState.Created)
{
return(Observable.Return(CommunicationState.Created));
}
else
{
return(Observable.Empty <CommunicationState>());
}
}
public List <MenuNodeInfo> GetTreeByID(string mainMenuID)
{
List <MenuNodeInfo> result = new List <MenuNodeInfo>();
IMenuService service = CreateSubClient();
ICommunicationObject comm = service as ICommunicationObject;
comm.Using(client =>
{
result = service.GetTreeByID(mainMenuID);
});
return(result);
}
public bool SaveExcelData(List <TableMappingInfo> list)
{
bool result = false;
ITableMappingService service = CreateSubClient();
ICommunicationObject comm = service as ICommunicationObject;
comm.Using(client =>
{
result = service.SaveExcelData(list);
});
return(result);
}
/// <summary>
/// 根据条件查询数据库,如果存在返回第一个对象
/// </summary>
/// <param name="condition">查询的条件</param>
/// <param name="orderBy">排序条件</param>
/// <returns>指定的对象</returns>
public virtual T FindSingle2(string condition, string orderBy)
{
T result = null;
IBaseService <T> service = CreateClient();
ICommunicationObject comm = service as ICommunicationObject;
comm.Using(client =>
{
result = service.FindSingle2(condition, orderBy);
});
return(result);
}
/// <summary>
/// 插入指定对象到数据库中
/// </summary>
/// <param name="obj">指定的对象</param>
/// <returns>执行成功返回新增记录的自增长ID。</returns>
public virtual int Insert2(T obj)
{
int result = -1;
IBaseService <T> service = CreateClient();
ICommunicationObject comm = service as ICommunicationObject;
comm.Using(client =>
{
result = service.Insert2(obj);
});
return(result);
}
/// <summary>
/// 更新某个表一条记录(只适用于用单键)
/// </summary>
/// <param name="recordField">Hashtable:键[key]为字段名;值[value]为字段对应的值</param>
/// <param name="primaryKeyValue">主键的值</param>
public virtual bool UpdateFields(Hashtable recordField, object primaryKeyValue)
{
bool result = false;
IBaseService <T> service = CreateClient();
ICommunicationObject comm = service as ICommunicationObject;
comm.Using(client =>
{
result = service.UpdateFields(recordField, primaryKeyValue);
});
return(result);
}
/// <summary>
/// 如果不存在记录，则插入对象属性到数据库中
/// </summary>
/// <param name="obj">指定的对象</param>
/// <param name="primaryKeyValue">主键的值</param>
/// <returns>执行插入成功返回<c>true</c>，否则为<c>false</c>。</returns>
public virtual bool InsertIfNew(T obj, object primaryKeyValue)
{
bool result = false;
IBaseService <T> service = CreateClient();
ICommunicationObject comm = service as ICommunicationObject;
comm.Using(client =>
{
result = service.InsertIfNew(obj, primaryKeyValue);
});
return(result);
}
/// <summary>
/// 医疗绩效奖金明细表Calculate
/// </summary>
public DataTable Yljxjjmx_Cal(string strYear, string strMonth, string strKSID, string strZXZD_ID)
{
DataTable result = new DataTable();
IYljxjjmxService service = CreateSubClient();
ICommunicationObject comm = service as ICommunicationObject;
comm.Using(client =>
{
result = service.Yljxjjmx_Cal(strYear, strMonth, strKSID, strZXZD_ID);
});
return(result);
}
/// <summary>
/// 根据ID字符串(逗号分隔)获取对象列表
/// </summary>
/// <param name="idString">ID字符串(逗号分隔)</param>
/// <returns>符合条件的对象列表</returns>
public virtual List <T> FindByIDs(string idString)
{
List <T> result = new List <T>();
IBaseService <T> service = CreateClient();
ICommunicationObject comm = service as ICommunicationObject;
comm.Using(client =>
{
result = service.FindByIDs(idString);
});
return(result);
}
/// <summary>
/// 返回数据库所有的对象集合
/// </summary>
/// <param name="orderBy">自定义排序语句，如Order By Name Desc；如不指定，则使用默认排序</param>
/// <returns>指定对象的集合</returns>
public virtual List <T> GetAll2(string orderBy)
{
List <T> result = new List <T>();
IBaseService <T> service = CreateClient();
ICommunicationObject comm = service as ICommunicationObject;
comm.Using(client =>
{
result = service.GetAll2(orderBy);
});
return(result);
}
/// <summary>
/// 获取表的所有记录数量
/// </summary>
/// <returns></returns>
public virtual int GetRecordCount()
{
int result = 0;
IBaseService <T> service = CreateClient();
ICommunicationObject comm = service as ICommunicationObject;
comm.Using(client =>
{
result = service.GetRecordCount();
});
return(result);
}
/// <summary>
/// 执行SQL查询语句，返回所有记录的DataTable集合。
/// </summary>
/// <param name="sql">SQL查询语句</param>
/// <returns></returns>
public virtual DataTable SqlTable(string sql)
{
DataTable result = new DataTable();
IBaseService <T> service = CreateClient();
ICommunicationObject comm = service as ICommunicationObject;
comm.Using(client =>
{
result = service.SqlTable(sql);
});
return(result);
}
private void CloseChannel(ICommunicationObject channel)
{
try
{
channel.Close();
}
catch (Exception ex)
{
}
finally
{
channel.Abort();
}
}
public List <MenuNodeInfo> GetTreeFunction(string systemType, string Functions)
{
List <MenuNodeInfo> result = new List <MenuNodeInfo>();
IMenuService service = CreateSubClient();
ICommunicationObject comm = service as ICommunicationObject;
comm.Using(client =>
{
result = service.GetTreeFunction(systemType, Functions);
});
return(result);
}
public ServerSideFileReceive(UserIdentity userIdentity, /*IResourceEx<T> resourceEx*/IFileInfoProvider provider)
{
//_resourceEx = resourceEx;
_userIdentity = userIdentity;
//Resource = resource;
_provider = provider;
//_resourceFileInfo = _resource.ResourceInfo as ResourceFileInfo;
if (OperationContext.Current != null && OperationContext.Current.Channel != null)
{
_communicationObject = OperationContext.Current.Channel;
_communicationObject.Faulted += new EventHandler(Abort);
}
}
/// <summary>
/// Safely disposes the channel by either closing or aborting it.
/// </summary>
/// <param name="communicationObject">The channel to dispose.</param>
/// <param name="logger">A logger to be used for logging purposes.</param>
/// <exception cref="ArgumentNullException">The <paramref name="communicationObject"/> is null.</exception>
public static async Task DisposeChannelAsync(this ICommunicationObject communicationObject, ILogger?logger = null)
{
_ = communicationObject ?? throw new ArgumentNullException(nameof(communicationObject));
logger ??= NullLogger.Instance;
try
{
switch (communicationObject.State)
{
case CommunicationState.Opened:
logger.LogDebug("Closing connection");
await communicationObject.CloseAsync().ConfigureAwait(false);
break;
case CommunicationState.Faulted:
logger.LogDebug("Aborting connection");
communicationObject.Abort();
break;
case CommunicationState.Closed:
case CommunicationState.Closing:
case CommunicationState.Created:
case CommunicationState.Opening:
break;
default:
throw new InvalidOperationException($"The channel is in an unexpected state: {communicationObject.State:G}");
}
}
catch (CommunicationException ex)
{
logger.LogError(ex, "An error occurred while closing the connection");
communicationObject.Abort();
}
catch (TimeoutException ex)
{
logger.LogError(ex, "An error occurred while closing the connection");
communicationObject.Abort();
}
catch (Exception ex)
{
logger.LogError(ex, "An error occurred while closing the connection");
communicationObject.Abort();
throw;
}
}
/// <summary>
/// 获取座位使用状态
/// </summary>
/// <param name="seatNo"></param>
/// <returns></returns>
public static EnterOutLogType GetSeatUsedState(string seatNo)
{
IWCFService.ISeatManageService seatService = WcfAccessProxy.ServiceProxy.CreateChannelSeatManageService();
bool error = false;
try
{
EnterOutLogInfo model = seatService.GetEnterOutLogInfoWithBookWaitBySeatNum(seatNo);
if (model != null)
{
SeatManage.EnumType.EnterOutLogType type = model.EnterOutState;
return(type);
}
else
{
List <BespeakLogInfo> bespeakLogs = seatService.GetBespeakLogInfoBySeatNo(seatNo, DateTime.Now);
if (bespeakLogs.Count > 0 && bespeakLogs[0].BsepeakState == SeatManage.EnumType.BookingStatus.Waiting)
{
return(EnterOutLogType.BespeakWaiting);
}
return(EnterOutLogType.None);
}
}
catch (Exception ex)
{
error = true;
SeatManageComm.WriteLog.Write("获取座位状态失败：" + ex.Message);
return(EnterOutLogType.None);
}
finally
{
ICommunicationObject ICommObjectService = seatService as ICommunicationObject;
try
{
if (ICommObjectService.State == CommunicationState.Faulted)
{
ICommObjectService.Abort();
}
else
{
ICommObjectService.Close();
}
}
catch
{
ICommObjectService.Abort();
}
}
}
public void Subscribe(SubscribeArg arg)
{
var newClientInfo = GetClientInfo();
var callback = OperationContext.Current.GetCallbackChannel <IEventCallback>();
arg.Username = arg.Username.ToLower();
if (!_Subscribers.ContainsKey(arg.Username))
{
_Subscribers[arg.Username] = new SubscribeContext()
{
Arg = arg, Callback = callback, Address = newClientInfo.Item1, Port = newClientInfo.Item2
};
}
else
{
if (_Subscribers[arg.Username].Address != newClientInfo.Item1 || _Subscribers[arg.Username].Port != newClientInfo.Item2)
{
_Subscribers[arg.Username] = new SubscribeContext()
{
Arg = arg, Callback = callback, Address = newClientInfo.Item1, Port = newClientInfo.Item2
};
}
}
ICommunicationObject obj = (ICommunicationObject)callback;
obj.Closed += (sender, args) =>
{
//current client closed, do nothing.
};
obj.Faulted += (sender, args) =>
{
//To do:
//Record error
};
obj.Closing += (sender, args) =>
{
var currentCallback = sender as IEventCallback;
_Subscribers.ToList().ForEach(context =>
{
if (context.Value.Callback == currentCallback)
{
RemoveSubscriber(context.Value.Arg.Username);
ClientLostEvent?.Invoke(arg);
}
});
};
NewClientSubscribedEvent?.Invoke(arg);
}
private void CloseOrAbortServiceChannelAndPerformExceptionBehaviours(ICommunicationObject communicationObject)
{
// Stop recursive or multiple calls
if (this.isClosing || communicationObject == null || communicationObject.State == CommunicationState.Closed)
{
return;
}
this.isClosing = true;
bool isClosed = false;
Exception closeException = null;
try
{
if (communicationObject.State != CommunicationState.Faulted)
{
this.OnClosingChannel();
communicationObject.Close();
isClosed = true;
this.OnClosedChannel();
}
}
catch (Exception ex)
{
// Handle the race condition where it might have faulted just after the If above.
closeException = ex;
}
finally
{
if (closeException != null)
{
this.TryToPerformCloseExceptionBehaviours(closeException);
}
// If the channel has not been closed yet because:
// - State was Faulted; or
// - An exception occurred while doing the Close()
// Then do an Abort()
if (!isClosed)
{
this.AbortServiceChannel(communicationObject);
}
this.DisposeChannel();
}
}
private void CloseOrAbortService()
{
if (this._wcfService == null)
{
return;
}
ICommunicationObject wcfService = this._wcfService as ICommunicationObject;
try
{
if (wcfService != null)
{
if (wcfService.State != CommunicationState.Faulted)
{
wcfService.Close();
}
else
{
wcfService.Abort();
}
}
}
catch (CommunicationException)
{
if (wcfService != null)
{
wcfService.Abort();
}
}
catch (TimeoutException)
{
if (wcfService != null)
{
wcfService.Abort();
}
}
catch
{
if (wcfService != null)
{
wcfService.Abort();
}
}
finally
{
this._wcfService = null;
}
}
/// <summary>
/// 根据查询条件删除违规记录
/// </summary>
/// <param name="begDate">开始日期</param>
/// <param name="endDate">结束日期</param>
/// <param name="roomNo">阅览室编号</param>
/// <returns></returns>
public static int DelBySearch(string begDate, string endDate, string roomNo)
{
IWCFService.ISeatManageService seatService = WcfAccessProxy.ServiceProxy.CreateChannelSeatManageService();
List <ViolationRecordsLogInfo> vlists = seatService.GetViolationRecordsLogs(null, roomNo, begDate + " 0:00:00", endDate + " 23:59:59", SeatManage.EnumType.LogStatus.Valid, SeatManage.EnumType.LogStatus.None);
bool error = false;
List <int> lst = new List <int>();
try
{
if (vlists.Count > 0)
{
foreach (ViolationRecordsLogInfo vlist in vlists)
{
vlist.Flag = SeatManage.EnumType.LogStatus.Fail;
seatService.UpdateViolationRecordsLog(vlist);
//SeatManage.ClassModel.ReaderNoticeInfo rni = new SeatManage.ClassModel.ReaderNoticeInfo();
//rni.CardNo = vlist.CardNo;
//rni.Note = string.Format("{0}记录的违规，{1}，被管理员手动移除", vlist.EnterOutTime, vlist.Remark);
//SeatManage.Bll.T_SM_ReaderNotice.AddReaderNotice(rni);
}
}
return(vlists.Count);
}
catch (Exception ex)
{
error = true;
SeatManageComm.WriteLog.Write("修改违规记录失败：" + ex.Message);
return(-1);
}
finally
{
ICommunicationObject ICommObjectService = seatService as ICommunicationObject;
try
{
if (ICommObjectService.State == CommunicationState.Faulted)
{
ICommObjectService.Abort();
}
else
{
ICommObjectService.Close();
}
}
catch
{
ICommObjectService.Abort();
}
}
}
/// <summary>
/// 返回数据库所有的对象集合(用于分页数据显示)
/// </summary>
/// <param name="info">分页实体信息</param>
/// <returns>指定对象的集合</returns>
public virtual List <T> GetAllWithPager(ref PagerInfo info)
{
List <T> result = new List <T>();
IBaseService <T> service = CreateClient();
ICommunicationObject comm = service as ICommunicationObject;
PagerInfo pagerInfo = info;
comm.Using(client =>
{
result = service.GetAllWithPager(ref pagerInfo);
});
info.RecordCount = pagerInfo.RecordCount;
return(result);
}
// TODO - document
public static void DisposeSafely(this ICommunicationObject communicationObject)
{
if (communicationObject.State == CommunicationState.Faulted)
{
communicationObject.Abort();
}
else
{
communicationObject.Close();
}
if (communicationObject is IDisposable disposable)
{
disposable.Dispose();
}
}
private void CloseProxy(ICommunicationObject proxy)
{
if (proxy == null)
{
throw new ArgumentNullException();
}
if (proxy.State == CommunicationState.Faulted)
{
proxy.Abort();
}
else
{
proxy.Close();
}
}
void ICommunicationObject1_Faulted(object sender, EventArgs e)
{
Program.AASServiceClient = new AASServiceReference.AASServiceClient(Program.callbackInstance, Program.NetTcpBinding, Program.EndpointAddress);
Program.AASServiceClient.ClientCredentials.ServiceCertificate.Authentication.CertificateValidationMode = System.ServiceModel.Security.X509CertificateValidationMode.None;
Program.AASServiceClient.ClientCredentials.UserName.UserName = this.comboBox用户名.Text;
Program.AASServiceClient.ClientCredentials.UserName.Password = this.textBox密码.Text + "\t" + this.MAC;
ICommunicationObject ICommunicationObject1 = Program.AASServiceClient as ICommunicationObject;
ICommunicationObject1.Faulted += ICommunicationObject1_Faulted;
ICommunicationObject1.Closed += ICommunicationObject1_Closed;
}
private static void CloseClient(ICommunicationObject client)
{
if (client.State == CommunicationState.Opened)
{
try
{
client.Close();
}
catch (CommunicationException)
{
client.Abort();
}
catch (TimeoutException)
{
client.Abort();
}
}
}
public Result Execute(ICommunicationObject client, string service, System.Reflection.MethodBase method, params object[] data)
{
RemoteInvokeArgs info = new RemoteInvokeArgs();
info.Interface = service;
int index = method.Name.LastIndexOf('.');
index = index>0?(index+1):0;
info.Method = method.Name.Substring(index, method.Name.Length - index);
info.Parameters = data;
info.CommunicationObject = client;
info.ParameterInfos = method.GetParameters();
foreach (System.Reflection.ParameterInfo pi in method.GetParameters())
{
info.ParameterTypes.Add(pi.ParameterType.Name);
}
return Handler.Execute(info);
}
/// <summary>
/// Initializes an instance of <see cref="WrappedRsaSecurityTokenAuthenticator"/>
/// </summary>
/// <param name="sessionTokenHandler">The sessionTokenHandler to wrap</param>
/// <param name="wcfSessionAuthenticator">The wcf SessionTokenAuthenticator.</param>
/// <param name="sctClaimsHandler">Handler that converts WCF generated IAuthorizationPolicy to <see cref="AuthorizationPolicy"/></param>
/// <param name="exceptionMapper">Converts token validation exception to SOAP faults.</param>
public WrappedSessionSecurityTokenAuthenticator( SessionSecurityTokenHandler sessionTokenHandler,
SecurityTokenAuthenticator wcfSessionAuthenticator,
SctClaimsHandler sctClaimsHandler,
ExceptionMapper exceptionMapper )
: base()
{
if ( sessionTokenHandler == null )
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull( "sessionTokenHandler" );
}
if ( wcfSessionAuthenticator == null )
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull( "wcfSessionAuthenticator" );
}
if ( sctClaimsHandler == null )
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull( "sctClaimsHandler" );
}
if ( exceptionMapper == null )
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull( "exceptionMapper" );
}
_issuanceSecurityTokenAuthenticator = wcfSessionAuthenticator as IIssuanceSecurityTokenAuthenticator;
if ( _issuanceSecurityTokenAuthenticator == null )
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperInvalidOperation( SR.GetString( SR.ID4244 ) );
}
_communicationObject = wcfSessionAuthenticator as ICommunicationObject;
if ( _communicationObject == null )
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperInvalidOperation( SR.GetString( SR.ID4245 ) );
}
_sessionTokenHandler = sessionTokenHandler;
_sctClaimsHandler = sctClaimsHandler;
_exceptionMapper = exceptionMapper;
}
private void CompleteClose(ICommunicationObject communicationObject, IAsyncResult result)
{
Exception closeException = null;
try
{
communicationObject.EndClose(result);
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
closeException = e;
communicationObject.Abort();
}
Decrement(result.CompletedSynchronously, closeException);
}
public static void Close(ICommunicationObject co)
{
if (co == null)
{
return;
}
try
{
switch (co.State)
{
case CommunicationState.Closed:
case CommunicationState.Closing:
break;
case CommunicationState.Faulted:
co.Abort();
break;
case CommunicationState.Created:
case CommunicationState.Opened:
case CommunicationState.Opening:
co.Close();
break;
default:
co.Abort();
break;
}
}
catch (Exception e)
{
s_Logger.Fatal(co, e);
// ReSharper disable EmptyGeneralCatchClause
try
{
co.Abort();
}
catch
{
}
// ReSharper restore EmptyGeneralCatchClause
}
}
private static async Task CloseAsync(ICommunicationObject commObj)
{
try
{
await Task.Factory.FromAsync(
(c, s) => ((ICommunicationObject)s).BeginClose(c, s),
r => ((ICommunicationObject)r.AsyncState).EndClose(r),
commObj);
commObj = null;
}
catch (CommunicationException)
{
}
catch (TimeoutException)
{
}
if (commObj != null)
{
commObj.Abort();
}
}
private void Done()
{
if (_communicationObject != null)
{
_communicationObject.Faulted -= Abort;
_communicationObject = null;
}
}
public CallbackState(CloseCollectionAsyncResult result, ICommunicationObject instance)
{
_result = result;
_instance = instance;
}
//public IPresentationDAL PresentationDAL{get; set;}
#region ILockService Members
public bool AcquireLock(ICommunicationObject communicationObject, UserIdentity user, ObjectKey objectKey, RequireLock requireLock)
{
return _lockingStorage.AcquireLock(communicationObject, user, objectKey, requireLock);
}
