/// <summary> /// 关闭通道连接并释放资源 /// </summary> /// <example>WcfClientProxy.CloseAndDispose((IClientChannel)_IService);</example> /// <param name="serviceProxy">代理实例</param> public static void CloseAndDispose(IClientChannel serviceProxy) { if (serviceProxy == null) { return; } try { if (serviceProxy.State == CommunicationState.Opened) { serviceProxy.Close(); } serviceProxy.Dispose(); } catch (CommunicationException) { serviceProxy.Abort(); } catch (TimeoutException) { serviceProxy.Abort(); } catch (Exception) { serviceProxy.Abort(); //throw; ///todo:未知异常,暂不抛出,考虑记录日志 } finally { serviceProxy = null; } }
public void unregisterSeller(Uri request, string name) { if (FlightSearchLogic.Instance.delegates.ContainsKey(name)) { ISellerService tsqs; bool gotValue = FlightSearchLogic.Instance.delegates.TryGetValue(name, out tsqs); if (gotValue) { IClientChannel currChannel = (IClientChannel)tsqs; try { currChannel.Close(); currChannel.Abort(); } catch (Exception) { currChannel.Abort(); Console.WriteLine("Closing of stale channel {0} failed, ignoring", currChannel.RemoteAddress.Uri.ToString()); } ISellerService victimChannel; FlightSearchLogic.Instance.delegates.TryRemove(name, out victimChannel); Console.WriteLine("Successfully remove old seller {0} by name", name); } } }
public static TResultType CallFunc(Func <TFuncType, TResultType> func, IClientChannel proxy) { try { return(func((TFuncType)proxy)); } catch (CommunicationException ex) { proxy.Abort(); throw ex; } catch (TimeoutException ex) { proxy.Abort(); throw ex; } catch (Exception ex) { proxy.Abort(); throw ex; } finally { if (proxy.State == CommunicationState.Opened) { proxy.Close(); } } }
public static void CallAction(Action <TActionType> action, IClientChannel proxy) { try { action((TActionType)proxy); } catch (CommunicationException ex) { proxy.Abort(); throw ex; } catch (TimeoutException ex) { proxy.Abort(); throw ex; } catch (Exception ex) { proxy.Abort(); throw ex; } finally { if (proxy.State == CommunicationState.Opened) { proxy.Close(); } } }
/// <summary> /// Executes the specified action. /// </summary> /// <typeparam name="TResult">The type of the result.</typeparam> /// <param name="action">The action.</param> /// <returns>the result</returns> public TResult Execute <TResult>(Func <T, TResult> action) { IClientChannel clientChannel = (IClientChannel)ChannelFactory.CreateChannel(); TResult result = default(TResult); try { result = action((T)clientChannel); clientChannel.Close(); } catch (FaultException e) { Console.WriteLine(e.Message); clientChannel.Abort(); } catch (CommunicationException e) { } catch (Exception e) { clientChannel.Abort(); } finally { } return(result); }
public static void Use(UseServiceDelegate <T> codeBlock) { IClientChannel proxy = (IClientChannel)_channelFactory.CreateChannel(); bool success = false; Exception mostRecentEx = null; for (int i = 0; i < 5; i++) // Attempt a maximum of 5 times { try { codeBlock((T)proxy); proxy.Close(); success = true; break; } // The following is typically thrown on the client when a channel is terminated due to the server closing the connection. catch (ChannelTerminatedException cte) { mostRecentEx = cte; proxy.Abort(); // delay (backoff) and retry Thread.Sleep(1000 * (i + 1)); } // The following is thrown when a remote endpoint could not be found or reached. The endpoint may not be found or // reachable because the remote endpoint is down, the remote endpoint is unreachable, or because the remote network is unreachable. catch (EndpointNotFoundException enfe) { mostRecentEx = enfe; proxy.Abort(); // delay (backoff) and retry Thread.Sleep(1000 * (i + 1)); } // The following exception that is thrown when a server is too busy to accept a message. catch (ServerTooBusyException stbe) { mostRecentEx = stbe; proxy.Abort(); // delay (backoff) and retry Thread.Sleep(1000 * (i + 1)); } catch (Exception) { // rethrow any other exception not defined here // You may want to define a custom Exception class to pass information such as failure count, and failure type proxy.Abort(); throw; } } if (mostRecentEx != null) { proxy.Abort(); throw new Exception("WCF call failed after 5 retries.", mostRecentEx); } }
public static R Run <T, R>(CachedChannelFactory <T> factory, TimeSpan?timeout, Func <T, R> methodToCall) { T t = factory.Factory.CreateChannel(); R result; using (IClientChannel clientChannel = (IClientChannel)((object)t)) { if (timeout != null) { clientChannel.OperationTimeout = timeout.Value; } CommunicationState state = clientChannel.State; bool flag = false; if (state != CommunicationState.Created) { if (state != CommunicationState.Closed) { goto IL_51; } } try { clientChannel.Open(); flag = true; } catch { clientChannel.Abort(); throw; } IL_51: bool flag2 = false; try { result = methodToCall(t); } catch (Exception error) { if (WcfUtils.IsChannelException(error)) { flag2 = true; clientChannel.Abort(); } throw; } finally { if (!flag2 && flag) { WcfUtils.CloseChannel(clientChannel); } } } return(result); }
private void RemoveSellerIfExists(Uri request, string name) { if (FlightSearchLogic.Instance.delegates.ContainsKey(name)) { ISellerService tsqs; bool gotValue = FlightSearchLogic.Instance.delegates.TryGetValue(name, out tsqs); if (gotValue) { IClientChannel currChannel = (IClientChannel)tsqs; try { currChannel.Close(); currChannel.Abort(); } catch (Exception) { currChannel.Abort(); Console.WriteLine("Closing of stale channel {0} failed, ignoring", currChannel.RemoteAddress.Uri.ToString()); } ISellerService victimChannel; FlightSearchLogic.Instance.delegates.TryRemove(name, out victimChannel); Console.WriteLine("Successfully remove old seller {0} by name", name); } } foreach (var seller in FlightSearchLogic.Instance.delegates) { IClientChannel currChannel = ((IClientChannel)seller.Value); if (currChannel.RemoteAddress.Uri.Equals(request)) { Console.WriteLine("Detected connection retry by {0} from {1} ,removing old connection", name, request.ToString()); // Close this channel try { currChannel.Close(); currChannel.Abort(); } catch (Exception) { currChannel.Abort(); Console.WriteLine("Closing of stale channel {0} failed, ignoring", currChannel.RemoteAddress.Uri.ToString()); } ISellerService victimChannel; FlightSearchLogic.Instance.delegates.TryRemove(seller.Key, out victimChannel); } } }
public T Function<T>(Func<T> func) { try { var result = func(); _clientChannel.Close(); return result; } catch (Exception ex) { KTrace.Error(ex); _clientChannel.Abort(); throw; } }
/// <summary> /// Invoke method implementation /// </summary> private T Invoke <T>(string operationName, string uri, ExecuteOptions options, InvokeDelegate <T> operation) { using (new SPMonitoredScope("Invoke :" + operationName + "_" + uri)) { string ep = FindLoadBalancerEndPoint(uri); if (!string.IsNullOrEmpty(ep)) { Uri xu = new Uri(ep); IIdentityServiceContract identityapplication = GetChannel(xu, options); IClientChannel clientChannel = identityapplication as IClientChannel; try { operation(identityapplication); clientChannel.Close(); } finally { if (clientChannel.State != CommunicationState.Closed) { clientChannel.Abort(); } } } } return(default(T)); }
public removeMerchantAliasResult RemoveMerchantAlias(removeMerchantAliasRequest request) { IClientChannel channel = (IClientChannel)_createMerchantAliasFactory.CreateChannel(); bool success = false; removeMerchantAliasResult result = null; try { removeMerchantAliasResponse response = ((MerchantAliasWSRemove)channel).removeMerchantAlias(new removeMerchantAliasRequest1(request)); channel.Close(); result = response.@return; success = true; } finally { if (!success) { channel.Abort(); } } return(result); }
public createMerchantAliasResult CreateMerchantAlias(createMerchantAliasRequest request) { IClientChannel channel = (IClientChannel)_createMerchantAliasFactory.CreateChannel(); bool success = false; createMerchantAliasResult result = null; try { createMerchantAliasResponse response = null; using (OperationContextScope scope = new OperationContextScope(channel)) { OperationContext.Current.OutgoingMessageHeaders.ReplyTo = new EndpointAddress(_config.AsyncServiceEndpoint); response = ((MerchantAliasWSCreate)channel).createMerchantAlias(new createMerchantAliasRequest1(request)); channel.Close(); } result = response.@return; success = true; } finally { if (!success) { channel.Abort(); } } return(result); }
public bool EndWhisper(IAsyncResult result) { if (this.proxy != null) { try { return(this.proxy.EndAsyncWhisper(result)); } catch (Exception ex) { if (this.Logger != null) { this.Logger.Fatal("Fail to EndWhisper", ex); } IClientChannel clientChannel = this.proxy as IClientChannel; if (clientChannel != null) { CommunicationState state = clientChannel.State; if (clientChannel.State == CommunicationState.Faulted) { clientChannel.Abort(); } return(false); } return(false); } } if (this.Logger != null) { this.Logger.Fatal("No Service is connected"); } return(false); }
void InvokeEnd(Task response, IClientChannel channel, MethodCallMessageWrapper methodCallWrapper) { Exception exception = null; MethodInfo method = methodCallWrapper.MethodBase as MethodInfo; try { FlowContextForTest(methodCallWrapper); if (response.IsFaulted) { exception = EvaluateException(response.Exception); throw exception; } } finally { OnPostInvoke(method, exception); if (channel.State != CommunicationState.Closed && channel.State != CommunicationState.Faulted) { try { channel.Close(); } catch { channel.Abort(); } } channel = null; } }
public static async Task <TResult> ExecuteAsync <TResult>(Func <T, Task <TResult> > action) { IClientChannel clientChannel = (IClientChannel)ChannelFactory.CreateChannel(); bool success = false; TaskCompletionSource <TResult> taskCompletionSource = new TaskCompletionSource <TResult>(); try { taskCompletionSource.TrySetResult(await action((T)clientChannel)); clientChannel.Close(); success = true; } catch (Exception ex) { taskCompletionSource.TrySetException(ex); } finally { if (!success) { clientChannel.Abort(); } } return(await taskCompletionSource.Task); }
// Token: 0x06000010 RID: 16 RVA: 0x00002588 File Offset: 0x00000788 public static void Use(Action <T> codeBlock, string RemoteIP) { IClientChannel clientChannel = (IClientChannel)((object)new ChannelFactory <T>(GenericService <T> .binding).CreateChannel(new EndpointAddress(string.Format("http://{0}/{1}{2}{3}", new object[] { RemoteIP, "IRemo", "te", "Panel" })))); bool flag = false; try { codeBlock((T)((object)clientChannel)); clientChannel.Close(); flag = true; } finally { if (!flag) { clientChannel.Abort(); } } }
public static void Using <TServiceContract>(Action <TServiceContract> action, string endpointConfigurationName) where TServiceContract : class { ChannelFactoryCacheKey cacheKey = new ChannelFactoryCacheKey(typeof(TServiceContract), endpointConfigurationName); ChannelFactory <TServiceContract> channelFactory = (ChannelFactory <TServiceContract>)SvcHelper.ChannelFactories.GetOrAdd( cacheKey, cacheKey => new ChannelFactory <TServiceContract>(cacheKey.EndpointConfigurationName)); TServiceContract typedChannel = channelFactory.CreateChannel(); IClientChannel clientChannel = (IClientChannel)typedChannel; try { using (new OperationContextScope((IContextChannel)typedChannel)) { action(typedChannel); } } finally { try { clientChannel.Close(); } catch { clientChannel.Abort(); } } }
public static void Using <T>(Action <T> action) { BasicHttpBinding bindnig = new BasicHttpBinding(); string endpointUri = GetServiceEndpoint(typeof(T)); ChannelFactory <T> factory = new ChannelFactory <T>(bindnig, new EndpointAddress(new Uri(endpointUri))); //ChannelFactory<T> factory = new ChannelFactory<T>("*"); T client = factory.CreateChannel(); try { action(client); ((IClientChannel)client).Close(); factory.Close(); } catch (Exception ex) { IClientChannel clientInstance = ((IClientChannel)client); if (clientInstance.State == System.ServiceModel.CommunicationState.Faulted) { clientInstance.Abort(); factory.Abort(); } else if (clientInstance.State != System.ServiceModel.CommunicationState.Closed) { clientInstance.Close(); factory.Close(); } throw (ex); } }
public async Task <byte[]> ExecuteWcfProcess(byte[] message) { IService proxy = null; IClientChannel ch = null; byte[] result; try { proxy = _factory.CreateChannel(); ch = (IClientChannel)proxy; ch.Open(); result = await proxy.ExecuteWcfProcess(message); ch.Close(); } catch (Exception) { if (ch != null) { if (ch.State == CommunicationState.Faulted) { ch.Abort(); } else { ch.Close(); } } throw; } return(result); }
/// <summary> /// Callback function will be used when fault happened using the channel. /// </summary> /// <param name="sender">Specify the callback event sender.</param> /// <param name="e">Specify the event argument.</param> private void Channel_Faulted(object sender, EventArgs e) { IClientChannel channel = sender as IClientChannel; channel.Abort(); ((IDisposable)channel).Dispose(); }
public void SendMemberInfo(long guildKey, string sender, bool isOnline) { if (this.proxy != null) { try { this.proxy.MemberInfo(guildKey, sender, isOnline); return; } catch (Exception ex) { if (this.Logger != null) { this.Logger.Error("Fail to close connection", ex); } IClientChannel clientChannel = this.proxy as IClientChannel; if (clientChannel.State == CommunicationState.Faulted) { clientChannel.Abort(); } return; } } if (this.Logger != null) { this.Logger.ErrorFormat("Fail to sendMemberInfo {0} {1} {2}", guildKey, sender, isOnline); } }
/// <summary> /// Releases unmanaged and - optionally - managed resources /// </summary> /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param> protected override void Dispose(bool disposing) { if (disposing == true) { IClientChannel proxyChannel = ProxyInstance as IClientChannel; try { if (proxyChannel != null) { if (proxyChannel.State != CommunicationState.Faulted) { proxyChannel.Close(); } else { proxyChannel.Abort(); } } } catch (CommunicationException) { if (proxyChannel != null) { proxyChannel.Abort(); } } catch (TimeoutException) { if (proxyChannel != null) { proxyChannel.Abort(); } } catch (Exception) { if (proxyChannel != null) { proxyChannel.Abort(); } throw; } finally { ProxyInstance = default(T); } } }
public static void CloseClientChannel(IClientChannel c) { try { c.Close(); } catch { c.Abort(); } finally { c.Dispose(); } }
public static void CleanUp(this IClientChannel proxy) { try { proxy.Close(); } catch { proxy.Abort(); throw; } }
public void UseAsyncWithReturnValue(UseServiceDelegateWithAsyncReturn <T> action, string endPoint, object obj) { try { _proxy = GetChannelFactory(endPoint).CreateChannel() as IClientChannel; if (_proxy != null) { _actionWithAsyncReturn = action; new Thread(() => { action((T)_proxy, obj); _proxy.Close(); }).Start(); } } catch (CommunicationException communicationException) { if (_proxy != null) { _proxy.Abort(); } throw communicationException; } catch (TimeoutException timeoutException) { if (_proxy != null) { _proxy.Abort(); } throw timeoutException; } catch (Exception ex) { if (_proxy != null) { _proxy.Abort(); } throw ex; } }
private void ExceptionOccured(string message, Exception e) { if (this.Logger != null) { this.Logger.Error(message, e); } IClientChannel clientChannel = this.proxy as IClientChannel; if (clientChannel.State == CommunicationState.Faulted) { clientChannel.Abort(); } }
private void Close() { try { _channel.Faulted -= ChannelFaultedHandler; _channel.Closed -= ChannelClosedExternallyHandler; if (_channel.State == CommunicationState.Opened) _channel.Close(); else _channel.Abort(); } catch (Exception ex) { Logger.Logger.Instance.Debug(ex, "WCF channel close exception."); _channel.Abort(); } finally { OnClosed(); } }
public void Use(UseServiceDelegate <T> action, string endPoint) { try { _proxy = GetChannelFactory(endPoint).CreateChannel() as IClientChannel; if (_proxy != null) { _proxy.Open(); action((T)_proxy); _proxy.Close(); } } catch (CommunicationException communicationException) { if (_proxy != null) { _proxy.Abort(); } throw communicationException; } catch (TimeoutException timeoutException) { if (_proxy != null) { _proxy.Abort(); } throw timeoutException; } catch (Exception ex) { if (_proxy != null) { _proxy.Abort(); } throw ex; } }
public void UseAsync(UseServiceDelegate <T> action, string endPoint, AsyncCallback callBack, object obj) { try { _proxy = GetChannelFactory(endPoint).CreateChannel() as IClientChannel; if (_proxy != null) { _proxy.Open(); _callBack = callBack; _action = action; IAsyncResult result = _action.BeginInvoke((T)_proxy, AsyncResult, obj); } } catch (CommunicationException communicationException) { if (_proxy != null) { _proxy.Abort(); } throw communicationException; } catch (TimeoutException timeoutException) { if (_proxy != null) { _proxy.Abort(); } throw timeoutException; } catch (Exception ex) { if (_proxy != null) { _proxy.Abort(); } throw ex; } }
private void ChannelFaulted(object sender, EventArgs e) { IClientChannel channel = (IClientChannel)sender; try { channel.Close(); } catch { channel.Abort(); } throw new ApplicationException("Exc_ChannelFailure"); }
static void Main(string[] args) { using (var channelFactory = new ChannelFactory <IHelloWorldService>( new NetNamedPipeBinding(), new EndpointAddress("net.pipe://localhost/my-services/hello-service"))) { while (true) { IClientChannel channel = null; try { var helloWorldService = channelFactory.CreateChannel(); helloWorldService.HelloWorld(); channel = (IClientChannel)helloWorldService; channel.Close(); } catch (EndpointNotFoundException) { } catch (CommunicationException) { channel.Abort(); } catch (TimeoutException) { channel.Abort(); } catch (Exception) { channel.Abort(); throw; } Console.ReadLine(); } } }
private static void CloseChannel(IClientChannel channel) { try { channel.Close(); } catch (TimeoutException) { channel.Abort(); } catch (CommunicationException) { channel.Abort(); } catch (Exception) { channel.Abort(); throw; } }