internal void PromptUserCallbackInternal(OperationCallbackProcessingContext callbackProcessingContext, OperationHandle operationHandle, string message, MiPromptType promptType, out MIResponseType response)
{
response = MIResponseType.MIResponseTypeYes;
if (this._promptUserCallback != null)
{
//CimAsyncCallbacksReceiverBase managedOperationContext = (CimAsyncCallbacksReceiverBase)callbackProcessingContext.ManagedOperationContext;
CimResponseType userResponse = CimResponseType.None;
//managedOperationContext.CallIntoUserCallback(callbackProcessingContext, () => userResponse = this._promptUserCallback(message, (CimPromptType)promptType), false, false);
response = (MIResponseType)userResponse;
}
}
internal void StreamedParameterCallback(OperationCallbackProcessingContext callbackProcessingContext, OperationHandle operationHandle, string parameterName, object parameterValue, MiType parameterType)
{
parameterValue = CimInstance.ConvertFromNativeLayer(parameterValue, null, null, !this._shortenLifetimeOfResults);
CimInstance cimInstance = parameterValue as CimInstance;
if (cimInstance != null)
{
cimInstance.SetCimSessionComputerName(this._CimSessionComputerName);
cimInstance.SetCimSessionInstanceId(this._CimSessionInstanceID);
}
CimInstance[] cimInstanceArray = parameterValue as CimInstance[];
if (cimInstanceArray != null)
{
CimInstance[] cimInstanceArray1 = cimInstanceArray;
for (int i = 0; i < (int)cimInstanceArray1.Length; i++)
{
CimInstance cimInstance1 = cimInstanceArray1[i];
if (cimInstance1 != null)
{
cimInstance1.SetCimSessionComputerName(this._CimSessionComputerName);
cimInstance1.SetCimSessionInstanceId(this._CimSessionInstanceID);
}
}
}
try
{
CimMethodResultBase cimMethodStreamedResult = new CimMethodStreamedResult(parameterName, parameterValue, parameterType.ToCimType());
base.ProcessNativeCallback(callbackProcessingContext, cimMethodStreamedResult, true, MiResult.OK, null, null);
}
finally
{
if (this._shortenLifetimeOfResults)
{
CimInstance cimInstance2 = parameterValue as CimInstance;
if (cimInstance2 != null)
{
cimInstance2.Dispose();
}
CimInstance[] cimInstanceArray2 = parameterValue as CimInstance[];
if (cimInstanceArray2 != null)
{
CimInstance[] cimInstanceArray3 = cimInstanceArray2;
for (int j = 0; j < (int)cimInstanceArray3.Length; j++)
{
CimInstance cimInstance3 = cimInstanceArray3[j];
if (cimInstance3 != null)
{
cimInstance3.Dispose();
}
}
}
}
}
}
private void WriteProgressCallbackInternal(OperationCallbackProcessingContext callbackProcessingContext, OperationHandle operationHandle, string activity, string currentOperation, string statusDescription, int percentageCompleted, int secondsRemaining)
{
Action userCallback = null;
if (this._writeProgressCallback != null)
{
//CimAsyncCallbacksReceiverBase managedOperationContext = (CimAsyncCallbacksReceiverBase)callbackProcessingContext.ManagedOperationContext;
if (userCallback == null)
{
userCallback = () => this._writeProgressCallback(activity, currentOperation, statusDescription, percentageCompleted, secondsRemaining);
}
//managedOperationContext.CallIntoUserCallback(callbackProcessingContext, userCallback, false, false);
}
}
internal void WriteMessageCallbackInternal(OperationCallbackProcessingContext callbackProcessingContext, OperationHandle operationHandle, uint channel, string message)
{
Action userCallback = null;
if (this._writeMessageCallback != null)
{
//CimAsyncCallbacksReceiverBase managedOperationContext = (CimAsyncCallbacksReceiverBase)callbackProcessingContext.ManagedOperationContext;
if (userCallback == null)
{
userCallback = () => this._writeMessageCallback(channel, message);
}
//managedOperationContext.CallIntoUserCallback(callbackProcessingContext, userCallback, false, false);
}
}
internal void CallIntoUserCallback(OperationCallbackProcessingContext callbackProcessingContext, Action userCallback, bool serializeCallbacks = false, bool suppressFurtherUserCallbacks = false)
{
lock (this._suppressFurtherUserCallbacksLock)
{
if (!this._suppressFurtherUserCallbacks)
{
if (suppressFurtherUserCallbacks)
{
this._suppressFurtherUserCallbacks = true;
}
callbackProcessingContext.InUserCode = true;
this.CallUnderOriginalExecutionContext(userCallback);
callbackProcessingContext.InUserCode = false;
}
}
}
internal void ProcessNativeCallback(OperationCallbackProcessingContext callbackProcessingContext, T currentItem, bool moreResults, MiResult operationResult, string errorMessage, InstanceHandle errorDetailsHandle)
{
Action <CimOperation> action = null;
if (!moreResults)
{
base.DisposeOperationWhenPossible();
}
if (currentItem != null || operationResult != MiResult.OK)
{
if (currentItem != null)
{
this.OnNextInternal(callbackProcessingContext, currentItem);
}
}
else
{
if (this._reportOperationStarted)
{
this.OnNextInternal(callbackProcessingContext, currentItem);
}
}
CimException exceptionIfMiResultFailure = CimException.GetExceptionIfMiResultFailure(operationResult, errorMessage, errorDetailsHandle);
if (exceptionIfMiResultFailure != null)
{
try
{
throw exceptionIfMiResultFailure;
}
catch (CimException cimException1)
{
CimException cimException = cimException1;
exceptionIfMiResultFailure = cimException;
}
}
if (!moreResults)
{
CimAsyncObserverProxyBase <T> cimAsyncObserverProxyBase = this;
if (action == null)
{
action = (CimOperation cimOperation) => this.ProcessEndOfResultsWorker(callbackProcessingContext, cimOperation, exceptionIfMiResultFailure);
}
cimAsyncObserverProxyBase.InvokeWhenOperationIsSet(action);
}
}
internal override void ReportInternalError(OperationCallbackProcessingContext callbackProcessingContext, Exception internalError)
{
lock (this._internalErrorWhileProcessingAsyncCallbackLock)
{
if (this._internalErrorWhileProcessingAsyncCallback != null)
{
Exception exception = this._internalErrorWhileProcessingAsyncCallback;
Exception[] exceptionArray = new Exception[2];
exceptionArray[0] = exception;
exceptionArray[1] = internalError;
this._internalErrorWhileProcessingAsyncCallback = new AggregateException(exceptionArray);
}
else
{
this._internalErrorWhileProcessingAsyncCallback = internalError;
}
}
}
internal void WriteErrorCallbackInternal(OperationCallbackProcessingContext callbackProcessingContext, OperationHandle operationHandle, InstanceHandle instanceHandle, out MIResponseType response)
{
response = MIResponseType.MIResponseTypeYes;
if (this._writeErrorCallback != null)
{
CimInstance cimInstance = null;
using (cimInstance)
{
if (instanceHandle != null)
{
cimInstance = new CimInstance(instanceHandle, null);
//CimAsyncCallbacksReceiverBase managedOperationContext = (CimAsyncCallbacksReceiverBase)callbackProcessingContext.ManagedOperationContext;
CimResponseType userResponse = CimResponseType.None;
//managedOperationContext.CallIntoUserCallback(callbackProcessingContext, () => userResponse = this._writeErrorCallback(cimInstance), false, false);
response = (MIResponseType)userResponse;
}
}
}
}
internal void IndicationResultCallback(OperationCallbackProcessingContext callbackProcessingContext, OperationHandle operationHandle, InstanceHandle instanceHandle, string bookMark, string machineID, bool moreResults, MiResult operationResult, string errorMessage, InstanceHandle errorDetailsHandle)
{
CimSubscriptionResult cimSubscriptionResult = null;
if (instanceHandle != null && !instanceHandle.IsInvalid)
{
if (!this._shortenLifetimeOfResults)
{
instanceHandle = instanceHandle.Clone();
}
cimSubscriptionResult = new CimSubscriptionResult(instanceHandle, bookMark, machineID);
}
using (cimSubscriptionResult)
{
if (!this._shortenLifetimeOfResults || cimSubscriptionResult == null)
{
base.ProcessNativeCallback(callbackProcessingContext, cimSubscriptionResult, moreResults, operationResult, errorMessage, errorDetailsHandle);
}
}
}
internal void ClassCallback(OperationCallbackProcessingContext callbackProcessingContext, OperationHandle operationHandle, ClassHandle ClassHandle, bool moreResults, MiResult operationResult, string errorMessage, InstanceHandle errorDetailsHandle)
{
CimClass cimClass = null;
if (ClassHandle != null && !ClassHandle.IsInvalid)
{
if (!this._shortenLifetimeOfResults)
{
ClassHandle = ClassHandle.Clone();
}
cimClass = new CimClass(ClassHandle);
}
//using (cimClass)
{
if (!this._shortenLifetimeOfResults || cimClass == null)
{
base.ProcessNativeCallback(callbackProcessingContext, cimClass, moreResults, operationResult, errorMessage, errorDetailsHandle);
}
}
}
internal void InstanceResultCallback(OperationCallbackProcessingContext callbackProcessingContext, OperationHandle operationHandle, InstanceHandle instanceHandle, bool moreResults, MiResult operationResult, string errorMessage, InstanceHandle errorDetailsHandle)
{
CimInstance cimInstance = null;
if (instanceHandle != null && !instanceHandle.IsInvalid)
{
if (!this._shortenLifetimeOfResults)
{
instanceHandle = instanceHandle.Clone();
}
cimInstance = new CimInstance(instanceHandle, null);
cimInstance.SetCimSessionComputerName(this._CimSessionComputerName);
cimInstance.SetCimSessionInstanceId(this._CimSessionInstanceID);
}
//TODO: using (cimInstance)
{
if (!this._shortenLifetimeOfResults || cimInstance == null)
{
base.ProcessNativeCallback(callbackProcessingContext, cimInstance, moreResults, operationResult, errorMessage, errorDetailsHandle);
}
}
}
private void ProcessEndOfResultsWorker(OperationCallbackProcessingContext callbackProcessingContext, CimOperation cimOperation, Exception exception)
{
if (exception != null)
{
CancellationMode cancellationMode = cimOperation.CancellationMode;
CancellationMode cancellationMode1 = cancellationMode;
switch (cancellationMode1)
{
case CancellationMode.NoCancellationOccured:
case CancellationMode.IgnoreCancellationRequests:
{
this.OnErrorInternal(callbackProcessingContext, exception);
return;
}
case CancellationMode.ThrowOperationCancelledException:
{
this.OnErrorInternal(callbackProcessingContext, new OperationCanceledException(exception.Message, exception));
return;
}
case CancellationMode.SilentlyStopProducingResults:
{
return;
}
default:
{
return;
}
}
}
else
{
this.OnCompletedInternal(callbackProcessingContext);
return;
}
}
private void ReportInternalErrorCore(OperationCallbackProcessingContext callbackProcessingContext, Exception internalError)
{
this.InvokeWhenOperationIsSet((CimOperation cimOperation) => {
lock (this)
{
try
{
cimOperation.Cancel(CancellationMode.SilentlyStopProducingResults);
}
catch (Exception exception2)
{
Exception exception = exception2;
Exception exception1 = internalError;
Exception[] exceptionArray = new Exception[2];
exceptionArray[0] = exception1;
exceptionArray[1] = exception;
internalError = new AggregateException(exceptionArray);
}
this.ReportInternalError(callbackProcessingContext, internalError);
}
}
);
}
internal override void ReportInternalError(OperationCallbackProcessingContext callbackProcessingContext, Exception internalError)
{
this.OnErrorInternal(callbackProcessingContext, internalError);
}
internal abstract void ReportInternalError(OperationCallbackProcessingContext callbackProcessingContext, Exception internalError);
private void OnErrorInternal(OperationCallbackProcessingContext callbackProcessingContext, Exception exception)
{
base.CallIntoUserCallback(callbackProcessingContext, () => ((CimAsyncObserverProxyBase <T>) this)._observer.OnError(exception), false, true);
}
private void OnNextInternal(OperationCallbackProcessingContext callbackProcessingContext, T item)
{
base.CallIntoUserCallback(callbackProcessingContext, () => ((CimAsyncObserverProxyBase <T>) this)._observer.OnNext(item), false, false);
}
private void OnCompletedInternal(OperationCallbackProcessingContext callbackProcessingContext)
{
IObserver <T> observer = this._observer;
base.CallIntoUserCallback(callbackProcessingContext, new Action(observer.OnCompleted), false, true);
}
