API Code PackとVisual Studio 2008でWindows 7のジャンプリストを作成する

using Microsoft.WindowsAPICodePack.Shell;
using Microsoft.WindowsAPICodePack.Taskbar;

JumpList list = JumpList.CreateJumpList();

string systemFolder = Environment.GetFolderPath(
    Environment.SpecialFolder.System);

string notepadPath = System.IO.Path.Combine(
    systemFolder, "notepad.exe");
JumpListLink notepadTask = new JumpListLink(
    notepadPath, "Open Notepad");
notepadTask.IconReference = new IconReference(
    notepadPath, 0);

string calculatorPath = System.IO.Path.Combine(
    systemFolder, "calc.exe");
JumpListLink calculatorTask = new JumpListLink(
    calculatorPath, "Open Calculator");
calculatorTask.IconReference = new IconReference(
    calculatorPath, 0);

list.AddUserTasks(notepadTask, calculatorTask);
list.Refresh();
MessageBox.Show("Custom tasks have been added!");

JumpList list = JumpList.CreateJumpList();
...
string selfPath = System.Environment.CommandLine;
// the value comes with quotation marks, strip them out
selfPath = selfPath.Substring(1, selfPath.Length - 3);

JumpListLink selfCommandATask = new JumpListLink(
      selfPath, "Command A");
selfCommandATask.Arguments = "Command-A";
selfCommandATask.IconReference = new IconReference(
      selfPath, 0);

JumpListLink selfCommandBTask = new JumpListLink(
      selfPath, "Command B");
selfCommandBTask.Arguments = "Command-B";
selfCommandBTask.IconReference = new IconReference(
      selfPath, 0);

JumpListSeparator separator = new JumpListSeparator();
list.AddUserTasks(notepadTask, calculatorTask,
      separator, selfCommandATask, selfCommandBTask);

C:\MyApps\Win7JumpListDemo.exe Command-A

static void Main(string[] args)
{
  if (CommandLineParameters.ParametersGiven(args))
  {
      CommandLineParameters.ProcessCommandLine(args);
  }
  else
  {
    Application.EnableVisualStyles();
    Application.SetCompatibleTextRenderingDefault(false);
    Application.ApplicationExit +=
      (obj, evt) =>
      {
          PipeCommunications.SignalCloseEvent();
      };
    Application.Run(new MainForm());
  }
}

PipeCommunications pipes = new PipeCommunications(
  (cmd) =>
  {
     communicationLogTextBox.Invoke(
     new LogMessageToTextBoxDelegate(
        LogMessageToTextBox),cmd);
   });
pipes.CreateListenPipeThread();

public delegate void LogMessageToTextBoxDelegate(string cmd);
...
private void LogMessageToTextBox(string cmd)
{
 communicationLogTextBox.Text =
  DateTime.Now.ToLongTimeString() +
  ": Got command: " + cmd + "\r\n" +
  communicationLogTextBox.Text;
}

using System.IO.Pipes;
using System.Threading;
...
Action<string> processCommandAction;
private static AutoResetEvent closeApplicationEvent;
...
internal Thread CreateListenPipeThread()
{
    closeApplicationEvent = new AutoResetEvent(false);
    Thread serverThread = new Thread(
        new ParameterizedThreadStart(
            PipeHandlerServerThread));
    serverThread.Start(serverThread);
    return serverThread;
}

private const string PipeName = "win7-jumplist-demopipe";
...
internal void PipeHandlerServerThread(object threadObj)
{
  Thread currentThread = (Thread)threadObj;
  NamedPipeServerStream pipeServer = null;
  try
  {
    while (true)
    {
      pipeServer = new NamedPipeServerStream(
        PipeName, PipeDirection.InOut, 1,
        PipeTransmissionMode.Byte,
        PipeOptions.Asynchronous);
      try
      {
        IAsyncResult async =
          pipeServer.BeginWaitForConnection(
          null, null);
        int index = WaitHandle.WaitAny(
          new WaitHandle[]
          {
            async.AsyncWaitHandle,
            closeApplicationEvent
          });
        switch (index)
        {
          case 0:
            pipeServer.EndWaitForConnection(async);
            ProcessPipeCommand(pipeServer);
            break;
          case 1:
            // exit this thread
            return;
          default:
            pipeServer.Close();
            break;
        }
      }
      catch (Exception ex)
      {
        processCommandAction("Exception: " +
          ex.Message);
      }
    }
  }
  finally
  {
    pipeServer.Close();
  }
}

private void ProcessPipeCommand(
  NamedPipeServerStream pipeServer)
{
  string command;
  using (StreamReader reader =
    new StreamReader(pipeServer))
  using (StreamWriter writer =
    new StreamWriter(pipeServer))
  {
    command = reader.ReadLine();
    processCommandAction(command);
    writer.WriteLine("OK");
  }
  if (pipeServer.IsConnected)
  {
    pipeServer.Disconnect();
  }
}

internal static void ProcessCommandLine(string[] args)
{
    string command = args[0];
    PipeCommunications pipes = new PipeCommunications();
    string result = pipes.SendCommandToServer(command);
}

internal string SendCommandToServer(string command)
{
  try
  {
    NamedPipeClientStream pipeClient =
      new NamedPipeClientStream(
        "localhost", PipeName, PipeDirection.InOut);
    try
    {
      using (StreamReader reader =
        new StreamReader(pipeClient))
      using (StreamWriter writer =
        new StreamWriter(pipeClient))
      {
        pipeClient.Connect();
        writer.WriteLine(command);
        writer.Flush();
        string response = reader.ReadLine();
        return response;
      }
    }
    finally
    {
      pipeClient.Close();
    }
  }
  catch (Exception ex)
  {
    System.Windows.Forms.MessageBox.Show(
      "Windows 7 Task Bar Demo: Pipe " +
      "communication failure: " + ex.Message);
    return null;
  }
}