/// <summary> /// Asynchronous implementation of the Invoke (End) /// </summary> public object InvokeEnd(object instance, out object[] outputs, IAsyncResult result) { var auditAsyncResult = result as AuditScopeAsyncResult; var auditScopeState = auditAsyncResult.AuditScopeState; object callResult; var auditScope = auditScopeState.AuditScope; var auditWcfEvent = (auditScope.Event as AuditEventWcfAction).WcfEvent; try { callResult = _baseInvoker.InvokeEnd(instance, out outputs, auditAsyncResult.OriginalAsyncResult); } catch (Exception ex) { AuditBehavior.CurrentAuditScope = null; auditWcfEvent.Fault = GetWcfFaultData(ex); auditWcfEvent.Success = false; (auditScope.Event as AuditEventWcfAction).WcfEvent = auditWcfEvent; auditScope.Dispose(); throw; } AuditBehavior.CurrentAuditScope = null; auditWcfEvent.OutputParameters = GetEventElements(outputs); auditWcfEvent.Result = new AuditWcfEventElement(callResult); (auditScope.Event as AuditEventWcfAction).WcfEvent = auditWcfEvent; auditScope.Dispose(); return(callResult); }
public object InvokeEnd(object instance, out object[] outputs, IAsyncResult result) { object returnedValue = null; object[] outputParams = {}; Exception exception = null; try { Task task = (result as Task); if (task.Status == TaskStatus.Faulted) { //Preserve original stack trace. exception = PreserveOriginalException(task.Exception); } CheckCompletesActorInstance(instance); returnedValue = m_OldInvoker.InvokeEnd(instance, out outputs, result); outputs = outputParams; return(returnedValue); } catch { Debug.Assert(true, "Invoker End exception: " + exception.Message); throw exception; } }
public object InvokeEnd(object instance, out object[] outputs, IAsyncResult result) { var invokeResult = _OriginalInvoker.InvokeEnd(instance, out outputs, result); AfterInvoke(); return(invokeResult); }
public object InvokeEnd(object instance, out object[] outputs, IAsyncResult asyncResult) { // Finish invoking the operation using the inner operation // invoker. object result = innerOperationInvoker.InvokeEnd(instance, out outputs, asyncResult); return(result); }
public object InvokeEnd(object instance, out object[] outputs, IAsyncResult result) { var task = result as Task; if (task != null && task.IsFaulted && task.Exception != null) { this.Log(task.Exception); } return(_invoker.InvokeEnd(instance, out outputs, result)); }
public Object InvokeEnd(Object instance, out Object[] outputs, IAsyncResult result) { try { return(_originalInvoker.InvokeEnd(instance, out outputs, result)); } finally { LogicalOperationScope.StopLogicalOperation(); } }
public object InvokeEnd(object instance, out object[] outputs, IAsyncResult result) { try { return(_baseInvoker.InvokeEnd(instance, out outputs, result)); } catch (Exception ex) { outputs = new object[0]; return(CatchException(instance, ex)); } }
public object InvokeEnd(object instance, out object[] outputs, IAsyncResult result) { try { var asyncResult = originalInvoker.InvokeEnd(instance, out outputs, result); return(TearDownService(instance, asyncResult)); } catch (Exception ex) { throw TearDownService(instance, ex); } }
public object InvokeEnd(object instance, out object[] outputs, IAsyncResult result) { object returnedValue = null; object[] outputParams = { }; Exception exception = null; returnedValue = m_OldInvoker.InvokeEnd(instance, out outputs, result); outputs = outputParams; PostInvoke(instance, returnedValue, outputParams, exception); return(returnedValue); }
void HandleCallback(IAsyncResult asyncResult) { try { innerOperationInvoker.InvokeEnd(instance, out outputs, asyncResult); Complete(false); } catch (Exception e) { Complete(false, e); } }
public object InvokeEnd(object instance, out object[] outputs, IAsyncResult result) { var task = result as Task; if (task != null && task.IsFaulted && task.Exception != null) { foreach (var error in task.Exception.InnerExceptions) { _log.Log(error); } } return(_invoker.InvokeEnd(instance, out outputs, result)); }
public object InvokeEnd(object instance, out object[] outputs, IAsyncResult asyncResult) { // Finish invoking the operation using the inner operation // invoker. object result = innerOperationInvoker.InvokeEnd(instance, out outputs, asyncResult); // Save the instance using the storage manager saved in the // current InstanceContext. InstanceContextExtension extension = OperationContext.Current.InstanceContext.Extensions.Find <InstanceContextExtension>(); extension.StorageManager.SaveInstance(extension.ContextId, instance); return(result); }
public Task <object> InvokeOperationAsync(object instance, object[] inputs, object state) { Message inputMessage = null; Message outputMessage = null; try { if (inputs != null && inputs.Length == 1) { inputMessage = inputs[0] as Message; } if (inputMessage != null) { // We need to copy the message in order to read it. // This means the original message will have the 'Read' state, which means it can no longer be read. var bufferedMessage = inputMessage.CreateBufferedCopy(Int32.MaxValue); inputs[0] = bufferedMessage.CreateMessage(); var messageToWorkOn = bufferedMessage.CreateMessage(); Stream messageStream = messageToWorkOn.GetBody <Stream>(); if (messageStream != null) { outputMessage = GetOutputMessageForInputMessageStream(messageStream); } } } catch (Exception ex) { // Swallow all the exceptions outputMessage = null; } if (outputMessage == null) { var capturedOperationContext = OperationContext.Current; return(Task <object> .Factory.StartNew(() => { OperationContext.Current = capturedOperationContext; var begin = _innerInvoker.InvokeBegin(instance, inputs, null, state); object[] o; return _innerInvoker.InvokeEnd(instance, out o, begin); })); } return(Task.FromResult((object)outputMessage)); }
/// <summary> /// 异步调用结束后操作 /// </summary> /// <param name="instance"></param> /// <param name="outputs"></param> /// <param name="result"></param> /// <returns></returns> public object InvokeEnd(object instance, out object[] outputs, IAsyncResult result) { object[] outputParams = { }; try { return(orgninInvoker.InvokeEnd(instance, out outputParams, result)); } finally { //写日志 logger.WriteLog(); outputs = outputParams; } }
public object InvokeEnd(object instance, out object[] outputs, IAsyncResult result) { object returnedValue = null; object[] outputParams = { }; try { returnedValue = invoker.InvokeEnd(instance, out outputs, result); outputs = outputParams; return(returnedValue); } catch (PropValiException pv) { TransResponse response = this.CreateResponse(out outputParams); if (response != null) { response.Status = TransStatus.ValidateError; response.Message = pv.Message; returnedValue = response; } else { returnedValue = null; } } catch (Exception ex) { TransResponse response = this.CreateResponse(out outputParams); if (response != null) { response.Status = TransStatus.Error; response.Message = ex.Message; returnedValue = response; } else { returnedValue = null; } } outputs = outputParams; return(returnedValue); }
public object InvokeEnd(object instance, out object[] outputs, IAsyncResult result) { object returnedValue = null; Exception exception = null; try { returnedValue = invoker.InvokeEnd(instance, out outputs, result); } catch (Exception ex) { exception = ex; throw; } PostInvoke(result.AsyncState as object[], returnedValue, outputs, exception); return(returnedValue); }
/// <summary> /// 功能:异步结束方法。 /// </summary> /// <returns> /// 返回值。 /// </returns> /// <param name="instance">调用的对象。</param><param name="outputs">方法的输出。</param><param name="result"><see cref="T:System.IAsyncResult"/> 对象。</param> public object InvokeEnd(object instance, out object[] outputs, IAsyncResult result) { outputs = null; object returnValue = null; try { returnValue = m_oldInvoker.InvokeEnd(instance, out outputs, result); } catch (DataMessageException dmex) { returnValue = GetDataErrorResponse(dmex); } catch (Exception ex) { returnValue = GetErrorResponse(instance, ex); } return(returnValue); }
public object InvokeEnd(object instance, out object[] outputs, IAsyncResult result) { object returnedValue = null; object[] outputParams = {}; Exception exception = null; try { Task task = (result as Task); if (task.Status == TaskStatus.Faulted) { //Preserve original stack trace. exception = PreserveOriginalException(task.Exception); } //TEST ONLY... if (CompletesActorInstance(instance)) { AsyncContextScope scope = CallContext.LogicalGetData("Context") as AsyncContextScope; if (scope != null) { scope.Close(); } } CheckCompletesActorInstance(instance); returnedValue = m_OldInvoker.InvokeEnd(instance, out outputs, result); outputs = outputParams; return(returnedValue); } catch { Debug.Assert(true, "Invoker End exception: " + exception.Message); throw CheckForActorNotFoundException(instance, exception); } finally { OnPostInvoke(instance, exception); } }
/// <summary> /// 异步调用结束后操作 /// </summary> /// <param name="instance"></param> /// <param name="outputs"></param> /// <param name="result"></param> /// <returns></returns> public object InvokeEnd(object instance, out object[] outputs, IAsyncResult result) { object[] outputParams = { }; try { return(orgninInvoker.InvokeEnd(instance, out outputParams, result)); } catch (Exception ex) { //写日志 因为考虑到NLog框架及各项目自身情况,不在本框架里实现写日志(这样程序的灵活性和扩展性高),框架只实现该实现的,其他由具体项目实现 logger.WriteLog(ex); //return null; throw; } finally { outputs = outputParams; } }
public object InvokeEnd(object instance, out object[] outputs, IAsyncResult result) { object returnedValue = null; object[] outputParams = { }; Exception exception = null; try { returnedValue = m_InnerInvoker.InvokeEnd(instance, out outputs, result); outputs = outputParams; return(returnedValue); } catch (Exception operationException) { exception = operationException; throw; } finally { PostInvoke(instance, returnedValue, outputParams, exception); } }
public object InvokeEnd(object instance, out object[] outputs, IAsyncResult asyncResult) { CachingAsyncResult result = asyncResult as CachingAsyncResult; CachingUserState state = result.CachingUserState; if (state.CacheItem == null) { object data = _invoker.InvokeEnd(instance, out outputs, result.OriginalAsyncResult); state.CacheItem = new CachedOperationResult { Data = data, Outputs = outputs }; CacheServiceHelper.Current.Add(state.CacheKey, state.CacheItem, TimeSpan.FromSeconds(_cacheDuration)); return(data); } else { InvokerDelegate invoker = ((AsyncResult)result.OriginalAsyncResult).AsyncDelegate as InvokerDelegate; invoker.EndInvoke(out outputs, result.OriginalAsyncResult); return(state.CacheItem.Data); } }
public object InvokeEnd(object instance, out object[] outputs, IAsyncResult result) { // Not supported - an exception will be thrown return(_innerInvoker.InvokeEnd(instance, out outputs, result)); }
public object InvokeEnd(object instance, out object[] outputs, IAsyncResult result) { // Use the default invoker. Don't time async methods return(_previousInvoker.InvokeEnd(instance, out outputs, result)); }
public object InvokeEnd(object instance, out object[] outputs, IAsyncResult result) { return(_baseInvoker.InvokeEnd(instance, out outputs, result)); }
public virtual object InvokeEnd(object instance, out object[] outputs, IAsyncResult result) { return(OldInvoker.InvokeEnd(instance, out outputs, result)); }
public object InvokeEnd(object instance, out object[] outputs, IAsyncResult asyncResult) { object result = _innerOperationInvoker.InvokeEnd(instance, out outputs, asyncResult); return(result); }
public object InvokeEnd(object instance, out object[] outputs, IAsyncResult result) { return(dispatchOperationInvoker.InvokeEnd(instance, out outputs, result)); }
/// <summary> /// Method which fires at the time of Request invoke action ends /// </summary> /// <param name="instance">operation context instance</param> /// <param name="outputs">output parameter array</param> /// <param name="result">result obtained</param> /// <returns>returns object</returns> public Object InvokeEnd(Object instance, out Object[] outputs, IAsyncResult result) { return(InnerOperationInvoker.InvokeEnd(instance, out outputs, result)); }
public object InvokeEnd(object instance, out object[] outputs, IAsyncResult result) { LogComplete(); return(_invoker.InvokeEnd(instance, out outputs, result)); }