private static void PipesReader(string pipeName)
{
try
{
using (var pipeReader = new NamedPipeServerStream(pipeName, PipeDirection.In))
{
pipeReader.WaitForConnection();
WriteLine("reader connected");
const int BUFFERSIZE = 256;
bool completed = false;
while (!completed)
{
byte[] buffer = new byte[BUFFERSIZE];
int nRead = pipeReader.Read(buffer, 0, BUFFERSIZE);
string line = Encoding.UTF8.GetString(buffer, 0, nRead);
WriteLine(line);
if (line == "bye") completed = true;
}
}
WriteLine("completed reading");
ReadLine();
}
catch (Exception ex)
{
WriteLine(ex.Message);
}
}
private static void ServerThread(object data)
{
bool running = true;
while (running)
{
NamedPipeServerStream pipeServer =
new NamedPipeServerStream("__MSDN__HELP__PIPE__", PipeDirection.In, 1);
try
{
pipeServer.WaitForConnection();
StreamString ss = new StreamString(pipeServer);
string token = ss.ReadString();
if (token == "*stop*")
running = false;
else
StringRequest(token);
}
catch(Exception)
{
}
finally
{
pipeServer.Close();
}
}
}
private static void Listen()
{
NamedPipeServerStream pipeServer =
new NamedPipeServerStream(MyPipeName,
PipeDirection.In,
1,
PipeTransmissionMode.Message,
PipeOptions.None);
StreamReader sr = new StreamReader(pipeServer);
do
{
pipeServer.WaitForConnection();
string fileName = sr.ReadLine();
Console.WriteLine(fileName);
Process proc = new Process();
proc.StartInfo.FileName = fileName;
proc.StartInfo.UseShellExecute = true;
proc.Start();
pipeServer.Disconnect();
} while (true);
}
private static async void StartGeneralServer()
{
Log.Info("Started server");
var exceptionCount = 0;
while(exceptionCount < 10)
{
try
{
using(var pipe = new NamedPipeServerStream("hdtgeneral", PipeDirection.In, 1, PipeTransmissionMode.Message))
{
Log.Info("Waiting for connecetion...");
await Task.Run(() => pipe.WaitForConnection());
using(var sr = new StreamReader(pipe))
{
var line = sr.ReadLine();
switch(line)
{
case "sync":
HearthStatsManager.SyncAsync(false, true);
break;
}
Log.Info(line);
}
}
}
catch(Exception ex)
{
Log.Error(ex);
exceptionCount++;
}
}
Log.Info("Closed server. ExceptionCount=" + exceptionCount);
}
public static void ClientSendsByteServerReceives()
{
using (NamedPipeServerStream server = new NamedPipeServerStream("foo", PipeDirection.In))
{
byte[] sent = new byte[] { 123 };
byte[] received = new byte[] { 0 };
Task t = Task.Run(() =>
{
using (NamedPipeClientStream client = new NamedPipeClientStream(".", "foo", PipeDirection.Out))
{
client.Connect();
Assert.True(client.IsConnected);
client.Write(sent, 0, 1);
}
});
server.WaitForConnection();
Assert.True(server.IsConnected);
int bytesReceived = server.Read(received, 0, 1);
Assert.Equal(1, bytesReceived);
t.Wait();
Assert.Equal(sent[0], received[0]);
}
}
public void Start()
{
try
{
ExtractUpdaterFromResource();
using (NamedPipeServerStream pipeServer = new NamedPipeServerStream("gsupdater", PipeDirection.Out))
{
ExecuteUpdater();
pipeServer.WaitForConnection();
using (StreamWriter sw = new StreamWriter(pipeServer))
{
sw.AutoFlush = true;
sw.WriteLine(_sourcePath);
sw.WriteLine(_applicationPath);
}
Environment.Exit(0);
}
}
catch (Exception e)
{
MessageBox.Show(@"Une erreur s'est produite lors du démarrage de la mise à jour de l'application"
+ Environment.NewLine
+ @"Detail du message :"
+ Environment.NewLine
+ e.Message);
}
}
private void startServer(object state)
{
try
{
var pipe = state.ToString();
using (var server = new NamedPipeServerStream(pipe, PipeDirection.Out))
{
server.WaitForConnection();
while (server.IsConnected)
{
if (_messages.Count == 0)
{
Thread.Sleep(100);
continue;
}
var bytes = _messages.Pop();
var buffer = new byte[bytes.Length + 1];
Array.Copy(bytes, buffer, bytes.Length);
buffer[buffer.Length - 1] = 0;
server.Write(buffer, 0, buffer.Length);
}
}
}
catch
{
}
}
public void Run()
{
while (true)
{
NamedPipeServerStream pipeStream = null;
try
{
pipeStream = new NamedPipeServerStream(ConnectionName, PipeDirection.InOut, -1, PipeTransmissionMode.Message);
pipeStream.WaitForConnection();
if (_stop)
return;
// Spawn a new thread for each request and continue waiting
var t = new Thread(ProcessClientThread);
t.Start(pipeStream);
}
catch (Exception)
{
if (pipeStream != null)
pipeStream.Dispose();
throw;
}
}
// ReSharper disable once FunctionNeverReturns
}
public void Run()
{
while (true)
{
var security = new PipeSecurity();
security.SetAccessRule(new PipeAccessRule("Administrators", PipeAccessRights.FullControl, AccessControlType.Allow));
using (pipeServer = new NamedPipeServerStream(
Config.PipeName,
PipeDirection.InOut,
NamedPipeServerStream.MaxAllowedServerInstances,
PipeTransmissionMode.Message,
PipeOptions.None,
Config.BufferSize, Config.BufferSize,
security,
HandleInheritability.None
))
{
try
{
Console.Write("Waiting...");
pipeServer.WaitForConnection();
Console.WriteLine("...Connected!");
if (THROTTLE_TIMER)
{
timer = new Timer
{
Interval = THROTTLE_DELAY,
};
timer.Elapsed += (sender, args) => SendMessage();
timer.Start();
while(pipeServer.IsConnected)Thread.Sleep(1);
timer.Stop();
}
else
{
while (true) SendMessage();
}
}
catch(Exception ex)
{
Console.WriteLine("Error: " + ex.Message);
}
finally
{
if (pipeServer != null)
{
Console.WriteLine("Cleaning up pipe server...");
pipeServer.Disconnect();
pipeServer.Close();
pipeServer = null;
}
}
}
}
}
public virtual async void OnAttachServer(NamedPipeServerStream server)
{
await Task.Run(() => server.WaitForConnection()); //偷懒
using (StreamReader reader = new StreamReader(server))
{
using (StreamWriter writer = new StreamWriter(server))
{
_pipes.Add(server, new KeyValuePair<StreamReader, StreamWriter>(reader, writer));
while (server.IsConnected)
{
try
{
var req = JsonConvert.DeserializeObject<NewTaskRequest>(reader.ReadLine());
TimePlan plan = new TimePlan(req.Describe, req.leftTime);
_callbackPipe.Add(plan, server);
plan.TimePlanExpired +=
(sender, args) =>
_pipes[_callbackPipe[args.CurrentPlan]].Value?.Write(
new TaskCompletePostBack(args.CurrentPlan.Description, args.CurrentPlan.EndTime));
_timePlans.AddSafe(plan);
}
catch (Exception)
{
break;
}
}
_pipes.Remove(server);
}
}
}
private void UserSignIn(string username, string password)
{
string hashed_password = sha256(password);
MessageBox.Show(hashed_password);
//send username and password to python and checks if correct
string info = username + "#" + hashed_password;
// Open the named pipe.
var server = new NamedPipeServerStream("Communicate");
server.WaitForConnection();
var br = new BinaryReader(server);
var bw = new BinaryWriter(server);
send(bw, info);
string message = recv(br);
server.Close();
server.Dispose();
//if receives true then send the user to the next gui.
if (message == "1")
{
SaveFile form = new SaveFile();
form.Show();
}
else
{
MessageBox.Show("incorrect password or username");
this.Show();
}
}
static void IPCThread()
{
string pipeName = string.Format("bizhawk-pid-{0}-IPCKeyInput", System.Diagnostics.Process.GetCurrentProcess().Id);
for (; ; )
{
using (NamedPipeServerStream pipe = new NamedPipeServerStream(pipeName, PipeDirection.In, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous, 1024, 1024))
{
try
{
pipe.WaitForConnection();
BinaryReader br = new BinaryReader(pipe);
for (; ; )
{
int e = br.ReadInt32();
bool pressed = (e & 0x80000000) != 0;
lock (PendingEventList)
PendingEventList.Add(new KeyInput.KeyEvent { Key = (Key)(e & 0x7FFFFFFF), Pressed = pressed });
}
}
catch { }
}
}
}
public void Worker()
{
while (true)
{
try
{
var serverStream = new NamedPipeServerStream("YetAnotherRelogger", PipeDirection.InOut, 100, PipeTransmissionMode.Message, PipeOptions.Asynchronous);
serverStream.WaitForConnection();
ThreadPool.QueueUserWorkItem(state =>
{
using (var pipeClientConnection = (NamedPipeServerStream)state)
{
var handleClient = new HandleClient(pipeClientConnection);
handleClient.Start();
}
}, serverStream);
}
catch (Exception ex)
{
Logger.Instance.WriteGlobal(ex.Message);
}
Thread.Sleep(Program.Sleeptime);
}
}
private void LaunchServer(string pipeName)
{
try
{
Console.WriteLine("Creating server: " + pipeName);
server = new NamedPipeServerStream(pipeName, PipeDirection.InOut, 4);
Console.WriteLine("Waiting for connection");
server.WaitForConnection();
reader = new StreamReader(server);
Task.Factory.StartNew(() =>
{
Console.WriteLine("Begin server read loop");
while (true)
{
try
{
var line = reader.ReadLine();
messages.Enqueue(line);
}
catch (Exception ex)
{
Console.WriteLine("ServerLoop exception: {0}", ex.Message);
}
}
});
}
catch (Exception ex)
{
Console.WriteLine("LaunchServer exception: {0}", ex.Message);
}
}
private void ListenForArguments(object state)
{
try
{
using (NamedPipeServerStream stream = new NamedPipeServerStream(this.identifier.ToString()))
{
using (StreamReader reader = new StreamReader(stream))
{
stream.WaitForConnection();
List<string> list = new List<string>();
while (stream.IsConnected)
{
list.Add(reader.ReadLine());
}
ThreadPool.QueueUserWorkItem(new WaitCallback(this.CallOnArgumentsReceived), list.ToArray());
}
}
}
catch (IOException)
{
}
finally
{
this.ListenForArguments(null);
}
}
/// <summary>
/// Listens for arguments on a named pipe.
/// </summary>
/// <param name="state">State object required by WaitCallback delegate.</param>
private void ListenForArguments(Object state)
{
try
{
using (NamedPipeServerStream server = new NamedPipeServerStream(identifier.ToString()))
using (StreamReader reader = new StreamReader(server))
{
server.WaitForConnection();
List<String> arguments = new List<String>();
while (server.IsConnected)
{
string line = reader.ReadLine();
if (line != null && line.Length > 0)
{
arguments.Add(line);
}
}
ThreadPool.QueueUserWorkItem(new WaitCallback(CallOnArgumentsReceived), arguments.ToArray());
}
}
catch (IOException)
{ } //Pipe was broken
finally
{
ListenForArguments(null);
}
}
public void Intercept(IInvocation invocation)
{
var pipename = Guid.NewGuid().ToString();
var procArgs = new List<string> {
Quote(invocation.TargetType.AssemblyQualifiedName),
Quote(invocation.MethodInvocationTarget.Name),
pipename,
};
procArgs.AddRange(invocation.Arguments.Select(a => Serialize(a)));
var proc = new Process {
StartInfo = {
FileName = "runner.exe",
Arguments = String.Join(" ", procArgs.ToArray()),
UseShellExecute = false,
CreateNoWindow = true,
}
};
using (var pipe = new NamedPipeServerStream(pipename, PipeDirection.In)) {
proc.Start();
pipe.WaitForConnection();
var r = bf.Deserialize(pipe);
r = r.GetType().GetProperty("Value").GetValue(r, null);
proc.WaitForExit();
if (proc.ExitCode == 0) {
invocation.ReturnValue = r;
} else {
var ex = (Exception) r;
throw new Exception("Error in external process", ex);
}
}
}
static void ConnectPythonPipe(NamedPipeServerStream server)
{
Console.WriteLine("Waiting for connection to Python...");
server.WaitForConnection();
Console.WriteLine("Connected to Python.");
}
public void Get(Stream s)
{
if (thr != null)
throw new InvalidOperationException("Can only serve one thing at a time!");
if (e != null)
throw new InvalidOperationException("Previous attempt failed!", e);
if (!s.CanWrite)
throw new ArgumentException("Stream must be readable!");
using (var evt = new ManualResetEventSlim())
{
thr = new Thread(delegate()
{
try
{
using (var srv = new NamedPipeServerStream(PipeName, PipeDirection.In))
{
evt.Set();
srv.WaitForConnection();
srv.CopyTo(s);
//srv.Flush();
}
}
catch (Exception ee)
{
e = ee;
}
});
thr.Start();
evt.Wait();
}
}
private void server()
{
System.IO.Pipes.NamedPipeServerStream pipeServer = new System.IO.Pipes.NamedPipeServerStream("testpipe", System.IO.Pipes.PipeDirection.InOut, 4);
StreamReader sr = new StreamReader(pipeServer);
StreamWriter sw = new StreamWriter(pipeServer);
do
{
try
{
pipeServer.WaitForConnection();
string test;
sw.WriteLine("Waiting");
sw.Flush();
pipeServer.WaitForPipeDrain();
test = sr.ReadLine();
Console.WriteLine(test);
}
catch (Exception ex)
{ throw ex; }
finally
{
pipeServer.WaitForPipeDrain();
if (pipeServer.IsConnected)
{
pipeServer.Disconnect();
}
}
} while (true);
}
private static void PipesReader2(string pipeName)
{
try
{
var pipeReader = new NamedPipeServerStream(pipeName, PipeDirection.In);
using (var reader = new StreamReader(pipeReader))
{
pipeReader.WaitForConnection();
WriteLine("reader connected");
bool completed = false;
while (!completed)
{
string line = reader.ReadLine();
WriteLine(line);
if (line == "bye") completed = true;
}
}
WriteLine("completed reading");
ReadLine();
}
catch (Exception ex)
{
WriteLine(ex.Message);
}
}
private static void StartServer(Type interfaceType, Type implType, string pipeName)
{
//create the server
var controller = new RpcController();
var server = new RpcServer(controller);
//register the service with the server. We must specify the interface explicitly since we did not use attributes
server.GetType()
.GetMethod("RegisterService")
.MakeGenericMethod(interfaceType)
.Invoke(server, new[] {Activator.CreateInstance(implType)});
//build the connection using named pipes
try
{
pipeServerStreamIn = CreateNamedPipe(pipeName + "ctos", PipeDirection.In);
pipeServerStreamOut = CreateNamedPipe(pipeName + "stoc", PipeDirection.Out);
streamsCreated = true;
pipeServerStreamIn.WaitForConnection();
pipeServerStreamOut.WaitForConnection();
//create and start the channel which will receive requests
var channel = new StreamRpcChannel(controller, pipeServerStreamIn, pipeServerStreamOut, useSharedMemory: true);
channel.Start();
}
catch (IOException e)
{
//swallow and exit
Console.WriteLine("Something went wrong (pipes busy?), quitting: " + e);
throw;
}
}
private static async void StartImportServer()
{
Log.Info("Started server");
var exceptionCount = 0;
while(exceptionCount < 10)
{
try
{
using(var pipe = new NamedPipeServerStream("hdtimport", PipeDirection.In, 1, PipeTransmissionMode.Message))
{
Log.Info("Waiting for connecetion...");
await Task.Run(() => pipe.WaitForConnection());
using(var sr = new StreamReader(pipe))
{
var line = sr.ReadLine();
var decks = JsonConvert.DeserializeObject<JsonDecksWrapper>(line);
decks.SaveDecks();
Log.Info(line);
}
}
}
catch(Exception ex)
{
Log.Error(ex);
exceptionCount++;
}
}
Log.Info("Closed server. ExceptionCount=" + exceptionCount);
}
private void CreatePipeServer()
{
pipeServer = new NamedPipeServerStream("www.pmuniverse.net-installer", PipeDirection.InOut, 1, (PipeTransmissionMode)0, PipeOptions.Asynchronous);
pipeServer.WaitForConnection();
//pipeServer.BeginWaitForConnection(new AsyncCallback(PipeConnected), pipeServer);
Pipes.StreamString streamString = new Pipes.StreamString(pipeServer);
while (pipeServer.IsConnected) {
string line = streamString.ReadString();
if (!string.IsNullOrEmpty(line)) {
if (line.StartsWith("[Status]")) {
installPage.UpdateStatus(line.Substring("[Status]".Length));
} else if (line.StartsWith("[Progress]")) {
installPage.UpdateProgress(line.Substring("[Progress]".Length).ToInt());
} else if (line.StartsWith("[Component]")) {
installPage.UpdateCurrentComponent(line.Substring("[Component]".Length));
} else if (line == "[Error]") {
throw new Exception(line.Substring("[Error]".Length));
} else if (line == "[InstallComplete]") {
installPage.InstallComplete();
break;
}
}
}
pipeServer.Close();
}
static public async Task WaitForConnectionAsync(this System.IO.Pipes.NamedPipeServerStream self, CancellationToken token)
{
Exception err = null;
var cts = new CancellationTokenSource();
Thread t = new Thread(delegate()
{
try
{
self.WaitForConnection();
}
catch (Exception x)
{
err = x;
cts.Cancel();
}
});
try
{
await Task.Delay(-1, cts.Token);
}
catch (Exception)
{
}
if (err != null)
{
throw new Exception(err.Message, err);
}
}
static void Main()
{
using (var pipeServer =
new NamedPipeServerStream("testpipe", PipeDirection.Out))
{
try
{
Console.WriteLine("NamedPipeServerStream object created.");
// Wait for a client to connect
Console.Write("Waiting for client connection...");
pipeServer.WaitForConnection();
Console.WriteLine("Client connected.");
// Read user input and send that to the client process.
using (StreamWriter sw = new StreamWriter(pipeServer))
{
sw.AutoFlush = true;
while (true)
{
Console.Write("Enter text: ");
sw.WriteLine(Console.ReadLine());
}
}
}
catch (IOException e)
{
Console.WriteLine("ERROR: {0}", e.Message);
}
}
}
private static void PipeServer()
{
using (NamedPipeServerStream pipeServer = new NamedPipeServerStream("BerkeleyDbWebApiSelfHost", PipeDirection.In))
pipeServer.WaitForConnection();
IntPtr stdin = GetStdHandle(StdHandle.Stdin);
CloseHandle(stdin);
}
static void Main(string[] args)
{
if (args.Length == 0)
{
port = new SerialPort("COM5", 9600);
}
else
{
port = new SerialPort(args[0], 9600);
}
var pipein = new NamedPipeServerStream("KTANEin");
var morsepipeout = new NamedPipeClientStream("KTANEMorseOut");
var pipeout = new NamedPipeClientStream("KTANEout");
pipein.WaitForConnection();
Thread.Sleep(1000);
pipeout.Connect();
morsepipeout.Connect();
Console.WriteLine("pipes open");
StreamReader reader = new StreamReader(pipeout);
StreamReader MorseReader = new StreamReader(morsepipeout);
StreamWriter writer = new StreamWriter(pipein);
writer.AutoFlush = true;
port.Open();
Thread morseThread = new Thread(new ParameterizedThreadStart(MorseHandler));
morseThread.Start(MorseReader);
while (true)
{
string hardwareInput = port.ReadLine();
Console.WriteLine("Hardware "+hardwareInput);
writer.WriteLine(hardwareInput);
string inputraw = reader.ReadLine().ToLower();
switch (inputraw)
{
case "true":
inputraw = "1";
break;
case "false":
inputraw = "0";
break;
}
byte result = Convert.ToByte(Int32.Parse(inputraw));
Console.WriteLine("Response " + result);
port.Write(new byte[]{result},0,1);
string isDetonated = reader.ReadLine().ToLower();
isDetonated = reader.ReadLine().ToLower();//what the f**k is happening
if (isDetonated.Equals("detonated:true"))
{
Console.WriteLine("Explosion");
port.Write(new byte[] { 253 }, 0, 1);
}
}
}
private void PipeThreadStart()
{
PipeSecurity pSec = new PipeSecurity();
PipeAccessRule pAccRule = new PipeAccessRule(new SecurityIdentifier(WellKnownSidType.BuiltinUsersSid, null)
, PipeAccessRights.ReadWrite | PipeAccessRights.Synchronize, System.Security.AccessControl.AccessControlType.Allow);
pSec.AddAccessRule(pAccRule);
using (_pipeServer = new NamedPipeServerStream("NKT_SQLINTERCEPT_PIPE",
PipeDirection.InOut,
NamedPipeServerStream.MaxAllowedServerInstances,
PipeTransmissionMode.Byte,
PipeOptions.None,
MAX_STRING_CCH * 2,
MAX_STRING_CCH * 2,
pSec,
HandleInheritability.Inheritable))
{
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine("(pipe thread) Waiting for connection...");
Console.ForegroundColor = ConsoleColor.Gray;
try
{
_pipeServer.WaitForConnection();
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine("(pipe thread) Client connected.");
Console.ForegroundColor = ConsoleColor.Gray;
while (true)
{
byte[] readBuf = new byte[MAX_STRING_CCH * 2];
int cbRead = _pipeServer.Read(readBuf, 0, MAX_STRING_CCH * 2);
string str = Encoding.Unicode.GetString(readBuf, 0, cbRead);
Console.WriteLine(str);
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("--------------------------------------------------------");
Console.ForegroundColor = ConsoleColor.Gray;
if (_blockQuery)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("(pipe thread) QUERY ABORTED");
Console.ForegroundColor = ConsoleColor.Gray;
}
}
}
catch (System.Exception ex)
{
Console.WriteLine("(pipethread) Pipe or data marshaling operation exception! ({0})", ex.Message);
}
}
}
private void UserSignIn(string username, string password)
{
if (username == "")
{
MessageBox.Show("Please enter username");
this.Show();
}
else if(password == "")
{
MessageBox.Show("Please enter password");
this.Show();
}
else
{
string hashed_password = sha256(password);
//send username and password to python and checks if correct
string info = "login#" + username + "#" + hashed_password;
// Open the named pipe.
var server = new NamedPipeServerStream("Communicate");
server.WaitForConnection();
var br = new BinaryReader(server);
var bw = new BinaryWriter(server);
send(bw, info);
string message_to_split = recv(br);
message_to_split = message_to_split + recv(br);
string message = message_to_split.Split('#')[0];
if (message_to_split.Split('#')[1] != "0")
{
this.my_uid = message_to_split.Split('#')[2];
this.firstname = message_to_split.Split('#')[1];
this.lastname = message_to_split.Split('#')[3];
MessageBox.Show(my_uid + firstname + lastname);
}
server.Close();
server.Dispose();
//if receives true then send the user to the next gui.
if (message == "Signed in")
{
string user_info = this.my_uid + "#" + this.firstname + "#" + this.lastname;
SaveFile form = new SaveFile(user_info);
form.Show();
}
else
{
MessageBox.Show("incorrect password or username");
this.Show();
}
}
}
public PipeJunction(string pipeName)
{
// The blocking synchronous way of using it is used here because there is a bug in mono
// the PipeOptions enum does not have the correct int values compared to ms .net version
_server = new NamedPipeServerStream(pipeName, PipeDirection.Out);
var connect = new Thread(() => _server.WaitForConnection());
_pipes.Add(connect);
_serverThread = new Thread(startServer);
connect.Start();
_serverThread.Start();
}
void PipeThread()
{
NamedPipeServerStream pipeServer = null;
try
{
pipeServer = new NamedPipeServerStream("NowPlayingtunesSongPipe", PipeDirection.InOut);
pipeServer.WaitForConnection();
//When Connected
StreamString stream = new StreamString(pipeServer);
String playerStr = stream.ReadString();
Debug.WriteLine("[foobar2000]Song changed.");
Debug.WriteLine(playerStr);
Debug.WriteLine("[foobar2000]dump end.");
String[] playerStrSplit = playerStr.Split('\n');
Core.iTunesClass song = new Core.iTunesClass();
song.AlbumArtworkEnabled = false;
song.SongTitle = playerStrSplit[0];
song.SongAlbum = playerStrSplit[1];
song.SongArtist = playerStrSplit[2];
song.SongAlbumArtist = playerStrSplit[3];
song.isFoobar = true;
try
{
song.SongTrackNumber = int.Parse(playerStrSplit[4]);
}
catch (Exception ex2)
{
}
song.SongGenre = playerStrSplit[5];
song.SongComposer = playerStrSplit[6];
pipeServer.Close();
pipeServer.Dispose();
//適当にイベント発生させる
onSongChangedEvent(song);
}
catch (Exception ex)
{
Debug.WriteLine("[foobar2000] ERROR");
Debug.WriteLine(ex.ToString());
}
finally
{
if (pipeServer != null)
{
if (pipeServer.IsConnected)
{
pipeServer.Dispose();
}
}
}
//Remake thread
StartThread();
}
