void WaitForConnectionCallBack(IAsyncResult Result)
{
try
{
// Get the pipe
NamedPipeServerStream pipeServer = (NamedPipeServerStream)(Result.AsyncState);
TempServer = pipeServer;
// End waiting for the connection
pipeServer.EndWaitForConnection(Result);
if (!RunningToken.IsCancellationRequested)
{
#region NPContract
var Receiver = SerializationContext.Default.GetSerializer <NPCallContract>();
NPCallContract ClientCall = Receiver.Unpack(pipeServer);
NPResultContract <object> ClientResult = new NPResultContract <object>();
if (ClientCall.VerifyMessage == VerifyMessage)
{
switch (ClientCall.Type)
{
case NPCalType.Get:
if (Command.ContainsKey(ClientCall.MethodCommand))
{
try
{
ClientResult.ObjectResult = (Command[ClientCall.MethodCommand])(ClientCall.Argruments);
ClientResult.Type = NPResultType.Complete;
}
catch
{
ClientResult.Type = NPResultType.InvalidOperationException;
}
}
else
{
ClientResult.Type = NPResultType.MissingCommandException;
}
break;
}
}
else
{
ClientResult.Type = NPResultType.VerifyMessageException;
}
var Sender = SerializationContext.Default.GetSerializer <NPResultContract <object> >();
Sender.Pack(pipeServer, ClientResult);
pipeServer.Dispose();
#endregion
#region CleanCode
if (pipeServer != null)
{
pipeServer.Dispose();
pipeServer = null;
}
if (Server != null)
{
Server.Dispose();
Server = null;
}
#endregion
#region Recursively wait for the connection
pipeServer = new NamedPipeServerStream(PipeName, PipeDirection.InOut, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous);
Server = pipeServer;
if (RunningToken != null && !RunningToken.IsCancellationRequested)
{
pipeServer.BeginWaitForConnection(new AsyncCallback(WaitForConnectionCallBack), Server);
}
#endregion
}
}
catch
{
//Cannot access close pipe
//Happen when stop
}
}
public o Get <o>(string Command, params object[] argruments)
{
//Check argrument
foreach (object obj in argruments)
{
Type ObjectType = obj.GetType();
bool IsHaveDataContract = Attribute.IsDefined(ObjectType, typeof(DataContractAttribute));
if (!IsHaveDataContract && !ObjectType.IsSerializable)
{
throw new ArgumentException("'" + ObjectType.Name + "' is not serializable type");
}
}
o Result = default(o);
NPResultType ResultType = NPResultType.Complete;
NamedPipeClientStream pipeClient = null;
try
{
pipeClient = new NamedPipeClientStream(ServerName.Length == 0 ? "." : ServerName, PipeName, PipeDirection.InOut, PipeOptions.Asynchronous);
pipeClient.Connect(500);
var Sender = SerializationContext.Default.GetSerializer <NPCallContract>();
NPCallContract ClientCall = new NPCallContract();
ClientCall.VerifyMessage = VerifyMessage;
ClientCall.MethodCommand = Command;
ClientCall.Type = NPCalType.Get;
ClientCall.Argruments = argruments;
Sender.Pack(pipeClient, ClientCall);
var Receiver = SerializationContext.Default.GetSerializer <NPResultContract <o> >();
NPResultContract <o> ClientResult = Receiver.Unpack(pipeClient);
switch (ClientResult.Type)
{
case NPResultType.Complete:
Result = (o)ClientResult.ObjectResult;
ResultType = NPResultType.Complete;
break;
case NPResultType.InvalidOperationException:
case NPResultType.MissingCommandException:
case NPResultType.TimeoutException:
case NPResultType.VerifyMessageException:
ResultType = ClientResult.Type;
break;
}
}
catch (TimeoutException)
{
ResultType = NPResultType.TimeoutException;
}
finally
{
pipeClient.Close();
pipeClient.Dispose();
}
if (ResultType == NPResultType.TimeoutException)
{
throw new TimeoutException("Missing '" + PipeName + "' server");
}
else if (ResultType == NPResultType.VerifyMessageException)
{
throw new UnauthorizedAccessException("Verify Message Incurrect");
}
else if (ResultType == NPResultType.MissingCommandException)
{
throw new MissingMethodException("Missing Command '" + Command + "'");
}
else if (ResultType == NPResultType.InvalidOperationException)
{
throw new InvalidOperationException("Somethings error on command '" + Command + "'");
}
return(Result);
}
