protected virtual IAsyncResult CoreOpen(bool isAsync, AsyncCallback callback, object asyncState)
{
lock (this.syncObject)
{
this.AssertIfStateIsBeforeOpen();
this.stateInfo = new System.Management.Automation.RunspacePoolStateInfo(RunspacePoolState.Opening, null);
}
this.RaiseStateChangeEvent(this.stateInfo);
if (isAsync)
{
AsyncResult state = new RunspacePoolAsyncResult(this.instanceId, callback, asyncState, true);
ThreadPool.QueueUserWorkItem(new WaitCallback(this.OpenThreadProc), state);
return state;
}
this.OpenHelper();
return null;
}
private void SetReconnectAsCompleted()
{
if ((this.reconnectAsyncResult != null) && !this.reconnectAsyncResult.IsCompleted)
{
this.reconnectAsyncResult.SetAsCompleted(base.stateInfo.Reason);
this.reconnectAsyncResult = null;
}
}
private IAsyncResult CoreClose(bool isAsync, AsyncCallback callback, object asyncState)
{
lock (this.syncObject)
{
if (((this.stateInfo.State == RunspacePoolState.Closed) || (this.stateInfo.State == RunspacePoolState.Broken)) || (((this.stateInfo.State == RunspacePoolState.Closing) || (this.stateInfo.State == RunspacePoolState.Disconnecting)) || (this.stateInfo.State == RunspacePoolState.Disconnected)))
{
if (isAsync)
{
RunspacePoolAsyncResult result = new RunspacePoolAsyncResult(this.instanceId, callback, asyncState, false);
result.SetAsCompleted(null);
return result;
}
return null;
}
this.stateInfo = new System.Management.Automation.RunspacePoolStateInfo(RunspacePoolState.Closing, null);
}
this.RaiseStateChangeEvent(this.stateInfo);
if (isAsync)
{
RunspacePoolAsyncResult state = new RunspacePoolAsyncResult(this.instanceId, callback, asyncState, false);
ThreadPool.QueueUserWorkItem(new WaitCallback(this.CloseThreadProc), state);
return state;
}
this.CloseHelper();
return null;
}
private void SetCloseAsCompleted()
{
this.DispatchTable.AbortAllCalls();
if (this.closeAsyncResult != null)
{
this.closeAsyncResult.SetAsCompleted(base.stateInfo.Reason);
this.closeAsyncResult = null;
}
else
{
this.SetOpenAsCompleted();
}
}
protected override IAsyncResult CoreOpen(bool isAsync, AsyncCallback callback, object asyncState)
{
PSEtwLog.SetActivityIdForCurrentThread(base.InstanceId);
PSEtwLog.LogOperationalVerbose(PSEventId.RunspacePoolOpen, PSOpcode.Open, PSTask.CreateRunspace, PSKeyword.UseAlwaysOperational, new object[0]);
lock (base.syncObject)
{
base.AssertIfStateIsBeforeOpen();
base.stateInfo = new RunspacePoolStateInfo(RunspacePoolState.Opening, null);
}
base.RaiseStateChangeEvent(base.stateInfo);
RunspacePoolAsyncResult result = new RunspacePoolAsyncResult(base.instanceId, callback, asyncState, true);
this.openAsyncResult = result;
this.dataStructureHandler.CreateRunspacePoolAndOpenAsync();
return result;
}
public override IAsyncResult BeginDisconnect(AsyncCallback callback, object state)
{
RunspacePoolState state2;
if (!this.CanDisconnect)
{
throw PSTraceSource.NewInvalidOperationException("RunspacePoolStrings", "DisconnectNotSupportedOnServer", new object[0]);
}
bool flag = false;
lock (base.syncObject)
{
state2 = base.stateInfo.State;
if (state2 == RunspacePoolState.Opened)
{
RunspacePoolStateInfo newStateInfo = new RunspacePoolStateInfo(RunspacePoolState.Disconnecting, null);
this.SetRunspacePoolState(newStateInfo);
flag = true;
}
}
if (flag)
{
base.RaiseStateChangeEvent(base.stateInfo);
}
if (state2 == RunspacePoolState.Opened)
{
this.disconnectAsyncResult = new RunspacePoolAsyncResult(base.instanceId, callback, state, false);
this.dataStructureHandler.DisconnectPoolAsync();
return this.disconnectAsyncResult;
}
InvalidRunspacePoolStateException exception = new InvalidRunspacePoolStateException(StringUtil.Format(RunspacePoolStrings.InvalidRunspacePoolState, RunspacePoolState.Opened, base.stateInfo.State), base.stateInfo.State, RunspacePoolState.Opened);
throw exception;
}
public override IAsyncResult BeginConnect(AsyncCallback callback, object state)
{
RunspacePoolState state2;
if (!this.AvailableForConnection)
{
throw PSTraceSource.NewInvalidOperationException("RunspacePoolStrings", "CannotConnect", new object[0]);
}
bool flag = false;
lock (base.syncObject)
{
state2 = base.stateInfo.State;
if (state2 == RunspacePoolState.Disconnected)
{
RunspacePoolStateInfo newStateInfo = new RunspacePoolStateInfo(RunspacePoolState.Connecting, null);
this.SetRunspacePoolState(newStateInfo);
flag = true;
}
}
if (flag)
{
base.RaiseStateChangeEvent(base.stateInfo);
}
flag = false;
if (state2 == RunspacePoolState.Disconnected)
{
RunspacePoolAsyncResult reconnectAsyncResult;
if (this.canReconnect)
{
this.dataStructureHandler.ReconnectPoolAsync();
this.reconnectAsyncResult = new RunspacePoolAsyncResult(base.instanceId, callback, state, false);
reconnectAsyncResult = this.reconnectAsyncResult;
}
else
{
this.dataStructureHandler.ConnectPoolAsync();
this.openAsyncResult = new RunspacePoolAsyncResult(base.instanceId, callback, state, false);
reconnectAsyncResult = this.openAsyncResult;
}
if (flag)
{
base.RaiseStateChangeEvent(base.stateInfo);
}
return reconnectAsyncResult;
}
InvalidRunspacePoolStateException exception = new InvalidRunspacePoolStateException(StringUtil.Format(RunspacePoolStrings.InvalidRunspacePoolState, RunspacePoolState.Disconnected, base.stateInfo.State), base.stateInfo.State, RunspacePoolState.Disconnected);
throw exception;
}
public override IAsyncResult BeginClose(AsyncCallback callback, object asyncState)
{
bool flag = false;
bool flag2 = false;
RunspacePoolStateInfo stateInfo = new RunspacePoolStateInfo(RunspacePoolState.BeforeOpen, null);
RunspacePoolAsyncResult closeAsyncResult = null;
lock (base.syncObject)
{
if ((base.stateInfo.State == RunspacePoolState.Closed) || (base.stateInfo.State == RunspacePoolState.Broken))
{
flag2 = true;
closeAsyncResult = new RunspacePoolAsyncResult(base.instanceId, callback, asyncState, false);
}
else if (base.stateInfo.State == RunspacePoolState.BeforeOpen)
{
stateInfo = base.stateInfo = new RunspacePoolStateInfo(RunspacePoolState.Closed, null);
flag = true;
flag2 = true;
this.closeAsyncResult = null;
closeAsyncResult = new RunspacePoolAsyncResult(base.instanceId, callback, asyncState, false);
}
else if ((base.stateInfo.State == RunspacePoolState.Opened) || (base.stateInfo.State == RunspacePoolState.Opening))
{
stateInfo = base.stateInfo = new RunspacePoolStateInfo(RunspacePoolState.Closing, null);
this.closeAsyncResult = new RunspacePoolAsyncResult(base.instanceId, callback, asyncState, false);
closeAsyncResult = this.closeAsyncResult;
flag = true;
}
else if (((base.stateInfo.State == RunspacePoolState.Disconnected) || (base.stateInfo.State == RunspacePoolState.Disconnecting)) || (base.stateInfo.State == RunspacePoolState.Connecting))
{
this.closeAsyncResult = new RunspacePoolAsyncResult(base.instanceId, callback, asyncState, false);
closeAsyncResult = this.closeAsyncResult;
}
else if (base.stateInfo.State == RunspacePoolState.Closing)
{
return this.closeAsyncResult;
}
}
if (flag)
{
base.RaiseStateChangeEvent(stateInfo);
}
if (!flag2)
{
this.dataStructureHandler.CloseRunspacePoolAsync();
return closeAsyncResult;
}
closeAsyncResult.SetAsCompleted(null);
return closeAsyncResult;
}
