public void Listen(string PipeName) { try { // Set to class level var so we can re-use in the async callback method _pipeName = PipeName; // Create the new async pipe NamedPipeServerStream pipeServer = new NamedPipeServerStream(PipeName, PipeDirection.In, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous); // Wait for a connection pipeServer.BeginWaitForConnection(new AsyncCallback(WaitForConnectionCallBack), pipeServer); } catch (Exception oEX) { Debug.WriteLine(oEX.Message); } }
private void CreatePipeServer() { PipeSecurity ps = new PipeSecurity(); ps.AddAccessRule(new PipeAccessRule("Users", PipeAccessRights.CreateNewInstance | PipeAccessRights.ReadWrite, System.Security.AccessControl.AccessControlType.Allow)); beaconServer = new NamedPipeServerStream("TransMockBeacon", PipeDirection.InOut, 10, PipeTransmissionMode.Message, PipeOptions.Asynchronous, 8, 8, ps); connectResult = beaconServer.BeginWaitForConnection(cb => ClientConnected(cb), beaconServer); }
protected void BeginPushPipeListen() { if (!Running) { return; } lock (PushPipes) { if (ListeningPushPipe != null) { ListeningPushPipe.Dispose(); // Shouldn't happen too } // Note: PipeDirection.InOut ensures the client can set ReadMode, IDK why but it works this way ListeningPushPipe = new NamedPipeServerStream(Name + PipeConnection.PUSH_SUFFIX, PipeDirection.InOut, NamedPipeServerStream.MaxAllowedServerInstances, PipeTransmissionMode.Message, PipeOptions.Asynchronous, 0, BufferSize, CreateSecurity()); ListeningPushPipe.BeginWaitForConnection(OnPushPipeConnect, null); } }
private void PipeConnect(IAsyncResult iar) { if (!_IsRunning) { return; } _MainPipe.EndWaitForConnection(iar); _MainPipe.Write(_PipeData, 0, _PipeData.Length); _MainPipe.WaitForPipeDrain(); _MainPipe.Disconnect(); // neue Pipe erstellen, einmal geschlossen, wars das _MainPipe.BeginWaitForConnection(PipeConnect, null); }
public void Listen(string PipeName) { try { _pipeName = PipeName; // Create the new async pipe NamedPipeServerStream pipeServer = new NamedPipeServerStream(PipeName, PipeDirection.In, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous); // Wait for a connection pipeServer.BeginWaitForConnection(new AsyncCallback(WaitForConnectionCallBack), pipeServer); } catch (Exception oEX) { throw oEX; } }
public void Init() { lock (pipeServerLock) { if (pipeServer != null) { return; } var sid = new SecurityIdentifier(WellKnownSidType.WorldSid, null); var rule = new PipeAccessRule(sid, PipeAccessRights.ReadWrite, System.Security.AccessControl.AccessControlType.Allow); var sec = new PipeSecurity(); sec.AddAccessRule(rule); pipeServer = new NamedPipeServerStream(HealthCheckSettings.HEALTH_CHECK_PIPE, PipeDirection.In, 1, PipeTransmissionMode.Message, PipeOptions.Asynchronous, 0, 0, sec); pipeServer.BeginWaitForConnection(new AsyncCallback(WaitForConnectionCallBack), pipeServer); } }
public void Listen() { lock (_lck) { Log("Listen for client."); if (_mustShutdown) { return; } _listener = new NamedPipeServerStream(PipeName, PipeDirection.InOut, NamedPipeServerStream.MaxAllowedServerInstances, PipeTransmissionMode.Byte, PipeOptions.Asynchronous | PipeOptions.WriteThrough); _listener.BeginWaitForConnection(OnConnect, null); } }
public StudioServer() { try { pipeSecurity = new PipeSecurity(); pipeSecurity.SetAccessRule(new PipeAccessRule(new SecurityIdentifier(WellKnownSidType.BuiltinUsersSid, null), PipeAccessRights.ReadWrite, AccessControlType.Allow)); serverStream = NamedPipeServerStreamConstructors.New($@"\.\DSParamStudio\pipe\CommandQueue", PipeDirection.InOut, System.IO.Pipes.NamedPipeServerStream.MaxAllowedServerInstances, PipeTransmissionMode.Message, PipeOptions.Asynchronous, 0, 0, pipeSecurity); serverStream.BeginWaitForConnection(handleConnection, serverStream); new Thread(TestThread).Start(); } catch { } }
private void StartServerPump() { if (!is_running) { return; } try { PipeSecurity ps = new PipeSecurity(); ps.AddAccessRule(new PipeAccessRule("Everyone", PipeAccessRights.ReadWrite, AccessControlType.Allow)); using (var npss = new NamedPipeServerStream(IPCCommon.PIPE_NAME, PipeDirection.InOut, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous, 512, 512, ps)) { npss.BeginWaitForConnection(async_result => { try { using (var npss_in_callback = (NamedPipeServerStream)async_result.AsyncState) { npss_in_callback.EndWaitForConnection(async_result); npss_in_callback.WaitForPipeDrain(); StreamReader sr = new StreamReader(npss_in_callback); var line = sr.ReadLine(); IPCServerMessage?.Invoke(line); npss_in_callback.Close(); // Listen for another client. Note that this is NOT recursive as we are currently inside a lambda. StartServerPump(); } } catch (Exception ex) { Logging.Error(ex, "Error while processing pipe connection. ({0})", IPCCommon.PIPE_NAME); } }, npss); } } catch (Exception ex) { Logging.Error(ex, "Error while waiting for pipe connection. ({0})", IPCCommon.PIPE_NAME); } }
/// <summary> /// Starts a new pipe server if one isn't already active. /// </summary> private void NamedPipeServerCreateServer() { if (_namedPipeServerStream != null) { // Already a pipe setup, just return return; } // Create a new pipe accessible by local authenticated users, disallow network //var sidAuthUsers = new SecurityIdentifier(WellKnownSidType.AuthenticatedUserSid, null); var sidNetworkService = new SecurityIdentifier(WellKnownSidType.NetworkServiceSid, null); var sidWorld = new SecurityIdentifier(WellKnownSidType.WorldSid, null); var pipeSecurity = new PipeSecurity(); // Deny network access to the pipe var accessRule = new PipeAccessRule(sidNetworkService, PipeAccessRights.ReadWrite, AccessControlType.Deny); pipeSecurity.AddAccessRule(accessRule); // Alow Everyone to read/write accessRule = new PipeAccessRule(sidWorld, PipeAccessRights.ReadWrite, AccessControlType.Allow); pipeSecurity.AddAccessRule(accessRule); // This user is the owner (can create pipes) SecurityIdentifier sidOwner = WindowsIdentity.GetCurrent().Owner; if (sidOwner != null) { accessRule = new PipeAccessRule(sidOwner, PipeAccessRights.FullControl, AccessControlType.Allow); pipeSecurity.AddAccessRule(accessRule); } // Create pipe and start the async connection wait _namedPipeServerStream = new NamedPipeServerStream( PipeName, PipeDirection.In, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous, 0, 0, pipeSecurity); _namedPipeAsyncResult = _namedPipeServerStream.BeginWaitForConnection(NamedPipeServerConnectionCallback, _namedPipeServerStream); }
void IpcProcessConnection(IAsyncResult ar) { try { // connect and read command ipcServer.EndWaitForConnection(ar); int raw = ipcServer.ReadByte(); if (raw >= 0) { IpcCommands command = (IpcCommands)raw; // commands interact with the main form and must therefore be processed in the UI thread this.Dispatcher.Invoke(new Action(() => { try { if (command == IpcCommands.ShowMainWindow) { this.MainWindow.ShowWindow(); } else if (command == IpcCommands.Exit) { this.MainWindow.CloseWindow(); } } catch (Exception ex) { log.Error("Error processing Ipc Message: " + ex.Message + " (" + ex.GetType().Name + ")", ex); } })); } } catch (Exception ex) { log.Error("Error processing Ipc Message: " + ex.Message + " (" + ex.GetType().Name + ")", ex); } try { ipcServer.Disconnect(); ipcServer.BeginWaitForConnection(new AsyncCallback(IpcProcessConnection), null); } catch (Exception ex) { log.Error("Could not listen on Ipc Channel: " + ex.Message + " (" + ex.GetType().Name + ")", ex); } }
public HookProxy(Client cl) { string dllPath = System.IO.Path.Combine(System.Windows.Forms.Application.StartupPath.ToString(), "Hooker.dll"); // string dllPath = System.IO.Path.Combine(System.Windows.Forms.Application.StartupPath.ToString(), "InjectBooter.dll"); client = cl; string name = "InjectClient" + Convert.ToString(client.Process.Id); pipeRecv = new NamedPipeServerStream(name, PipeDirection.InOut, -1, PipeTransmissionMode.Message, PipeOptions.Asynchronous); pipeRecv.BeginWaitForConnection(BeginWaitForConnection, pipeRecv); bool injected = Inject(dllPath); SetUpPipes(); tibiaSock = new TibiaSock(cl); }
public ServerInstance(string serverName, bool writeThrough, int instance, int maxServerCount) { myMemoryStream = new MemoryStream(buffSize); myReadPos = 0; myThreadRunning = true; myInstance = instance; myBuffer = new byte[buffSize]; myThread = new Thread(new ThreadStart(ProcessServerStream)); myThread.Start(); myNamedPipeServerStream = new NamedPipeServerStream( serverName, PipeDirection.InOut, maxServerCount, PipeTransmissionMode.Byte, writeThrough ? PipeOptions.Asynchronous | PipeOptions.WriteThrough : PipeOptions.Asynchronous); myNamedPipeServerStream.BeginWaitForConnection(new AsyncCallback(OnConnect), null); }
private void waitForAdditionalInstances(string[] args) { var accumulatedArgs = new List <string>(args); while (true) { var signal = new ManualResetEvent(false); using (var pipeServer = new NamedPipeServerStream(ipcNamedPipeGuid, PipeDirection.In, -1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous)) { pipeServer.BeginWaitForConnection(x => { // if timed out, stop waiting for a connection if (signal.WaitOne(0)) { signal.Close(); return; } pipeServer.EndWaitForConnection(x); signal.Set(); }, null); // no client connected to the pipe within the Timeout period if (!signal.WaitOne(Timeout, true)) { signal.Set(); break; } using (var sr = new StreamReader(pipeServer)) { int length = Convert.ToInt32(sr.ReadLine()); for (int i = 0; i < length; ++i) { accumulatedArgs.Add(sr.ReadLine()); } } } // new args have been added to accumulatedArgs, continue loop to listen for another client } ipcMutex.Close(); Launching(this, new SingleInstanceEventArgs(accumulatedArgs.ToArray())); }
private async void ConnectionCallback(IAsyncResult asyncResult) { try { using (var pipeServer = asyncResult.AsyncState as NamedPipeServerStream) // get the pipeserver { if (pipeServer != null) { pipeServer.EndWaitForConnection(asyncResult); // finish connection byte[] buffer = new byte[16 * 1024]; using (MemoryStream memoryStream = new MemoryStream()) // create mem stream to read in bytes from pipe stream { int read; while ((read = await pipeServer.ReadAsync(buffer, 0, buffer.Length)) > 0) // read to the end of the stream { memoryStream.Write(buffer, 0, read); // write the bytes to memory } var json = GetString(memoryStream.ToArray()); // convert bytes to string var msg = Newtonsoft.Json.JsonConvert.DeserializeObject <KioskMessage <object> >(json); // deserialize to message with object payload - payload will be a json string when <object> is used as generic type var assembly = typeof(KioskMessage <object>).Assembly; // find the assembly where are payload types can be found var dataType = assembly.GetType(msg.DataType); // get the type of the payload var payload = Newtonsoft.Json.JsonConvert.DeserializeObject(msg.Data.ToString(), dataType); // deserialize the payload json to the correct type switch (dataType.FullName) // brittle switch statements based on type string - better way? { case "KinectPOC.Common.Messages.Demographics": RaiseDemographicsEvent(payload as DemographicData); break; } } pipeServer.Close(); } } var newServer = new NamedPipeServerStream(_pipeName, PipeDirection.In, 1, PipeTransmissionMode.Message, PipeOptions.Asynchronous); newServer.BeginWaitForConnection(new AsyncCallback(ConnectionCallback), newServer); } catch (Exception ex) { Debug.WriteLine(ex.Message); } }
public async Task <bool> StartAsync() { if (State != ServerState.Stopped) { return(false); } lock (_stateLock) { if (State != ServerState.Stopped) { return(false); } State = ServerState.Starting; } if (_pipe != null) { await _pipe.DisposeAsync().ConfigureAwait(false); } try { _pipe = new NamedPipeServerStream(_configuration.PipeName, PipeDirection.InOut, 1, PipeTransmissionMode.Message, PipeOptions.Asynchronous | PipeOptions.WriteThrough); _pipe.BeginWaitForConnection(OnConnectionReceived, null); lock (_stateLock) { State = ServerState.Started; } return(true); } catch (Exception ex) { _logger.Error(ex); lock (_stateLock) { State = ServerState.Stopped; } return(false); } }
private void StartNewPipeServer() { if (_pipeServer != null) { throw new InvalidOperationException("Cannot start a new pipe server before destroying previous instance."); } if (_outstandingIO != 0) { throw new InvalidOperationException("Outstanding I/O is not zero."); } _nextPacketIndex = 0; _pipeServer = new NamedPipeServerStream(PipeName, PipeDirection.InOut, 1, PipeTransmissionMode.Message, PipeOptions.Asynchronous); Interlocked.Increment(ref _outstandingIO); _pipeServer.BeginWaitForConnection(OnConnectionAsync, null); }
public void Listen(string pipeName) { try { this.pipeName = pipeName; NamedPipeServerStream pipeServer = new NamedPipeServerStream(pipeName, PipeDirection.In, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous); pipeServer.BeginWaitForConnection (new AsyncCallback(WaitForConnectionCallBack), pipeServer); } catch (Exception exeptionon) { throw exeptionon; } }
private void IpcServerPipeCreate() { // Create message-mode pipe to simplify message transition // Assume all messages will be smaller than the pipe buffer sizes NamedPipeServerStream pipe = new NamedPipeServerStream( _pipeName, PipeDirection.InOut, -1, // maximum instances PipeTransmissionMode.Message, PipeOptions.Asynchronous | PipeOptions.WriteThrough, ServerInBufferSize, ServerOutBufferSize, _pipeSecurity ); // Asynchronously accept a client connection pipe.BeginWaitForConnection(OnClientConnected, pipe); }
private static void _AsyncConnectionHandler(IAsyncResult result) { NamedPipeServerStream srv = result.AsyncState as NamedPipeServerStream; srv.EndWaitForConnection(result); BinaryFormatter bf = new BinaryFormatter(); string[] inargs = bf.Deserialize(srv) as string[]; AddFiles(inargs); srv.Close(); srv = new NamedPipeServerStream(_AppName + "IPC", PipeDirection.InOut, 1, PipeTransmissionMode.Message, PipeOptions.Asynchronous); srv.BeginWaitForConnection(new AsyncCallback(_AsyncConnectionHandler), srv); }
private void StartNewPipeServer() { _pipeServer = new NamedPipeServerStream(_pipeName, PipeDirection.In, 254, PipeTransmissionMode.Message, PipeOptions.Asynchronous); #if !NETSTANDARD1_6 _pipeServer.BeginWaitForConnection(WaitForConnectionCallBack, null); #elif NETSTANDARD1_6 Task.Run(async() => { await _pipeServer.WaitForConnectionAsync(); try { WaitForConnectionCallBack(null); } catch (ObjectDisposedException) { } }); #endif }
private void IpcServerPipeCreate() { // Create message-mode pipe to simplify message transition // Assume all messages will be smaller than the pipe buffer sizes NamedPipeServerStream pipe = new NamedPipeServerStream( m_pipename, PipeDirection.InOut, -1, // maximum instances PipeTransmissionMode.Message, PipeOptions.Asynchronous | PipeOptions.WriteThrough, SERVER_IN_BUFFER_SIZE, SERVER_OUT_BUFFER_SIZE, m_ps ); // Asynchronously accept a client connection AwaitingClientConnection = pipe.BeginWaitForConnection(OnClientConnected, pipe); }
static void PipeHandler(IAsyncResult res) { NamedPipeServerStream nps = res.AsyncState as NamedPipeServerStream; // End the current connection. nps.EndWaitForConnection(res); string data = Name + ":" + Port + "\r\n"; nps.Write(Encoding.ASCII.GetBytes(data), 0, data.Length); nps.Flush(); nps.WaitForPipeDrain(); nps.Disconnect(); // Start the new connection. nps.BeginWaitForConnection(PipeHandler, nps); }
private void ClientConnected(IAsyncResult result) { NamedPipeServerStream asyncState = result.AsyncState as NamedPipeServerStream; asyncState.EndWaitForConnection(result); if (asyncState.IsConnected) { NamedPipeTransport item = new NamedPipeTransport(asyncState, PipeName); item.MessageReceived += new MessageEventHandler(OnMessageReceived); lock (mConnections) { mConnections.Add(item); } } NamedPipeServerStream state = new NamedPipeServerStream(PipeName, PipeDirection.InOut, -1, PipeTransmissionMode.Message, PipeOptions.Asynchronous); state.BeginWaitForConnection(new AsyncCallback(this.ClientConnected), state); }
public Boolean Start() { Trace("Start"); _isStopping = false; try { this._pipeServer = new NamedPipeServerStream(this._pipeName, PipeDirection.InOut, 16, PipeTransmissionMode.Message, PipeOptions.Asynchronous); _pipeServer.BeginWaitForConnection(WaitForConnectionCallBack, null); return(true); } catch (Exception ex) { Trace(ex, "BeginWaitForConnection"); return(false); } }
private void RunSendingServer(string pipeName, IpcCommands command, Func <object> function) { _namedPipeServer = new NamedPipeServerStream(NamedPipe.GetUserPipeName(pipeName), PipeDirection.Out, 2, PipeTransmissionMode.Message, PipeOptions.Asynchronous); AsyncCallback ac = null; ac = o => { NamedPipeServerStream s = (NamedPipeServerStream)o.AsyncState; try { if (disposedValue) { return; } s.EndWaitForConnection(o); object data = function.Invoke(); using (MemoryStream ms = new MemoryStream()) { ms.WriteByte((byte)command); if (data != null) { BinaryFormatter bf = new BinaryFormatter(); bf.Serialize(ms, data); } ms.Seek(0, SeekOrigin.Begin); ms.CopyTo(s); s.Flush(); s.WaitForPipeDrain(); } s.Disconnect(); s.BeginWaitForConnection(ac, s); } catch (Exception) { s.Dispose(); RunSendingServer(pipeName, command, function); } }; _namedPipeServer.BeginWaitForConnection(ac, _namedPipeServer); }
/// <summary> /// Called whenever a new environment has been received. /// </summary> /// <param name="ar">The results of the aysnchronous operation.</param> /// <remarks> /// Byte Array to Structure code taken from @cite stackOverflowByte (http://stackoverflow.com/questions/3278827/how-to-convert-structure-to-byte-array-in-c) /// </remarks> private void EnvironmentReceived(IAsyncResult ar) { var environment = new StatusReport(); var size = Marshal.SizeOf(environment); if (disposed) { return; } pipeServer.EndWaitForConnection(ar); var bytes = new List <byte>(); var buffer = new byte[size]; pipeServer.Read(buffer, 0, size); bytes.AddRange(buffer); var array = bytes.ToArray(); var ptr = Marshal.AllocHGlobal(size); Marshal.Copy(array, 0, ptr, size); lock (latestEnvironmentLocker) { var report = (StatusReport)Marshal.PtrToStructure(ptr, typeof(StatusReport)); latestEnvironment = report.Environment; CurrentVector = report.FieldVector; fieldType = report.FieldType; latestBallVelocity = report.BallVelocity; } if (!worker.IsBusy) { worker.RunWorkerAsync(); } Marshal.FreeHGlobal(ptr); pipeServer.Disconnect(); pipeServer.BeginWaitForConnection(EnvironmentReceived, null); }
public MainWindow(string[] args) { InitializeComponent(); SystemEvents.SessionEnding += SystemEvents_SessionEnding; _nzbDrive = new NZBDriveDLL.NZBDrive(); _nzbDrive.LogLevel = NZBDriveDLL.LogLevelType.Info; this.Closing += MainWindow_Closing; _nzbDrive.EventLog += _nzbDrive_EventLog; _model = new NZBDriveModel(_nzbDrive); this.DataContext = _model; NZBDriveView.Model = _model; StatusBox.Status = _model.Status; ToolBar.Model = _model; _nzbDrive.ConnectionStateChanged += _nzbDrive_ConnectionStateChanged; _nzbDrive.NZBFileOpen += _nzbDrive_NZBFileOpen; _nzbDrive.NZBFileClose += _nzbDrive_NZBFileClose; _nzbDrive.FileAdded += _nzbDrive_FileAdded; _nzbDrive.FileRemoved += _nzbDrive_FileRemoved; _nzbDrive.FileInfo += _nzbDrive_FileInfo; _nzbDrive.FileSegmentStateChanged += _nzbDrive_FileSegmentStateChanged; _nzbDrive.ConnectionInfo += _nzbDrive_ConnectionInfo; _model.MountStatusHandle += _model_MountStatus; NZBDriveSettings.Load(_model); _model.SettingsChanged += model_SettingsChanged; this.ContentRendered += MainWindow_ContentRendered; _pipe = new NamedPipeServerStream("NZBDriveApplicationPipe", PipeDirection.In, 254, PipeTransmissionMode.Message, PipeOptions.Asynchronous); _pipeCallback = new AsyncCallback(PipedConnectionCallBack); _pipe.BeginWaitForConnection(_pipeCallback, this); _model.Mount(args); }
private Process StartProcessWithRequest(AgentRequest request, string workingDirectory) { var agentPath = request.GetType().Assembly.Location; var startInfo = new ProcessStartInfo(agentPath) { WorkingDirectory = workingDirectory, UseShellExecute = false, RedirectStandardOutput = true, RedirectStandardError = true, RedirectStandardInput = true, CreateNoWindow = true }; using (var activationDirectory = new WorkingDirectory()) { startInfo.EnvironmentVariables["COMPLUS_ApplicationMigrationRuntimeActivationConfigPath"] = activationDirectory.DirectoryInfo.FullName; if (_clrVersion == ClrVersion.Version4) { var configPath = Path.Combine(activationDirectory.DirectoryInfo.FullName, string.Concat(Path.GetFileName(agentPath), ".activation_config")); File.WriteAllText(configPath, ClrVersion4ActivationConfigContent); } var namedPipeName = string.Format("{0}.{1}", GetType().FullName, Guid.NewGuid()); startInfo.Arguments = namedPipeName; using (var pipeServer = new NamedPipeServerStream(namedPipeName, PipeDirection.InOut, 1, PipeTransmissionMode.Message, PipeOptions.Asynchronous)) { var messagePipe = new MessagePipe(pipeServer); var ar = pipeServer.BeginWaitForConnection(null, pipeServer); var process = Process.Start(startInfo); pipeServer.EndWaitForConnection(ar); messagePipe.WriteMessage(request); pipeServer.WaitForPipeDrain(); return(process); } } }
public void TestOneWay_XML() { PipeSecurity ps = new PipeSecurity(); ps.AddAccessRule( new PipeAccessRule( "USERS", PipeAccessRights.CreateNewInstance | PipeAccessRights.ReadWrite, System.Security.AccessControl.AccessControlType.Allow)); // We first spin a pipe server to make sure that the send port will be able to connect using (NamedPipeServerStream pipeServer = new NamedPipeServerStream( "OneWaySend", PipeDirection.InOut, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous, 1024, 1024, ps)) { string xml = "<SomeTestMessage><Element1 attribute1=\"attributeValue\"></Element1><Element2>Some element content</Element2></SomeTestMessage>"; OutboundTestHelper testHelper = new OutboundTestHelper(pipeServer); pipeServer.BeginWaitForConnection(cb => testHelper.ClientConnected(cb), testHelper); //Here we spin the pipe client that will send the message to BizTalk using (NamedPipeClientStream pipeClient = new NamedPipeClientStream("localhost", "OneWayReceive", PipeDirection.InOut, PipeOptions.Asynchronous)) { byte[] xmlBytes = Encoding.UTF8.GetBytes(xml); pipeClient.Connect(10000); pipeClient.Write(xmlBytes, 0, xmlBytes.Count()); pipeClient.WriteByte(0x00);//writing the EOF byte pipeClient.Flush(); pipeClient.WaitForPipeDrain(); } //Here we wait for the event to be signalled testHelper.syncEvent.WaitOne(60000); //The event was signalled, we get the message stirng from the outBuffer string receivedXml = Encoding.UTF8.GetString(testHelper.memStream.ToArray(), 0, (int)testHelper.memStream.Length); Assert.AreEqual(xml, receivedXml, "Contents of the received message is different"); } }