void SendToPipe() { byte[] buffer = ASCIIEncoding.ASCII.GetBytes ("done"); System.IO.Pipes.NamedPipeClientStream clientStream = new System.IO.Pipes.NamedPipeClientStream ("mypipe"); clientStream.Connect (System.TimeSpan.MaxValue.Seconds); clientStream.WaitForPipeDrain(); clientStream.Write (buffer, 0, buffer.Length); clientStream.Flush (); clientStream.Dispose(); clientStream.Close(); }
private static void Main(string[] args) { try { if (args.Length > 1) { var pipeGuid = args[0]; NamedPipeClientStream pipeClient = new NamedPipeClientStream(".", pipeGuid, PipeDirection.InOut); pipeClient.Connect(); var dlls = args.Skip(2).ToArray(); var nunit3ConsoleExePath = Encoding.UTF8.GetString(Convert.FromBase64String(args[1])); Write(pipeClient, Discover(dlls, pipeClient, nunit3ConsoleExePath)); pipeClient.WaitForPipeDrain(); pipeClient.Close(); } } catch (Exception ex) { var sb = new StringBuilder(); sb.AppendLine(ex.Message); sb.AppendLine(ex.StackTrace); foreach (var arg in args) sb.AppendLine(arg); string fileName = DateTime.Now.ToString("YYYY-MM-DD hh:mm:ss"); Guid parsedGuid; if (args.Length > 0 && Guid.TryParse(args[0], out parsedGuid)) fileName = parsedGuid.ToString(); try { File.WriteAllText(fileName, sb.ToString()); } catch (Exception) { } Console.WriteLine(sb.ToString()); } }
public static bool SendMessage(Command cmd) { try { using (NamedPipeClientStream pipeClient = new NamedPipeClientStream(".", PipeServer.SERVERNAME, PipeDirection.InOut)) { // Connect to the pipe or wait until the pipe is available. Log.Write("Attempting to connect to pipe: " + PipeServer.SERVERNAME); pipeClient.Connect(1000); Log.Write("Connected to pipe."); StreamWriter sw = new StreamWriter(pipeClient); { sw.AutoFlush = true; sw.WriteLine(cmd.ToString()); pipeClient.WaitForPipeDrain(); Log.Write("Pipe Message Sent: " + cmd.ToString()); } StreamReader sr = new StreamReader(pipeClient); { string temp; while ((temp = sr.ReadLine()) != null) { Log.Write("Pipe Message Received: " + temp); if (temp == "done") return true; else if (temp == "failed") return false; } } sw.Close(); sr.Close(); } } catch (Exception exc) { Log.Write(exc.ToString(), true); return false; } return false; }
private void pipeWorker (object args) { try { string value = args.ToString(); _pipeStream = new NamedPipeClientStream( ".", _pipeName, PipeDirection.Out ); _pipeStream.Connect(); byte[] messageBytes = Encoding.UTF8.GetBytes( value ); _pipeStream.Write( messageBytes, 0, messageBytes.Length ); _pipeStream.WaitForPipeDrain(); _pipeStream.Close(); Thread.Sleep( 5000 ); _sendingFinished.Set(); } catch { } }
static void Main(string[] args) { try { if (args.Length > 1) { NamedPipeClientStream pipeClient = new NamedPipeClientStream(".", args[0], PipeDirection.InOut); pipeClient.Connect(); Discover(args, pipeClient); pipeClient.WaitForPipeDrain(); pipeClient.Close(); } } catch (Exception ex) { Console.WriteLine(ex.Message); } }
public static void RunProperMode(Command command) { if (command.ContainsCommandArg("/Uninstall")) { // Are we in uninstall-mode? UninstallHelper uninstallHelper = new UninstallHelper(); uninstallHelper.RunUninstall(); } else if (command.ContainsCommandArg("-silentinstall")) { Globals.InPortableMode = command["-portable"].ToBool(); Globals.IsSilentInstall = true; NamedPipeClientStream pipeClient = new NamedPipeClientStream(".", "www.pmuniverse.net-installer", PipeDirection.InOut, PipeOptions.None, System.Security.Principal.TokenImpersonationLevel.Impersonation); pipeClient.Connect(); Pipes.StreamString clientStream = new Pipes.StreamString(pipeClient); Globals.SilentInstallCommunicationPipeStream = clientStream; Globals.SilentInstallCommunicationPipe = pipeClient; installWaitEvent = new ManualResetEvent(false); Installer installer = new Installer(command); installer.InstallComplete += new EventHandler(installer_InstallComplete); installer.Install(clientStream); installWaitEvent.WaitOne(); clientStream.WriteString("[InstallComplete]"); pipeClient.WaitForPipeDrain(); pipeClient.Close(); System.Environment.Exit(0); } else { // There are no special command line arguments, run the installer in install mode // Let's check if we elevated ourselves if (!Globals.CommandLine.ContainsCommandArg("/skipwelcome") || !VistaSecurity.IsAdmin()) { // Show the welcome page PageManager.ActivePage = new Pages.pgeWelcome(); } else { // Show the license page PageManager.ActivePage = new Pages.pgeLicense(); } } }
/// <summary> /// check if given exe already running or not /// </summary> /// <returns>returns true if already running</returns> public static bool IfAlreadyRunningDoSwitch() { string strLoc = Assembly.GetExecutingAssembly().Location; FileSystemInfo fileInfo = new FileInfo(strLoc); string sExeName = fileInfo.Name; bool bCreatedNew = false; _mutex = new Mutex(true, "Global\\"+sExeName, out bCreatedNew); if (bCreatedNew) { _mutex.ReleaseMutex(); _PipeThread = new Thread(new System.Threading.ThreadStart(PipeThread)); _PipeThread.Name = "Pipe"; _PipeThread.Start(); Application.ApplicationExit += new EventHandler(Application_ApplicationExit); } else { using (NamedPipeClientStream pipeStream = new NamedPipeClientStream(NamedPipeName)) { // The connect function will indefinitely wait for the pipe to become available // If that is not acceptable specify a maximum waiting time (in ms) pipeStream.Connect(); using (StreamWriter sw = new StreamWriter(pipeStream)) { string[] Args = Environment.GetCommandLineArgs(); sw.AutoFlush = true; sw.WriteLine(Args.Length >= 2 ? Args[1] : string.Empty); pipeStream.WaitForPipeDrain(); } } } return !bCreatedNew; }
private void Init() { if (PipeExists(PIPENAME)) { using (NamedPipeClientStream client = new NamedPipeClientStream(PIPENAME)) { try { client.Connect(2000); client.Write(SHOW, 0, SHOW.Length); client.WaitForPipeDrain(); } catch { } } Environment.Exit(1); } using (NamedPipeServerStream server = new NamedPipeServerStream(PIPENAME)) { while (true) { server.WaitForConnection(); byte[] data = new byte[255]; int count = server.Read(data, 0, data.Length); string msg = Encoding.ASCII.GetString(data, 0, count).ToUpper(); if (msg.Equals("SHOW")) { main.Invoke(new MethodInvoker(delegate { main.Show(); main.WindowState = FormWindowState.Normal; })); } else if (msg.Equals("BREAK")) { break; } else if (msg.Equals("EXIT")) { Environment.Exit(0); } server.Disconnect(); } } }
public static void NotifYUser(Settings settings, SettingsPrinter printer, List<InkLevel> inkLevel) { string title = "Printer Ink is at low level"; string body = ""; //body += title + "\n\r\n\r"; body += "Printer Details:\n\r"; body += printer.Name + "\n\r"; foreach (var level in inkLevel) { if (level.Value <= printer.Level) { body += string.Format("{0} - {1:00%}\n\r", level.Name, level.Value); } } body += "\n\r\n\r*****"; try { var pipeClient = new NamedPipeClientStream("InkMonPipe"); pipeClient.Connect(3000); if (pipeClient.IsConnected) { var buf = Encoding.ASCII.GetBytes(body); pipeClient.Write(buf, 0, buf.Length); pipeClient.WaitForPipeDrain(); pipeClient.Close(); } } catch (Exception e) { Console.WriteLine(e); } }
protected override void OnStartup(StartupEventArgs e) { if (e.Args == null) _exeArguments = new string[0]; else _exeArguments = e.Args; AppDomain.CurrentDomain.UnhandledException += UncaughtThreadException; DispatcherUnhandledException += UncaughtUiThreadException; using (WindowsIdentity identity = WindowsIdentity.GetCurrent()) _pipeName = String.Format("DayZeroLauncher_{{{0}}}_Instance", identity.User); bool secondInstance = false; using (var pipeConn = new NamedPipeClientStream(".", _pipeName, PipeDirection.Out)) { try { const int timeoutMs = 100; pipeConn.Connect(timeoutMs); pipeConn.ReadMode = PipeTransmissionMode.Message; string queryString = GetQueryParams(); if (!string.IsNullOrEmpty(queryString)) { byte[] bytesToWrite = Encoding.UTF8.GetBytes(queryString); pipeConn.Write(bytesToWrite, 0, bytesToWrite.Length); pipeConn.WaitForPipeDrain(); } secondInstance = true; pipeConn.Close(); } catch (TimeoutException) { } } if (secondInstance) //already sent message to pipe { Shutdown(); return; } //we are the only app, start the server StartPipeServer(); LocalMachineInfo.Current.Update(); base.OnStartup(e); }
public static Task<bool> SendMessageAsync(object message, string pipeName, bool wait = true) { return Task.Run<bool>(new Func<bool>(() => { try { using (NamedPipeClientStream pipeClient = new NamedPipeClientStream(".", pipeName, PipeDirection.Out, PipeOptions.None, TokenImpersonationLevel.None)) { using (MemoryStream ms = new MemoryStream()) { if (wait) { int i = 0; for (; i != 20; i++) { if (!NamedPipeDoesNotExist(pipeName)) break; Thread.Sleep(50); } if (i == 20) return false; } if (NamedPipeDoesNotExist(pipeName)) return false; pipeClient.Connect(10); BinaryFormatter bf = new BinaryFormatter(); bf.Serialize(ms, message); ms.Seek(0, SeekOrigin.Begin); ms.CopyTo(pipeClient); pipeClient.Flush(); pipeClient.WaitForPipeDrain(); } } return true; } catch (Exception e) { Logging.LogException(e); return false; } })); }
public static void HandleCommandLine (int connectTimeoutMs = 2500) { var commandLineArgs = Environment.GetCommandLineArgs(); if ((commandLineArgs.Length == 3) && (commandLineArgs[1] == "--buildSolution")) { try { var jss = new JavaScriptSerializer { MaxJsonLength = 1024 * 1024 * 64 }; var pipeId = commandLineArgs[2]; using (var pipe = new NamedPipeClientStream(pipeId)) { pipe.Connect(connectTimeoutMs); using (var sr = new StreamReader(pipe)) using (var sw = new StreamWriter(pipe)) { var argsJson = sr.ReadLine(); var argsDict = jss.Deserialize<Dictionary<string, object>>(argsJson); var buildResult = Build( (string)argsDict["solutionFile"], (string)argsDict["buildConfiguration"], (string)argsDict["buildPlatform"], (string)argsDict["buildTarget"], (string)argsDict["logVerbosity"], true ); var resultJson = jss.Serialize(buildResult); sw.WriteLine(resultJson); sw.Flush(); pipe.Flush(); pipe.WaitForPipeDrain(); } } } catch (Exception exc) { Console.Error.WriteLine(exc.ToString()); Environment.Exit(1); } Environment.Exit(0); } }
static void Main(string[] args) { // get application GUID as defined in AssemblyInfo.cs string appGuid = ((GuidAttribute)Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(GuidAttribute), false).GetValue(0)).Value.ToString(); // unique id for global mutex - Global prefix means it is global to the machine string mutexId = string.Format("Global\\{{{0}}}", appGuid); using (var mutex = new Mutex(false, mutexId)) { // edited by Jeremy Wiebe to add example of setting up security for multi-user usage // edited by 'Marc' to work also on localized systems (don't use just "Everyone") var allowEveryoneRule = new MutexAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.FullControl, AccessControlType.Allow); var securitySettings = new MutexSecurity(); securitySettings.AddAccessRule(allowEveryoneRule); mutex.SetAccessControl(securitySettings); // edited by acidzombie24 var hasHandle = false; try { try { // note, you may want to time out here instead of waiting forever // edited by acidzombie24 // mutex.WaitOne(Timeout.Infinite, false); hasHandle = mutex.WaitOne(500, false); if (hasHandle == false) { if (args.Count() == 1) { if (args[0] == "update") { //TODO: send message to pipe NamedPipeClientStream pipe = new NamedPipeClientStream(".", "NXTLibTesterGUI_forceupdatepipe", PipeDirection.Out); StreamWriter sw = new StreamWriter(pipe); pipe.Connect(); sw.AutoFlush = true; sw.WriteLine("Force Update Now!"); pipe.WaitForPipeDrain(); pipe.Dispose(); } return; } MessageBox.Show("Application already running! Close the other instance and try again.", "Application Running", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } } catch (AbandonedMutexException) { // Log the fact the mutex was abandoned in another process, it will still get aquired hasHandle = true; } FindNXT.updatewaiting = false; if (args.Count() == 1) { if (args[0] == "update") { FindNXT.updatewaiting = true; } } // Perform your work here. Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new FindNXT()); } finally { // edited by acidzombie24, added if statemnet if (hasHandle) mutex.ReleaseMutex(); } } }
private void QvxCommandWorker() { try { if (pipeName == null) return; object state = new object(); object connection = null; using (NamedPipeClientStream pipeClient = new NamedPipeClientStream(".", pipeName, PipeDirection.InOut)) { var buf = new byte[4]; var buf2 = new byte[4]; Int32 count = 0; Int32 datalength = 0; pipeClient.Connect(1000); while (pipeClient.IsConnected) { try { #region Get QvxRequest var iar = pipeClient.BeginRead(buf, 0, 4, null, state); while (!iar.IsCompleted) Thread.Sleep(1); count = pipeClient.EndRead(iar); if (count != 4) throw new Exception("Invalid Count Length"); buf2[0] = buf[3]; buf2[1] = buf[2]; buf2[2] = buf[1]; buf2[3] = buf[0]; datalength = BitConverter.ToInt32(buf2, 0); var data = new byte[datalength]; count = pipeClient.Read(data, 0, datalength); if (count != datalength) throw new Exception("Invalid Data Length"); var sdata = ASCIIEncoding.ASCII.GetString(data); sdata = sdata.Replace("\0", ""); QvxRequest request; try { request = QvxRequest.Deserialize(sdata); } catch (Exception ex) { logger.Error(ex); throw ex; } request.QVWindow = QVWindow; request.Connection = connection; #endregion #region Handle QvxRequets QvxReply result = null; if (HandleQvxRequest != null) result = HandleQvxRequest(request); if (result == null) result = new QvxReply() { Result = QvxResult.QVX_UNKNOWN_ERROR }; #endregion #region Send QvxReply sdata = " " + result.Serialize() + "\0"; datalength = sdata.Length - 4; buf2 = ASCIIEncoding.ASCII.GetBytes(sdata); buf = BitConverter.GetBytes(datalength); buf2[0] = buf[3]; buf2[1] = buf[2]; buf2[2] = buf[1]; buf2[3] = buf[0]; pipeClient.Write(buf2, 0, buf2.Length); pipeClient.WaitForPipeDrain(); #endregion #region Handle result States if (result.Terminate) close = true; if (result.Connection != null) connection = result.Connection; if (result.SetConnectionNULL) connection = null; #endregion } catch (Exception ex) { logger.Error(ex); Thread.Sleep(500); close = true; } if (close) { close = false; pipeClient.Close(); } Thread.Sleep(5); } } running = false; } catch (Exception ex) { logger.Error(ex); } }
public static async Task ClientPInvokeChecks() { using (NamedPipeServerStream server = new NamedPipeServerStream("foo", PipeDirection.In, 1, PipeTransmissionMode.Byte, PipeOptions.None, 4096, 4096)) { using (NamedPipeClientStream client = new NamedPipeClientStream(".", "foo", PipeDirection.Out)) { Task serverTask = DoServerOperationsAsync(server); client.Connect(); Assert.False(client.CanRead); Assert.False(client.CanSeek); Assert.False(client.CanTimeout); Assert.True(client.CanWrite); Assert.False(client.IsAsync); Assert.True(client.IsConnected); if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { Assert.Equal(0, client.OutBufferSize); } else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) { Assert.True(client.OutBufferSize > 0); } else { Assert.Throws<PlatformNotSupportedException>(() => client.OutBufferSize); } Assert.Equal(PipeTransmissionMode.Byte, client.ReadMode); Assert.NotNull(client.SafePipeHandle); Assert.Equal(PipeTransmissionMode.Byte, client.TransmissionMode); client.Write(new byte[] { 123 }, 0, 1); await client.WriteAsync(new byte[] { 124 }, 0, 1); if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { client.WaitForPipeDrain(); } else { Assert.Throws<PlatformNotSupportedException>(() => client.WaitForPipeDrain()); } client.Flush(); await serverTask; } } using (NamedPipeServerStream server = new NamedPipeServerStream("foo", PipeDirection.Out)) { using (NamedPipeClientStream client = new NamedPipeClientStream(".", "foo", PipeDirection.In)) { Task serverTask = DoServerOperationsAsync(server); client.Connect(); if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { Assert.Equal(0, client.InBufferSize); } else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) { Assert.True(client.InBufferSize > 0); } else { Assert.Throws<PlatformNotSupportedException>(() => client.InBufferSize); } byte[] readData = new byte[] { 0, 1 }; Assert.Equal(1, client.Read(readData, 0, 1)); Assert.Equal(1, client.ReadAsync(readData, 1, 1).Result); Assert.Equal(123, readData[0]); Assert.Equal(124, readData[1]); await serverTask; } } }
private Response GetResponse(Request request) { _pipeClient = CreateClientPipe(); TryConnect(_pipeClient); _pipeClient.WriteByte((byte)request); _pipeClient.WriteByte((byte)_pos); _pipeClient.WaitForPipeDrain(); Response response = (Response)_pipeClient.ReadByte(); return response; }
public void Send(byte[] message) { using ( var pipeClientStream = new NamedPipeClientStream( ".", this.hookServerChannelName, PipeDirection.Out, PipeOptions.None)) { pipeClientStream.Connect(); pipeClientStream.Write(message, 0, message.Length); try { pipeClientStream.WaitForPipeDrain(); } catch { Debug.WriteLine("pipe bandaid!"); } } }
private void Send(string message) { try { if (string.IsNullOrWhiteSpace(message)) return; using (var pipeStream = new NamedPipeClientStream (".", PipeName, PipeDirection.Out, PipeOptions.Asynchronous)) { pipeStream.Connect(Timeout*1000); var buffer = Encoding.UTF8.GetBytes(message); pipeStream.Write(buffer, 0, buffer.Length); pipeStream.Flush(); pipeStream.WaitForPipeDrain(); } } catch (Exception e) { Log.WarnFormat("An exception occurred while trying to send '{0}' to pipe '{1}': {2}", Message, PipeName, e.Message); } }
private string ReadWriteMessage(NamedPipeClientStream pipeClient, string message) { try { ChannelStream channelStream = new ChannelStream(pipeClient); channelStream.Send(message); pipeClient.WaitForPipeDrain(); string response = channelStream.Receive(); pipeClient.Close(); return response; } catch { return null; } }
public MainForm(string wzToLoad, bool usingPipes, bool firstrun) { InitializeComponent(); encryptionBox.Items.Add(HaRepacker.Properties.Resources.EncTypeGMS); encryptionBox.Items.Add(HaRepacker.Properties.Resources.EncTypeMSEA); encryptionBox.Items.Add(HaRepacker.Properties.Resources.EncTypeNone); #if DEBUG debugToolStripMenuItem.Visible = true; #endif WindowState = ApplicationSettings.Maximized ? FormWindowState.Maximized : FormWindowState.Normal; Size = ApplicationSettings.WindowSize; if (usingPipes) { try { Program.pipe = new NamedPipeServerStream(Program.pipeName, PipeDirection.In); Program.pipeThread = new Thread(new ThreadStart(PipeServer)); Program.pipeThread.IsBackground = true; Program.pipeThread.Start(); } catch (IOException) { if (wzToLoad != null) { try { NamedPipeClientStream clientPipe = new NamedPipeClientStream(".", Program.pipeName, PipeDirection.Out); clientPipe.Connect(0); StreamWriter sw = new StreamWriter(clientPipe); sw.WriteLine(wzToLoad); clientPipe.WaitForPipeDrain(); sw.Close(); Environment.Exit(0); } catch (TimeoutException) { } } } } if (wzToLoad != null && File.Exists(wzToLoad)) { short version; WzMapleVersion encVersion = WzTool.DetectMapleVersion(wzToLoad, out version); encryptionBox.SelectedIndex = (int)encVersion; LoadWzFileThreadSafe(wzToLoad, MainPanel, false); } WzNode.ContextMenuBuilder = new WzNode.ContextMenuBuilderDelegate(new ContextMenuManager(MainPanel.UndoRedoMan).CreateMenu); }
private void QvxDataWorker() { try { if (pipeName == null) return; logger.Info("Start :" + pipeName); using (NamedPipeClientStream pipeClient = new NamedPipeClientStream(".", pipeName, PipeDirection.Out)) { pipeClient.Connect(1000); if (pipeClient.IsConnected) { if (DataClientDeliverData != null) { var thread = new Thread( new ThreadStart(() => { DataClientDeliverData(this); this.Close(); })); thread.IsBackground = false; thread.Name = "DataClientDeliverDataThread"; thread.Start(); } } while (pipeClient.IsConnected) { byte[] buffer = null; List<byte[]> sendList = null; lock (lockQueue) { if (SendQueue.Count > 0) { sendList = SendQueue; SendQueue = new List<byte[]>(); } } if (sendList != null) { int reqSize = 0; for (int i = 0; i < sendList.Count; i++) reqSize += sendList[i].Length; if (reqSize > 0) { buffer = new byte[reqSize]; reqSize = 0; for (int i = 0; i < sendList.Count; i++) { sendList[i].CopyTo(buffer, reqSize); reqSize += sendList[i].Length; } } } if (buffer != null) { int index = 0; int tosend = buffer.Length; int sendnow = 0; while (tosend > 0) { sendnow = tosend; if ((sendnow > pipeClient.OutBufferSize) && (pipeClient.OutBufferSize > 0)) sendnow = pipeClient.OutBufferSize; pipeClient.Write(buffer, index, sendnow); index += sendnow; tosend -= sendnow; pipeClient.WaitForPipeDrain(); } } if (close & (buffer == null)) { logger.Info("Close :" + pipeName); pipeClient.Close(); close = false; } Thread.Sleep(5); } } } catch (Exception ex) { logger.ErrorException("Exceptions:" + pipeName, ex); } }
public static void ClientPInvokeChecks() { using (NamedPipeServerStream server = new NamedPipeServerStream("foo", PipeDirection.In)) { using (NamedPipeClientStream client = new NamedPipeClientStream(".", "foo", PipeDirection.Out)) { Task serverTask = DoServerOperationsAsync(server); client.Connect(); Console.WriteLine("client.CanRead = {0}", client.CanRead); Console.WriteLine("client.CanSeek = {0}", client.CanSeek); Console.WriteLine("client.CanTimeout = {0}", client.CanTimeout); Console.WriteLine("client.CanWrite = {0}", client.CanWrite); Console.WriteLine("client.IsAsync = {0}", client.IsAsync); Console.WriteLine("client.IsConnected = {0}", client.IsConnected); Console.WriteLine("client.OutBufferSize = {0}", client.OutBufferSize); Console.WriteLine("client.ReadMode = {0}", client.ReadMode); Console.WriteLine("client.SafePipeHandle = {0}", client.SafePipeHandle); Console.WriteLine("client.TransmissionMode = {0}", client.TransmissionMode); client.Write(new byte[] { 123 }, 0, 1); client.WriteAsync(new byte[] { 124 }, 0, 1).Wait(); client.WaitForPipeDrain(); client.Flush(); serverTask.Wait(); } } using (NamedPipeServerStream server = new NamedPipeServerStream("foo", PipeDirection.Out)) { using (NamedPipeClientStream client = new NamedPipeClientStream(".", "foo", PipeDirection.In)) { Task serverTask = DoServerOperationsAsync(server); client.Connect(); Console.WriteLine("client.InBufferSize = {0}", client.InBufferSize); byte[] readData = new byte[] { 0, 1 }; client.Read(readData, 0, 1); client.ReadAsync(readData, 1, 1).Wait(); Assert.Equal(123, readData[0]); Assert.Equal(124, readData[1]); serverTask.Wait(); } } }