internal void ProcessReceivedData(RemoteDataObject <PSObject> receivedData)
        {
            if (receivedData.RunspacePoolId != this.clientRunspacePoolId)
            {
                throw new PSRemotingDataStructureException(RemotingErrorIdStrings.RunspaceIdsDoNotMatch, new object[] { receivedData.RunspacePoolId, this.clientRunspacePoolId });
            }
            switch (receivedData.DataType)
            {
            case RemotingDataType.RunspacePoolOperationResponse:
                this.SetMaxMinRunspacesResponseRecieved.SafeInvoke <RemoteDataEventArgs <PSObject> >(this, new RemoteDataEventArgs <PSObject>(receivedData.Data));
                return;

            case RemotingDataType.RunspacePoolStateInfo:
            {
                RunspacePoolStateInfo runspacePoolStateInfo = RemotingDecoder.GetRunspacePoolStateInfo(receivedData.Data);
                this.StateInfoReceived.SafeInvoke <RemoteDataEventArgs <RunspacePoolStateInfo> >(this, new RemoteDataEventArgs <RunspacePoolStateInfo>(runspacePoolStateInfo));
                this.NotifyAssociatedPowerShells(runspacePoolStateInfo);
                return;
            }

            case RemotingDataType.CreatePowerShell:
            case RemotingDataType.AvailableRunspaces:
            case RemotingDataType.GetCommandMetadata:
                break;

            case RemotingDataType.PSEventArgs:
            {
                PSEventArgs pSEventArgs = RemotingDecoder.GetPSEventArgs(receivedData.Data);
                this.PSEventArgsReceived.SafeInvoke <RemoteDataEventArgs <PSEventArgs> >(this, new RemoteDataEventArgs <PSEventArgs>(pSEventArgs));
                break;
            }

            case RemotingDataType.ApplicationPrivateData:
            {
                PSPrimitiveDictionary applicationPrivateData = RemotingDecoder.GetApplicationPrivateData(receivedData.Data);
                this.ApplicationPrivateDataReceived.SafeInvoke <RemoteDataEventArgs <PSPrimitiveDictionary> >(this, new RemoteDataEventArgs <PSPrimitiveDictionary>(applicationPrivateData));
                return;
            }

            case RemotingDataType.RunspacePoolInitData:
            {
                RunspacePoolInitInfo runspacePoolInitInfo = RemotingDecoder.GetRunspacePoolInitInfo(receivedData.Data);
                this.RSPoolInitInfoReceived.SafeInvoke <RemoteDataEventArgs <RunspacePoolInitInfo> >(this, new RemoteDataEventArgs <RunspacePoolInitInfo>(runspacePoolInitInfo));
                return;
            }

            case RemotingDataType.RemoteHostCallUsingRunspaceHost:
            {
                RemoteHostCall data = RemoteHostCall.Decode(receivedData.Data);
                this.RemoteHostCallReceived.SafeInvoke <RemoteDataEventArgs <RemoteHostCall> >(this, new RemoteDataEventArgs <RemoteHostCall>(data));
                return;
            }

            default:
                return;
            }
        }