private void Encoder_Data_Available(object sender, VideoEventArgs e)
{
frame++;
framebytes = e.payload.outbytes;
lastframe = e.payload.uncompressedFrame;
lastframestride = e.payload.stride;
lastframeheight = e.payload.height;
lastframewidth = e.payload.width;
if (isConnected)
{
VideoStream.Write(e.payload.result, 0, e.payload.outbytes);
VideoStream.Flush();
VideoStream.WaitForPipeDrain();
video.ReturnWork(e.payload);
}
if (enableWriteToFile && binaryVideoWriter != null)
{
binaryVideoWriter.Write(e.payload.result, 0, e.payload.outbytes);
binaryVideoWriter.Flush();
}
}
public AnonymousPipes(String pipeName, String clientPath, String cmdLineArgs, CallBack callback, DisconnectEvent disconnectEvent)
{
String args;
this.clientPath = clientPath;
this.callback = callback;
this.disconnectEvent = disconnectEvent;
this.name = pipeName;
this.running = true;
serverMode = true;
args = StartPipeServer() + " " + cmdLineArgs;
try
{
pipeClient = new Process();
pipeClient.StartInfo.FileName = clientPath;
pipeClient.StartInfo.Arguments = args;
pipeClient.StartInfo.UseShellExecute = false;
pipeClient.Start();
} catch (Exception ex)
{
ermsg = ex.Message;
running = false;
return;
}
outGoingServerPipe.DisposeLocalCopyOfClientHandle();
inComingServerPipe.DisposeLocalCopyOfClientHandle();
ssw = new StreamWriter(outGoingServerPipe);
ssw.AutoFlush = true;
ssw.WriteLine("SYNC");
outGoingServerPipe.WaitForPipeDrain();
new Thread(delegate()
{
using (StreamReader isr = new StreamReader(inComingServerPipe))
{
String tmp;
while (running && inComingServerPipe.IsConnected)
{
tmp = isr.ReadLine();
if (tmp != null)
{
callback(tmp);
}
}
}
running = false;
disconnectEvent();
}).Start();
}
static void Main(string[] args)
{
Process pipeClient1 = new Process();
pipeClient1.StartInfo.FileName = @"AnonymousPipeClient.exe";
//AnonymousPipeServerStream is an one-way pipe. in other words it's only support PipeDirection.In or PipeDirection.Out.
//in this program, we use PipeDirection.Out for send data to clients.
using (AnonymousPipeServerStream pipeServer =
new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.Inheritable))
{
//send the client handle that from AnonymousPipeServerStream to client
pipeClient1.StartInfo.Arguments = pipeServer.GetClientHandleAsString();
pipeClient1.StartInfo.UseShellExecute = false;
pipeClient1.Start();
//closes the local copy of the AnonymousPipeClientStream object's handle
//this method must be call after the client handle has been passed to the client
//if this method isn't called, then the AnonymousPipeServerStream will not receive notice when client dispose of it's PipeStream object
pipeServer.DisposeLocalCopyOfClientHandle();
try
{
using (StreamWriter sw = new StreamWriter(pipeServer))
{
//automatic flush
sw.AutoFlush = true;
sw.WriteLine("SYNC");
//it'll block util the other end of pipe has been read all send bytes
pipeServer.WaitForPipeDrain();
String temp = null;
while (true)
{
temp = Console.ReadLine();
//send message to pipeclient from console
sw.WriteLine(temp);
//it'll block util the other end of pipe has been read all send bytes
pipeServer.WaitForPipeDrain();
if (temp == "exit")
{
break;
}
}
}
}
catch (IOException e)
{
Console.WriteLine("[server] exception:{0}", e.Message);
}
}
pipeClient1.WaitForExit();
pipeClient1.Close();
}
public void Stop()
{
m_Server.WaitForPipeDrain();
m_Server.Close();
m_Client.Close();
m_Client.Dispose();
m_Client = null;
m_Server.Dispose();
m_Server = null;
}
private void Audio_RecordingStopped(object sender, StoppedEventArgs e)
{
if (isConnected)
{
AudioStream.Flush();
AudioStream.WaitForPipeDrain();
}
if (enableWriteToFile && binaryAudioWriter != null)
{
binaryAudioWriter.Flush();
binaryAudioWriter.Close();
binaryAudioWriter.Dispose();
}
}
void run()
{
using (pipeServer)
{
StartClient(pipeServer.GetClientHandleAsString());
pipeServer.DisposeLocalCopyOfClientHandle();
using (sw)
{
sw.AutoFlush = true;
sw.WriteLine("SYNC");
pipeServer.WaitForPipeDrain();
while (true)
{
try
{
Evnt.WaitOne();
sw.WriteLine(x);
sw.WriteLine(y);
sem.Release();
}
catch (SemaphoreFullException)
{
}
}
}
}
}
/// <summary>
/// Main task thread for working with a single APSIMRunner.exe process using
/// an anonymous pipe.
/// </summary>
private void PipeServerTaskThread()
{
// Create 2 anonymous pipes (read and write) for duplex communications
// (each pipe is one-way)
using (var pipeRead = new AnonymousPipeServerStream(PipeDirection.In, HandleInheritability.Inheritable))
using (var pipeWrite = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.Inheritable))
{
var pipeHandles = pipeRead.GetClientHandleAsString() + " " + pipeWrite.GetClientHandleAsString();
// Run a APSIMRunner process passing the pipe read and write handles as arguments.
var runnerProcess = new ProcessUtilities.ProcessWithRedirectedOutput();
runnerProcess.Exited += OnExited;
var runnerExecutable = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "APSIMRunner.exe");
runnerProcess.Start(executable: runnerExecutable,
arguments: pipeHandles,
workingDirectory: Directory.GetCurrentDirectory(),
redirectOutput: true,
writeToConsole: false);
// Release the local handles that were created with the above GetClientHandleAsString calls
pipeRead.DisposeLocalCopyOfClientHandle();
pipeWrite.DisposeLocalCopyOfClientHandle();
try
{
// Get the next job to run.
var job = GetJobToRun();
while (job != null)
{
var startTime = DateTime.Now;
// Send the job to APSIMRunner.exe - this will run the simulation.
PipeUtilities.SendObjectToPipe(pipeWrite, job.JobSentToClient);
pipeWrite.WaitForPipeDrain();
// Get the output data back from APSIMRunner.exe
var endJob = PipeUtilities.GetObjectFromPipe(pipeRead) as JobOutput;
// Send the output data to storage.
endJob.WriteOutput(job.DataStore);
// Signal end of job.
InvokeJobCompleted(job.RunnableJob,
job.JobManager,
startTime,
endJob.ErrorMessage);
// Get the next job to run.
job = GetJobToRun();
}
}
catch (Exception err)
{
AddException(err);
}
}
}
private static void sendToBasketApp(AnonymousPipeServerStream pipeServer, StreamWriter sw, string sendingString)
{
// Send a 'sync message' and wait for client to receive it.
sw.WriteLine("SYNC");
pipeServer.WaitForPipeDrain();
// Send the console input to the client process.
sw.WriteLine(sendingString);
}
public static void StartProcess()
{
Process pipeClient = new Process();
pipeClient.StartInfo.FileName = "child.exe";
using (AnonymousPipeServerStream pipeServer =
new AnonymousPipeServerStream(PipeDirection.Out,
HandleInheritability.Inheritable))
{
// Show that anonymous pipes do not support Message mode.
try
{
Console.WriteLine("[SERVER] Setting ReadMode to \"Message\".");
pipeServer.ReadMode = PipeTransmissionMode.Message;
}
catch (NotSupportedException e)
{
Console.WriteLine("[SERVER] Exception:\n {0}", e.Message);
}
Console.WriteLine("[SERVER] Current TransmissionMode: {0}.",
pipeServer.TransmissionMode);
// Pass the client process a handle to the server.
pipeClient.StartInfo.Arguments =
pipeServer.GetClientHandleAsString();
pipeClient.StartInfo.UseShellExecute = false;
pipeClient.Start();
pipeServer.DisposeLocalCopyOfClientHandle();
try
{
// Read user input and send that to the client process.
using (StreamWriter sw = new StreamWriter(pipeServer))
{
sw.AutoFlush = true;
// Send a 'sync message' and wait for client to receive it.
sw.WriteLine("SYNC");
pipeServer.WaitForPipeDrain();
// Send the console input to the client process.
Console.Write("[SERVER] Enter text: ");
sw.WriteLine(Console.ReadLine());
}
}
// Catch the IOException that is raised if the pipe is broken
// or disconnected.
catch (IOException e)
{
Console.WriteLine("[SERVER] Error: {0}", e.Message);
}
}
pipeClient.WaitForExit();
pipeClient.Close();
Console.WriteLine("[SERVER] Client quit. Server terminating.");
}
static void Main()
{
Process pipeClient = new Process();
pipeClient.StartInfo.FileName = "C:/Users/martinH/Desktop/BuiltUnityGame/5cube2fish.exe";
int counter = 0;
using (AnonymousPipeServerStream pipeServer =
new AnonymousPipeServerStream(PipeDirection.Out,
HandleInheritability.Inheritable))
{
Console.WriteLine("[SERVER] Current TransmissionMode: {0}.",
pipeServer.TransmissionMode);
// Pass the client process a handle to the server.
pipeClient.StartInfo.Arguments =
pipeServer.GetClientHandleAsString();
pipeClient.StartInfo.UseShellExecute = false;
pipeClient.Start();
pipeServer.DisposeLocalCopyOfClientHandle();
try
{
// Read user input and send that to the client process.
using (StreamWriter sw = new StreamWriter(pipeServer))
{
// sw.AutoFlush = true;
sw.AutoFlush = false;
Console.WriteLine("Before Loop");
while (counter < 200000)
{
//sw.AutoFlush = true;
// Send a 'sync message' and wait for client to receive it.
sw.WriteLine(counter.ToString());
Console.WriteLine("Writing Sample" + counter.ToString());
pipeServer.WaitForPipeDrain();
counter++;
// Send the console input to the client process.
// Console.Write("[SERVER] Enter text: ");
// sw.WriteLine(Console.ReadLine());
}
Console.WriteLine("Wrote 200K Samples");
}
}
// Catch the IOException that is raised if the pipe is broken
// or disconnected.
catch (IOException e)
{
Console.WriteLine("[SERVER] Error: {0}", e.Message);
}
}
pipeClient.WaitForExit();
pipeClient.Close();
Console.WriteLine("[SERVER] Client quit. Server terminating.");
}
public Relay(Options options)
{
log.Info("creating relay host");
log.Debug("create interprocess input pipe");
pipeIn = new AnonymousPipeServerStream(PipeDirection.In, HandleInheritability.Inheritable);
pipeReader = new StreamReader(pipeIn);
log.Debug("create interprocess output pipe");
pipeOut = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.Inheritable);
pipeWriter = new StreamWriter(pipeOut);
log.Debug("create processor host");
processor = new Process();
processor.StartInfo.FileName = System.Reflection.Assembly.GetExecutingAssembly().Location;
log.DebugFormat("StartInfo.FileName={0}", processor.StartInfo.FileName);
processor.StartInfo.Arguments = String.Format("--pipe-in={0} --pipe-out={1} process", pipeOut.GetClientHandleAsString(), pipeIn.GetClientHandleAsString());
log.DebugFormat("StartInfo.Arguments={0}", processor.StartInfo.Arguments);
processor.StartInfo.UseShellExecute = false;
log.Debug("start processor host");
try
{
processor.Start();
}
catch (Exception ex)
{
log.Fatal("Exception while starting processor host.", ex);
throw ex;
}
log.DebugFormat("processor host process id : {0}", processor.Id);
log.Debug("join processes into a job so processor host dies together with relay host");
job = new Job();
job.AddProcess(Process.GetCurrentProcess().Id);
job.AddProcess(processor.Id);
log.Debug("create native messaging ports");
portA = new Port();
portB = new Port(pipeIn, pipeOut);
portsExceptions = new List <Exception>();
log.Debug("create stop event");
stop = new ManualResetEvent(false);
log.Debug("synchronize processes");
string sync = "SYNC";
pipeWriter.WriteLine(sync);
pipeWriter.Flush();
log.DebugFormat("sent {0}", sync);
pipeOut.WaitForPipeDrain();
sync = pipeReader.ReadLine();
log.DebugFormat("received {0}", sync);
log.Info("created relay host");
}
public void SendLog(LogMessage logMessage)
{
try
{
_pipeServerStreamWriter.WriteLine(JsonConvert.SerializeObject(logMessage));
_logsManagerPipeServer.WaitForPipeDrain();
}
catch (IOException e)
{
Console.WriteLine("[SERVER] Error: {0}", e.Message);
}
}
static void Main(string[] args)
{
string fileName;
if (File.Exists("PipeClient.exe"))
{
fileName = "PipeClient.exe";
}
else
{
fileName = "PipeClientCpp.exe";
}
Process pipeClientProcess = new Process();
pipeClientProcess.StartInfo.FileName = fileName;
using (var pipeServer = new AnonymousPipeServerStream(
PipeDirection.Out, HandleInheritability.Inheritable))
{
Console.WriteLine("[SERVER] Current TransmissionMode: {0}.", pipeServer.TransmissionMode);
pipeClientProcess.StartInfo.Arguments = pipeServer.GetClientHandleAsString();
pipeClientProcess.StartInfo.UseShellExecute = false;
pipeClientProcess.Start();
pipeServer.DisposeLocalCopyOfClientHandle();
try
{
using (var streamWriter = new StreamWriter(pipeServer))
{
streamWriter.AutoFlush = true;
streamWriter.WriteLine("SYNC");
pipeServer.WaitForPipeDrain();
Console.Write("[SERVER] Enter text: ");
streamWriter.WriteLine(Console.ReadLine());
}
}
catch (IOException e)
{
Console.WriteLine("[SERVER] Error: {0}", e.Message);
}
}
pipeClientProcess.WaitForExit();
pipeClientProcess.Close();
Console.WriteLine("[SERVER] Client quit. Server terminating.");
Console.ReadKey();
}
public void StartPatcher()
{
var process = new Process
{
StartInfo =
{
FileName = Path.Combine(Directory.GetCurrentDirectory(), "XIVLauncher.PatchInstaller.exe"),
WorkingDirectory = Directory.GetCurrentDirectory()
}
};
process.StartInfo.Verb = "runas";
using (var pipeServer =
new AnonymousPipeServerStream(PipeDirection.InOut,
HandleInheritability.Inheritable))
{
Console.WriteLine("[SERVER] Current TransmissionMode: {0}.",
pipeServer.TransmissionMode);
// Pass the client process a handle to the server.
process.StartInfo.Arguments =
pipeServer.GetClientHandleAsString();
process.StartInfo.UseShellExecute = false;
process.Start();
pipeServer.DisposeLocalCopyOfClientHandle();
try
{
// Read user input and send that to the client process.
using (StreamWriter sw = new StreamWriter(pipeServer))
{
sw.AutoFlush = true;
// Send a 'sync message' and wait for client to receive it.
sw.WriteLine("SYNC");
pipeServer.WaitForPipeDrain();
// Send the console input to the client process.
Console.Write("[SERVER] Enter text: ");
sw.WriteLine(Console.ReadLine());
}
}
// Catch the IOException that is raised if the pipe is broken
// or disconnected.
catch (IOException e)
{
Console.WriteLine("[SERVER] Error: {0}", e.Message);
}
}
}
public void Close()
{
if (!_disposed)
{
lock (this)
if (!_disposed)
{
_server.WaitForPipeDrain();
_server.Close();
_client.Close();
_disposed = true;
}
}
}
static void Main(string[] args)
{
Console.WriteLine("Kinect for Beat Saber | By Caeden117");
Console.WriteLine("Any launch args for this application will transfer over to Beat Saber! (\"--verbose\" and \"fpfc\", for example.)");
Console.WriteLine("Current launch args: " + string.Join(" ", args));
Console.WriteLine("=============================");
Console.WriteLine("Waiting for Kinect...");
chooser = new KinectSensorChooser();
chooser.KinectChanged += KinectUpdate;
chooser.Start();
Process.GetCurrentProcess().Exited += Exit;
Console.WriteLine("Kinect active. Launching Beat Saber...");
serverStream = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.Inheritable)
{
ReadMode = PipeTransmissionMode.Byte
};
beatSaber = new Process();
beatSaber.StartInfo.FileName = "Beat Saber.exe"; //This NEEDS to be placed in the root Beat Saber folder
beatSaber.StartInfo.Arguments = $"{string.Join(" ", args)} KinectClientHandle={serverStream.GetClientHandleAsString()}";
beatSaber.StartInfo.UseShellExecute = false;
beatSaber.Start();
serverStream.DisposeLocalCopyOfClientHandle();
try
{
Console.WriteLine("Attempting to establish connection...");
sw = new StreamWriter(serverStream)
{
AutoFlush = true
};
sw.WriteLine("SYNC");
serverStream.WaitForPipeDrain();
Console.WriteLine("Connection established! We are good to go!");
}
catch (IOException e)
{
Console.WriteLine(e);
Console.WriteLine("Connection has been terminated.");
}
beatSaber.WaitForExit();
beatSaber.Close();
Console.WriteLine("Beat Saber terminated. Terminating self...");
//Console.ReadLine();
Process.GetCurrentProcess().Close();
}
public static void ServerReadOnlyThrows()
{
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.In))
{
Assert.Throws <NotSupportedException>(() => server.Write(new byte[5], 0, 5));
Assert.Throws <NotSupportedException>(() => server.WriteByte(123));
Assert.Throws <NotSupportedException>(() => server.Flush());
Assert.Throws <NotSupportedException>(() => server.OutBufferSize);
Assert.Throws <NotSupportedException>(() => server.WaitForPipeDrain());
}
}
void StartProcess()
{
this.pipeClient = new Process();
pipeClient.StartInfo.FileName = "pipeClient.exe";
this.eventHandled = new TaskCompletionSource <bool>();
using (AnonymousPipeServerStream pipeServer = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.Inheritable))
{
Console.WriteLine("[SERVER] Current TransmissionMode: {0}.", pipeServer.TransmissionMode);
// Pass the client process a handle to the server.
pipeClient.StartInfo.Arguments = pipeServer.GetClientHandleAsString();
pipeClient.StartInfo.UseShellExecute = false;
// para el exited
pipeClient.EnableRaisingEvents = true;
pipeClient.Exited += new EventHandler(myProcess_Exited);
pipeClient.Start();
pipeServer.DisposeLocalCopyOfClientHandle();
try
{
// Read user input and send that to the client process.
using (StreamWriter sw = new StreamWriter(pipeServer))
{
sw.AutoFlush = true;
// Send a 'sync message' and wait for client to receive it.
sw.WriteLine("SYNC");
pipeServer.WaitForPipeDrain();
// Send the console input to the client process.
Console.Write("[SERVER] Enter text: ");
sw.WriteLine(Console.ReadLine());
}
}
// Catch the IOException that is raised if the pipe is broken
// or disconnected.
catch (IOException e)
{
Console.WriteLine("[SERVER] Error: {0}", e.Message);
}
}
pipeClient.WaitForExit();
pipeClient.Close();
Console.WriteLine("[SERVER] Client quit. Server terminating.");
Console.ReadLine();
}
public static void Main()
{
Process pipeClient = new Process();
pipeClient.StartInfo.FileName = "PipeClient.exe";
using (var pipeServer = new AnonymousPipeServerStream(PipeDirection.Out,
HandleInheritability.Inheritable))
{
try
{
Console.Write("[SERVER] Setting ReadMode to \"Message\".");
pipeServer.ReadMode = PipeTransmissionMode.Message;
}
catch (NotSupportedException e)
{
Console.WriteLine("[SERVER] Exception:\n {0}", e.Message);
}
Console.WriteLine("[SERVER] Current TransmissionMode: {0}.", pipeServer.TransmissionMode);
pipeClient.StartInfo.Arguments = pipeServer.GetClientHandleAsString();
pipeClient.StartInfo.UseShellExecute = false;
pipeClient.Start();
pipeServer.DisposeLocalCopyOfClientHandle();
try
{
using (var sw = new StreamWriter(pipeServer))
{
sw.AutoFlush = true;
sw.WriteLine("SYNC"); // Send a 'sync message' and wait for client to receive it.
pipeServer.WaitForPipeDrain();
Console.Write("[SERVER] Enter text: ");
sw.WriteLine(Console.ReadLine());
}
}
catch (IOException e) // if the pipe is broken or disconnected.
{
Console.WriteLine("[SERVER] Error: {0}", e.Message);
}
}
pipeClient.WaitForExit();
pipeClient.Close();
Console.WriteLine("[SERVER] Client quit. Server terminating.");
}
public void StartServer()
{
Process pipeClient = new Process();
pipeClient.StartInfo.FileName = "C:/Users/martinH/Desktop/BuiltUnityGame/5cube2fish.exe";
using (AnonymousPipeServerStream pipeServer =
new AnonymousPipeServerStream(PipeDirection.Out,
HandleInheritability.Inheritable))
{
// Pass the client process a handle to the server.
pipeClient.StartInfo.Arguments =
pipeServer.GetClientHandleAsString();
pipeClient.StartInfo.UseShellExecute = false;
pipeClient.Start();
pipeServer.DisposeLocalCopyOfClientHandle();
try
{
// Read user input and send that to the client process.
using (StreamWriter sw = new StreamWriter(pipeServer))
{
sw.AutoFlush = false;
while (!token.IsCancellationRequested)
{
buffer_input = ringBuffer.Receive();
// This is all good here. Writes the correct value.
// Console.WriteLine(buffer_input.Item1.ToString());
tail_left_voltages.Enqueue(buffer_input.Item1);
// Console.WriteLine(tail_left_voltages.Dequeue().ToString());
tail_right_voltages.Enqueue(buffer_input.Item2);
movement_command = GenerateTailCommand();
sw.WriteLine(movement_command);
pipeServer.WaitForPipeDrain();
}
}
}
// Catch the IOException that is raised if the pipe is broken
// or disconnected.
catch (IOException e)
{
Console.WriteLine("[SERVER] Error: {0}", e.Message);
}
}
pipeClient.WaitForExit();
pipeClient.Close();
Console.WriteLine("[SERVER] Client quit. Server terminating.");
}
private async Task SendPayload(string payload)
{
await Task.Run(() =>
{
try
{
_streamWriter.WriteLine(payload);
_pipeServerStream.WaitForPipeDrain();
Log("Render data sent to the renderer.");
}
catch (Exception e)
{
Log($"Error: {e.Message}");
}
});
}
private void LaunchToaster(Message bread)
{
using (var server = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.Inheritable))
{
ProcessStartInfo psi = new ProcessStartInfo()
{
RedirectStandardInput = true,
UseShellExecute = false,
FileName = File.ReadAllText(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), @"toasterpath")),
};
psi.Arguments += $" --pipe-id={server.GetClientHandleAsString()}";
if (this.GetSettingOrDefault <bool>(GrowlerSetting.DebugLogging, false))
{
psi.Arguments += " --loglevel-debug";
}
Process p = new Process()
{
StartInfo = psi
};
p.Start();
server.DisposeLocalCopyOfClientHandle();
try
{
using (var writer = new StreamWriter(server))
{
string json = JsonConvert.SerializeObject(bread);
writer.Write(json);
writer.Flush();
}
server.WaitForPipeDrain();
}
catch (IOException ex)
{
// Growler doesn't have logging (yet?)
System.Windows.Forms.MessageBox.Show($"Pipe to Toaster broken, {ex}");
}
}
}
public static void Run()
{
using var clientProccess = new Process();
using var outPipe = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.Inheritable);
using var inPipe = new AnonymousPipeServerStream(PipeDirection.In, HandleInheritability.Inheritable);
var clientHandleOut = outPipe.GetClientHandleAsString();
var clientHandleIn = inPipe.GetClientHandleAsString();
var clientArgs = new System.Text.StringBuilder();
clientArgs.Append(clientHandleOut);
clientArgs.Append(" ");
clientArgs.Append(clientHandleIn);
clientArgs.Append(" ");
clientArgs.Append(timesToRun);
clientProccess.StartInfo.Arguments = clientArgs.ToString();
clientProccess.StartInfo.FileName = @"C:\Users\slima\source\Repos\sasha-limarev\fs\c#\AnonPipeClient\bin\Debug\netcoreapp3.0\AnonPipePong.exe";
clientProccess.Start();
outPipe.DisposeLocalCopyOfClientHandle();
inPipe.DisposeLocalCopyOfClientHandle();
using var serverReader = new StreamReader(inPipe);
using var serverWriter = new StreamWriter(outPipe)
{
AutoFlush = true
};
for (int i = 0; i < timesToRun; ++i)
{
serverWriter.WriteLine(lineToSend);
outPipe.WaitForPipeDrain();
var currLine = serverReader.ReadLine();
Console.WriteLine(currLine);
Thread.Sleep(100);
}
}
public static void ServerPInvokeChecks()
{
// calling every API related to server and client to detect any bad PInvokes
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out))
{
Task clientTask = Task.Run(() => StartClient(PipeDirection.In, server.ClientSafePipeHandle));
Assert.False(server.CanRead);
Assert.False(server.CanSeek);
Assert.False(server.CanTimeout);
Assert.True(server.CanWrite);
Assert.False(string.IsNullOrWhiteSpace(server.GetClientHandleAsString()));
Assert.False(server.IsAsync);
Assert.True(server.IsConnected);
Assert.Equal(0, server.OutBufferSize);
Assert.Equal(PipeTransmissionMode.Byte, server.ReadMode);
Assert.NotNull(server.SafePipeHandle);
Assert.Equal(PipeTransmissionMode.Byte, server.TransmissionMode);
server.Write(new byte[] { 123 }, 0, 1);
server.WriteAsync(new byte[] { 124 }, 0, 1).Wait();
server.Flush();
server.WaitForPipeDrain();
clientTask.Wait();
server.DisposeLocalCopyOfClientHandle();
}
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.In))
{
Task clientTask = Task.Run(() => StartClient(PipeDirection.Out, server.ClientSafePipeHandle));
Assert.Equal(4096, server.InBufferSize);
byte[] readData = new byte[] { 0, 1 };
Assert.Equal(1, server.Read(readData, 0, 1));
Assert.Equal(1, server.ReadAsync(readData, 1, 1).Result);
Assert.Equal(123, readData[0]);
Assert.Equal(124, readData[1]);
clientTask.Wait();
}
}
static void Main(string[] args)
{
using (AnonymousPipeServerStream pipedServer = new AnonymousPipeServerStream(PipeDirection.Out))
{
Thread child = new Thread(new ParameterizedThreadStart(childThread));
child.Start(pipedServer.GetClientHandleAsString());
using (StreamWriter sw = new StreamWriter(pipedServer))
{
var data = string.Empty;
sw.AutoFlush = true;
while (!data.Equals("quit", StringComparison.InvariantCultureIgnoreCase))
{
pipedServer.WaitForPipeDrain();
Console.WriteLine("SERVER : ");
data = Console.ReadLine();
sw.WriteLine(data);
}
}
}
}
public async Task SendAsync(Process p, string value)
{
using (AnonymousPipeServerStream pipeServer = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.Inheritable))
{
try
{
Console.WriteLine("[SERVER] Setting ReadMode to \"Message\".");
pipeServer.ReadMode = PipeTransmissionMode.Message;
}
catch (NotSupportedException e)
{
Console.WriteLine("[SERVER] Exception:\n {0}", e.Message);
}
Console.WriteLine("[SERVER] Current TransmissionMode: {0}.",
pipeServer.TransmissionMode);
Console.WriteLine(p.StartInfo.Arguments +
pipeServer.GetClientHandleAsString());
pipeServer.DisposeLocalCopyOfClientHandle();
try
{
using (StreamWriter sw = new StreamWriter(pipeServer))
{
sw.AutoFlush = true;
await sw.WriteLineAsync("SYNC");
pipeServer.WaitForPipeDrain();
await sw.WriteLineAsync(value);
}
}
catch (IOException e)
{
Console.WriteLine("[SERVER] Error: {0}", e.Message);
}
}
}
public static void ServerPInvokeChecks()
{
// calling every API related to server and client to detect any bad PInvokes
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out))
{
Task clientTask = StartClientAsync(PipeDirection.In, server.ClientSafePipeHandle);
Console.WriteLine("server.CanRead = {0}", server.CanRead);
Console.WriteLine("server.CanSeek = {0}", server.CanSeek);
Console.WriteLine("server.CanTimeout = {0}", server.CanTimeout);
Console.WriteLine("server.CanWrite = {0}", server.CanWrite);
Console.WriteLine("server.GetClientHandleAsString() = {0}", server.GetClientHandleAsString());
Console.WriteLine("server.IsAsync = {0}", server.IsAsync);
Console.WriteLine("server.IsConnected = {0}", server.IsConnected);
Console.WriteLine("server.OutBufferSize = {0}", server.OutBufferSize);
Console.WriteLine("server.ReadMode = {0}", server.ReadMode);
Console.WriteLine("server.SafePipeHandle = {0}", server.SafePipeHandle);
Console.WriteLine("server.TransmissionMode = {0}", server.TransmissionMode);
server.Write(new byte[] { 123 }, 0, 1);
server.WriteAsync(new byte[] { 124 }, 0, 1).Wait();
server.Flush();
Console.WriteLine("Waiting for Pipe Drain.");
server.WaitForPipeDrain();
clientTask.Wait();
server.DisposeLocalCopyOfClientHandle();
}
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.In))
{
Task clientTask = StartClientAsync(PipeDirection.Out, server.ClientSafePipeHandle);
Console.WriteLine("server.InBufferSize = {0}", server.InBufferSize);
byte[] readData = new byte[] { 0, 1 };
server.Read(readData, 0, 1);
server.ReadAsync(readData, 1, 1).Wait();
Assert.Equal(123, readData[0]);
Assert.Equal(124, readData[1]);
}
}
/// <summary>
/// 匿名管道服务端
/// </summary>
static void AnonymousPipeServer()
{
var pipeClient = new Process();
pipeClient.StartInfo.FileName = @"D:\CSharpCode\MyDemo\ConsoleApp2\bin\Debug\ConsoleApp2.exe";
using (var pipeServer = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.Inheritable))
{
Console.WriteLine($"[SERVER] Current TransmissionMode: {pipeServer.TransmissionMode}");
pipeClient.StartInfo.Arguments = pipeServer.GetClientHandleAsString();
pipeClient.StartInfo.UseShellExecute = false;
pipeClient.Start();
pipeServer.DisposeLocalCopyOfClientHandle();
try
{
using (var sw = new StreamWriter(pipeServer))
{
sw.AutoFlush = true;
sw.WriteLine("SYNC");
pipeServer.WaitForPipeDrain();
Console.WriteLine("[SERVER] Enter text:");
sw.WriteLine(Console.ReadLine());
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
pipeClient.WaitForExit();
pipeClient.Close();
Console.WriteLine($"[SERVER] Client quit. Server terminating.");
}
private void SetupAnonymousPipes()
{
_pipeClient.StartInfo.FileName = "Render.exe";
_pipeServerStream = new AnonymousPipeServerStream(
PipeDirection.Out,
HandleInheritability.Inheritable);
// Pass the client process a handle to the server.
_pipeClient.StartInfo.Arguments = _pipeServerStream.GetClientHandleAsString();
_pipeClient.StartInfo.UseShellExecute = false;
_pipeClient.Start();
_pipeServerStream.DisposeLocalCopyOfClientHandle();
_streamWriter = new StreamWriter(_pipeServerStream)
{
AutoFlush = true
};
_streamWriter.WriteLine("[SYNC]");
_pipeServerStream.WaitForPipeDrain();
}
void DoSend()
{
using (StreamWriter sw = new StreamWriter(_writePipeServerStream))
{
while (!_stop)
{
try
{
_autoResetEvent.Reset();
while (_messageConcurrentQueue.TryDequeue(out var msg))
{
sw.WriteLine(msg);
sw.Flush();
_writePipeServerStream.WaitForPipeDrain();
}
_autoResetEvent.WaitOne(1000);
}
catch (Exception exception)
{
Trace.TraceError("[[MSP-SERVER-W]]" + exception);
}
}
}
}
public static void ServerReadOnlyThrows()
{
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.In))
{
Assert.Throws<NotSupportedException>(() => server.Write(new byte[5], 0, 5));
Assert.Throws<NotSupportedException>(() => server.WriteByte(123));
Assert.Throws<NotSupportedException>(() => server.Flush());
Assert.Throws<NotSupportedException>(() => server.OutBufferSize);
Assert.Throws<NotSupportedException>(() => server.WaitForPipeDrain());
Assert.Throws<NotSupportedException>(() => NotReachable(server.WriteAsync(new byte[5], 0, 5)));
}
}