/// <summary>
/// Calls method with one parameter and result. Deserializes parameter and serialize result.
/// </summary>
/// <param name="type">Type containing method</param>
/// <param name="methodName">Name of method to call</param>
/// <param name="pipeName">Name of pipe to pass parameter and result</param>
static void InvokeFunc(Type type, string methodName, string pipeName)
{
using (var pipe = new NamedPipeClientStream(pipeName))
{
pipe.Connect();
var formatter = new BinaryFormatter();
ProcessThreadParams pars;
var lengthBytes = new byte[4];
pipe.Read(lengthBytes, 0, 4);
var length = BitConverter.ToInt32(lengthBytes, 0);
var inmemory = new MemoryStream(length);
var buf = new byte[1024];
while (length != 0)
{
var red = pipe.Read(buf, 0, buf.Length);
inmemory.Write(buf, 0, red);
length -= red;
}
inmemory.Position = 0;
try
{
AppDomain.CurrentDomain.AssemblyResolve += (sender, args) =>
{
return type.Assembly;
};
pars = (ProcessThreadParams)formatter.Deserialize(inmemory);
var method = type.GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance, null, pars.Types, null);
if (method == null) throw new InvalidOperationException("Method is not found: " + methodName);
if (pars.Pipe != null)
{
var auxPipe = new NamedPipeClientStream(pars.Pipe);
auxPipe.Connect();
for (int i = 0; i < pars.Parameters.Length; i++)
if (pars.Parameters[i] is PipeParameter) pars.Parameters[i] = auxPipe;
}
object result = method.Invoke(pars.Target, pars.Parameters);
var outmemory = new MemoryStream();
formatter.Serialize(outmemory, ProcessThreadResult.Successeded(result));
outmemory.WriteTo(pipe);
}
catch (TargetInvocationException e)
{
formatter.Serialize(pipe, ProcessThreadResult.Exception(e.InnerException));
throw e.InnerException;
}
catch (Exception e)
{
formatter.Serialize(pipe, ProcessThreadResult.Exception(e));
throw;
}
}
}
static void Main()
{
try
{
using (var pipe = new NamedPipeClientStream(".", "sharp-express", PipeDirection.InOut))
{
pipe.Connect();
var encoding = Encoding.UTF8;
var sb = new StringBuilder();
sb.Append("GET / HTTP/1.1\r\n");
sb.Append("Header1: Hi!\r\n");
sb.Append("\r\n");
var bytes = encoding.GetBytes(sb.ToString());
pipe.Write(bytes, 0, bytes.Length);
pipe.Flush();
var buf = new byte[64 * 1024];
var size = pipe.Read(buf, 0, buf.Length);
var message = encoding.GetString(buf, 0, size);
Console.WriteLine(message);
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
Console.ReadLine();
}
static void Main()
{
try {
using (var npcs = new NamedPipeClientStream("Stream Mosaic")) {
try {
npcs.Connect(500);
var url = Environment.CommandLine.Substring(Environment.CommandLine.IndexOf(' ')).Trim();
var textBytes = Encoding.UTF8.GetBytes(url);
npcs.Write(textBytes, 0, textBytes.Length);
npcs.Flush();
var responseBytes = new byte[1];
npcs.Read(responseBytes, 0, 1);
} catch (TimeoutException) {
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new MainWindow());
}
}
} catch (Exception exc) {
MessageBox.Show(exc.ToString());
}
}
public static void ServerSendsByteClientReceives()
{
using (NamedPipeServerStream server = new NamedPipeServerStream("foo", PipeDirection.Out))
{
byte[] sent = new byte[] { 123 };
byte[] received = new byte[] { 0 };
Task t = Task.Run(() =>
{
using (NamedPipeClientStream client = new NamedPipeClientStream(".", "foo", PipeDirection.In))
{
client.Connect();
Assert.True(client.IsConnected);
int bytesReceived = client.Read(received, 0, 1);
Assert.Equal(1, bytesReceived);
}
});
server.WaitForConnection();
Assert.True(server.IsConnected);
server.Write(sent, 0, 1);
t.Wait();
Assert.Equal(sent[0], received[0]);
}
}
public void Run()
{
while (true)
{
using (pipeClient = new NamedPipeClientStream(
"localhost",
Config.PipeName,
PipeDirection.InOut,
PipeOptions.None
))
{
try
{
Console.Write("Waiting for new connection...");
pipeClient.Connect(5000);
Console.WriteLine("...Connected!");
pipeClient.ReadMode = PipeTransmissionMode.Message;
}
catch (Exception ex)
{
Console.WriteLine("...timed out :(");
}
try
{
while (pipeClient.IsConnected)
{
byte[] bResponse = new byte[Config.BufferSize];
int cbResponse = bResponse.Length;
int cbRead = pipeClient.Read(bResponse, 0, cbResponse);
var message = Encoding.Unicode.GetString(bResponse).TrimEnd('\0');
Console.WriteLine(message);
}
}
catch (Exception ex)
{
Console.WriteLine("Error: " + ex.Message);
}
finally
{
Console.WriteLine("Connection lost");
if (pipeClient != null)
{
Console.WriteLine("Cleaning up pipe connection...");
pipeClient.Close();
pipeClient = null;
}
}
}
}
}
static void Main(string[] args)
{
string[] simpleNames = { "Yukari", "Maki", "Zunko", "Akane", "Aoi", "Koh" };
string[] simpleNamesA = { "yukari", "maki", "zunko", "akane", "aoi", "koh" };
//引数のチェック
if (args.Length < 2) {
string mergeName = "";
for (int i = 0; i < simpleNames.Length; i++)
{
mergeName = mergeName + simpleNames[i];
//ワード間に", "をつける
if (i < simpleNames.Length - 1)
mergeName = mergeName + ", ";
}
Console.WriteLine("引数を指定してください: VoiceroidTClient"+ mergeName +" [会話内容];[音量0.0-2.0];[話速0.5-4.0];[高さ0.5-2.0];[抑揚0.0-2.0]");
return;
}
//引数に設定されたボイスロイドの名前をチェック
string selectedSimple = null;
for (int i = 0; i < simpleNames.Length; i++) {
if (args[0].CompareTo(simpleNames[i]) == 0 || args[0].CompareTo(simpleNamesA[i]) == 0) {
selectedSimple = simpleNames[i];
}
}
if (selectedSimple == null) {
string mergeName = "";
for (int i = 0; i < simpleNames.Length; i++)
{
mergeName = mergeName + simpleNames[i];
//ワード間に", "をつける
if (i < simpleNames.Length - 1)
mergeName = mergeName + ", ";
}
Console.WriteLine("第一引数に指定されたVOICEROIDの名前が正しくありません. 使用できる名前は次のとおりです: "+ mergeName);
return;
}
//サーバーとの通信処理を開始
string message = args[1];
try {
//サーバーのセッションを取得する
using (NamedPipeClientStream client = new NamedPipeClientStream("voiceroid_talker" + selectedSimple)) {
client.Connect(1000);
//サーバにーメッセージを送信する
byte[] buffer = UnicodeEncoding.Unicode.GetBytes(message);
client.Write(buffer, 0, buffer.Length);
byte[] response = new byte[4];
client.Read(response, 0, response.Length);
client.Close();
}
} catch (Exception e) {
//サーバーに接続できない時、通信エラーが発生した場合
Console.WriteLine("VoiceroidTServerによるサーバー, [voiceroid_talker" + selectedSimple + "]が見つかりません.");
}
}
private void SendCommand(int pid, string command)
{
var clientStream = new NamedPipeClientStream(".", this.PipeNameForPid(pid), PipeDirection.InOut, PipeOptions.Asynchronous);
clientStream.Connect(500);
clientStream.ReadMode = PipeTransmissionMode.Message;
var commandBytes = Encoding.ASCII.GetBytes(command);
byte[] buffer = new byte[256];
var responseBuilder = new StringBuilder();
clientStream.Write(commandBytes, 0, commandBytes.Length);
int read = clientStream.Read(buffer, 0, buffer.Length);
responseBuilder.Append(Encoding.ASCII.GetString(buffer, 0, read));
while (!clientStream.IsMessageComplete)
{
read = clientStream.Read(buffer, 0, buffer.Length);
responseBuilder.Append(Encoding.ASCII.GetString(buffer, 0, read));
}
this.ProcessResponse(responseBuilder.ToString());
}
private static byte[] ReadCommandFromEnviroGen(NamedPipeClientStream pipe)
{
//We read into this buffer because this will block until we get a byte,
//which is what we want in this case.
var commandRead = new byte[1];
pipe.Read(commandRead, 0, 1);
Console.WriteLine($"Raw command read: {commandRead[0]}");
var commandLength = ServerCommands.CommandLengths[commandRead[0]];
var input = new byte[1 + commandLength];
input[0] = commandRead[0];
if (commandLength > 0)
{
//TODO: handle improper number of bytes sent, currently this just blocks if the amount is too low
//Read all the command args into the input array
pipe.Read(input, 1, commandLength);
}
return input;
}
private void Form1_Load(object sender, EventArgs e)
{
_spyMgr.LoadCustomDll(_process, @"..\..\..\Plugin\bin\Plugins\CRegistryPlugin.dll", false, false);
pipe = new NamedPipeClientStream(".", "HyperPipe32", PipeDirection.InOut);
pipe.Connect();
byte[] data = new byte[4];
pipe.Read(data, 0, 4);
Int32 address = BitConverter.ToInt32(data, 0);
NktHook hook = _spyMgr.CreateHookForAddress((IntPtr)address, "D3D9.DLL!CreateDevice", (int)(eNktHookFlags.flgRestrictAutoHookToSameExecutable | eNktHookFlags.flgOnlyPostCall | eNktHookFlags.flgDontCheckAddress));
hook.AddCustomHandler(@"..\..\..\Plugin\bin\Plugins\CRegistryPlugin.dll", 0, "");
hook.Attach(_process, true);
hook.Hook(true);
_spyMgr.ResumeProcess(_process, continueevent);
}
private static void ChunkRequestSpeedTest(object data)
{
//initialize world
SendCommandToEnviroGen(new byte[] { 1, 10, 10});
var getChunkCommand = new byte[] { 4, 0, 0 };
m_Watch.Start();
for (var i = 0; i < 1000; i++)
{
var pipe = new NamedPipeClientStream(".", m_OutputPipeName, PipeDirection.InOut);
pipe.Connect();
pipe.Write(getChunkCommand, 0, getChunkCommand.Length);
var input = new byte[32768 + 1];
pipe.Read(input, 0, input.Length);
}
m_Watch.Stop();
Console.WriteLine($"EnviroGen took {m_Watch.ElapsedMilliseconds}ms to serve 1000 chunks.");
Console.WriteLine($"Average Time: {m_Watch.ElapsedMilliseconds / 1000f}ms");
m_Watch.Reset();
Console.ReadLine();
}
private D3Header SendD3Cmd()
{
Thread.Sleep(10); // damit CPU nicht ausgelastet wird. so CPU is not busy.
lock (this)
{
object bufferOBJ = (object)this.D3Mail;
if (this.D3Process != null)
{
byte[] ByteStruct = new byte[Marshal.SizeOf(this.D3Mail)];
IntPtr ptr = Marshal.AllocHGlobal(Marshal.SizeOf(this.D3Mail));
Marshal.StructureToPtr(this.D3Mail, ptr, true);
Marshal.Copy(ptr, ByteStruct, 0, Marshal.SizeOf(this.D3Mail));
Marshal.FreeHGlobal(ptr);
NamedPipeClientStream pipeClient;
pipeClient = new NamedPipeClientStream(".", "D3_" + this.D3Process.Id, PipeDirection.InOut);
try
{
pipeClient.Connect(200);
if (pipeClient.IsConnected)
{
pipeClient.Write(ByteStruct, 0, Marshal.SizeOf(this.D3Mail));
pipeClient.Read(ByteStruct, 0, Marshal.SizeOf(this.D3Mail));
}
IntPtr i = Marshal.AllocHGlobal(Marshal.SizeOf(bufferOBJ));
Marshal.Copy(ByteStruct, 0, i, Marshal.SizeOf(bufferOBJ));
bufferOBJ = Marshal.PtrToStructure(i, bufferOBJ.GetType());
Marshal.FreeHGlobal(i);
}
catch (Exception e) { _logger.Log("[IPlugin] D3 Command Exception." + e); }
finally
{
pipeClient.Close();
}
}
return this.D3Mail = (D3Header)bufferOBJ;
}
}
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 D3Header SendD3Cmd(D3Header SendBuffer)
{
Thread.Sleep(5); // damit CPU nicht ausgelastet wird.
lock (this)
{
object bufferOBJ = (object)SendBuffer;
byte[] ByteStruct = new byte[Marshal.SizeOf(SendBuffer)];
IntPtr ptr = Marshal.AllocHGlobal(Marshal.SizeOf(SendBuffer));
Marshal.StructureToPtr(SendBuffer, ptr, true);
Marshal.Copy(ptr, ByteStruct, 0, Marshal.SizeOf(SendBuffer));
Marshal.FreeHGlobal(ptr);
NamedPipeClientStream pipeClient;
SendBuffer.returnValue1.i = -1;
SendBuffer.returnValue2.i = -1;
SendBuffer.returnValue1.f = -1;
SendBuffer.returnValue2.f = -1;
try
{
pipeClient = new NamedPipeClientStream(".", "D3_" + this.D3Process.Id, PipeDirection.InOut);
pipeClient.Connect(1000);
if (pipeClient.IsConnected)
{
pipeClient.Write(ByteStruct, 0, Marshal.SizeOf(SendBuffer));
pipeClient.Read(ByteStruct, 0, Marshal.SizeOf(SendBuffer));
}
IntPtr i = Marshal.AllocHGlobal(Marshal.SizeOf(bufferOBJ));
Marshal.Copy(ByteStruct, 0, i, Marshal.SizeOf(bufferOBJ));
bufferOBJ = Marshal.PtrToStructure(i, bufferOBJ.GetType());
Marshal.FreeHGlobal(i);
pipeClient.Close();
}
catch { }
return (D3Header)bufferOBJ;
}
}
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();
}
}
}
private static void DrainPipe(NamedPipeClientStream pipeStream)
{
if (pipeStream == null || !pipeStream.IsConnected || !HasData(pipeStream))
return;
byte[] buffer = new byte[0x8000];
do
{
if (pipeStream.Read(buffer, 0, buffer.Length) <= 0)
break;
}
while (HasData(pipeStream));
}
/// <summary>
/// Copies the named pipe stream to the specified stream.
/// </summary>
/// <param name="pipeName">Pipe name.</param>
/// <param name="target">Destination stream.</param>
public static void CopyNamedPipeStream(this string pipeName, Stream target)
{
using (NamedPipeClientStream clientPipe = new NamedPipeClientStream(pipeName))
{
clientPipe.Connect();
int bytes, copiedBytes = 0;
var buffer = new byte[1024];
while ((bytes = clientPipe.Read(buffer, 0, buffer.Length)) > 0)
{
target.Write(buffer, 0, bytes);
copiedBytes += bytes;
/*if (onProgress != null)
{
bool shouldCancel = onProgress((float)copiedBytes / clientPipe.Length);
if (shouldCancel)
break;
}*/
}
target.Flush();
}
}
const int BUFFER_SIZE = 1024; // 1 KB
#endregion Fields
#region Methods
static void BCLSystemIOPipeClient()
{
/////////////////////////////////////////////////////////////////////
// Try to open a named pipe.
//
// Prepare the pipe name
String strServerName = ".";
String strPipeName = "HelloWorld";
NamedPipeClientStream pipeClient = null;
try
{
pipeClient = new NamedPipeClientStream(
strServerName, // The server name
strPipeName, // The unique pipe name
PipeDirection.InOut, // The pipe is bi-directional
PipeOptions.None, // No additional parameters
//The server process cannot obtain identification information about
//the client, and it cannot impersonate the client.
TokenImpersonationLevel.Anonymous);
pipeClient.Connect(60000); // set TimeOut for connection
pipeClient.ReadMode = PipeTransmissionMode.Message;
Console.WriteLine(@"The named pipe, \\{0}\{1}, is connected.",
strServerName, strPipeName);
/////////////////////////////////////////////////////////////////
// Send a message to the pipe server and receive its response.
//
// A byte buffer of BUFFER_SIZE bytes. The buffer should be big
// enough for ONE request to the client
string strMessage;
byte[] bRequest; // Client -> Server
int cbRequestBytes;
byte[] bReply = new byte[BUFFER_SIZE]; // Server -> Client
int cbBytesRead, cbReplyBytes;
// Send one message to the pipe.
// '\0' is appended in the end because the client may be a native
// C++ program.
strMessage = "Default request from client\0";
bRequest = Encoding.Unicode.GetBytes(strMessage);
cbRequestBytes = bRequest.Length;
if (pipeClient.CanWrite)
{
pipeClient.Write(bRequest, 0, cbRequestBytes);
}
pipeClient.Flush();
Console.WriteLine("Sends {0} bytes; Message: \"{1}\"",
cbRequestBytes, strMessage.TrimEnd('\0'));
// Receive one message from the pipe.
cbReplyBytes = BUFFER_SIZE;
do
{
if (pipeClient.CanRead)
{
cbBytesRead = pipeClient.Read(bReply, 0, cbReplyBytes);
// Unicode-encode the byte array and trim all the '\0' chars
// at the end.
strMessage = Encoding.Unicode.GetString(bReply).TrimEnd('\0');
Console.WriteLine("Receives {0} bytes; Message: \"{1}\"",
cbBytesRead, strMessage);
}
}
while (!pipeClient.IsMessageComplete);
}
catch (TimeoutException ex)
{
Console.WriteLine("Unable to open named pipe {0}\\{1}",
strServerName, strPipeName);
Console.WriteLine(ex.Message);
}
catch (Exception ex)
{
Console.WriteLine("The client throws the error: {0}", ex.Message);
}
finally
{
/////////////////////////////////////////////////////////////////
// Close the pipe.
//
if (pipeClient != null)
pipeClient.Close();
}
}
/// <summary>
/// Use the types in the System.IO.Pipes namespace to connect to the
/// named pipe. This solution is recommended when you program against
/// .NET Framework 3.5 or any newer releases of .NET Framework.
/// </summary>
public static void Run()
{
NamedPipeClientStream pipeClient = null;
try
{
// Try to open the named pipe identified by the pipe name.
pipeClient = new NamedPipeClientStream(
Program.ServerName, // The server name
Program.PipeName, // The unique pipe name
PipeDirection.InOut, // The pipe is duplex
PipeOptions.None // No additional parameters
);
pipeClient.Connect(5000);
Console.WriteLine("The named pipe ({0}) is connected.",
Program.FullPipeName);
// Set the read mode and the blocking mode of the named pipe. In
// this sample, we set data to be read from the pipe as a stream
// of messages. This allows a reading process to read varying-
// length messages precisely as sent by the writing process. In
// this mode, you should not use StreamWriter to write the pipe,
// or use StreamReader to read the pipe. You can read more about
// the difference from http://go.microsoft.com/?linkid=9721786.
pipeClient.ReadMode = PipeTransmissionMode.Message;
//
// Send a request from client to server
//
string message = Program.RequestMessage;
byte[] bRequest = Encoding.Unicode.GetBytes(message);
int cbRequest = bRequest.Length;
pipeClient.Write(bRequest, 0, cbRequest);
Console.WriteLine("Send {0} bytes to server: \"{1}\"",
cbRequest, message.TrimEnd('\0'));
//
// Receive a response from server.
//
do
{
byte[] bResponse = new byte[Program.BufferSize];
int cbResponse = bResponse.Length, cbRead;
cbRead = pipeClient.Read(bResponse, 0, cbResponse);
// Unicode-encode the received byte array and trim all the
// '\0' characters at the end.
message = Encoding.Unicode.GetString(bResponse).TrimEnd('\0');
Console.WriteLine("Receive {0} bytes from server: \"{1}\"",
cbRead, message);
}
while (!pipeClient.IsMessageComplete);
}
catch (Exception ex)
{
Console.WriteLine("The client throws the error: {0}", ex.Message);
}
finally
{
// Close the pipe.
if (pipeClient != null)
{
pipeClient.Close();
pipeClient = null;
}
}
}
/// <summary>クライアント生成 - Socketスレッド関数</summary>
private void ClientNamedPipe()
{
// 通信シーケンスは自分で設計する
// （本サンプルはリクエスト・レスポンス型の通信シーケンス）。
// 名前付きパイプ（クライアント）
// 双方向のメッセージ ストリーム
NamedPipeClientStream s = null;
MemoryStream ms = null;
byte[] buff = new byte[256];
byte[] byt = null;
int bytSize = 0;
string str = "";
int frequency = this.Frequency[Thread.CurrentThread.ManagedThreadId];
string message = this.Message[Thread.CurrentThread.ManagedThreadId];
// スレッドID
int managedThreadId = Thread.CurrentThread.ManagedThreadId;
try
{
// 名前付きパイプ（クライアント）を生成
s = new NamedPipeClientStream(
".", "mypipe", PipeDirection.InOut);
s.Connect(3 * 1000);
//s.ReadTimeout = 3 * 1000;
//s.WriteTimeout = 3 * 1000;
// 接続を表示
this.SetResult_Client(
string.Format("接続 - ThreadId:{0}" , managedThreadId));
// メッセージをｎ回送信
for (int i = 1; i <= frequency; i++)
{
// メッセージを送信
str = i.ToString() + "-" + message + "<end-send>";
byt = Encoding.UTF8.GetBytes(str);
s.Write(byt, 0, byt.Length);
// 送信メッセージを表示
this.SetResult_Client(
string.Format("({0})送信:{1}", managedThreadId, str));
// 受信処理
ms = new MemoryStream();
while (true)
{
// メッセージ（の一部）を受信
bytSize = s.Read(buff, 0, buff.Length); //（待機）
// 受信したメッセージを蓄積
ms.Write(buff, 0, bytSize);
// 受信したメッセージを文字列に変換
str = Encoding.UTF8.GetString(ms.ToArray());
// ここでは、<end-send>と送られるまで受信を続行する。
if (str.IndexOf("<end-send>") != -1)
{
// シーケンス制御文字を消去
str = str.Replace("<end-send>", "");
break;
}
}
// 受信メッセージを表示
this.SetResult_Client(
string.Format("({0})受信:{1}", managedThreadId, str));
}
// 全送信の終了
str = "終わり<end-connect>";
byt = Encoding.UTF8.GetBytes(str);
s.Write(byt, 0, byt.Length);
// 送信メッセージを表示
this.SetResult_Client(
string.Format("({0})送信:{1}", managedThreadId, str));
}
catch (Exception ex)
{
// エラーを表示
this.SetResult_Client(
string.Format("({0})エラー：{1}", managedThreadId, ex.ToString()));
}
finally
{
if (s != null)
{
// TCPストリーム ソケットをクローズ
s.Close();
}
// 切断を表示
this.SetResult_Client(
string.Format(
"切断 - ThreadId:{0}" , managedThreadId));
}
}