C#

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using EnvDTE;

namespace MyApp
{
    public static class IISDebugAttach
    {
        public static void AttachToIIS()
        {
            // Register the IOleMessageFilter to handle any threading errors.
            MessageFilter.Register();

            DTE dte = (DTE)System.Runtime.InteropServices.Marshal.GetActiveObject("VisualStudio.DTE.14.0");

            var listProcess = new List<string>();
            listProcess.Add("iisexpress");

            var processes = dte.Debugger.LocalProcesses;

            try
            {
                foreach (Process process in processes)
                {
                    foreach (var processName in listProcess)
                    {
                        if (!string.IsNullOrEmpty(process.Name))
                        {
                            string procName = process.Name;

                            if (procName.ToLower().IndexOf(processName, StringComparison.Ordinal) != -1)
                            {
                                process.Attach();
                            }
                        }
                    }
                }
            }
            catch (Exception e)
            {
                int x = 1;
            }

            // Clear thread issue filter
            MessageFilter.Revoke();
        }

        public class MessageFilter : IOleMessageFilter
        {
            //
            // Class containing the IOleMessageFilter
            // thread error-handling functions.

            // Start the filter.
            public static void Register()
            {
                IOleMessageFilter newFilter = new MessageFilter();
                IOleMessageFilter oldFilter = null;
                CoRegisterMessageFilter(newFilter, out oldFilter);
            }

            // Done with the filter, close it.
            public static void Revoke()
            {
                IOleMessageFilter oldFilter = null;
                CoRegisterMessageFilter(null, out oldFilter);
            }

            //
            // IOleMessageFilter functions.
            // Handle incoming thread requests.
            int IOleMessageFilter.HandleInComingCall(int dwCallType,
              System.IntPtr hTaskCaller, int dwTickCount, System.IntPtr
              lpInterfaceInfo)
            {
                //Return the flag SERVERCALL_ISHANDLED.
                return 0;
            }

            // Thread call was rejected, so try again.
            int IOleMessageFilter.RetryRejectedCall(System.IntPtr
              hTaskCallee, int dwTickCount, int dwRejectType)
            {
                if (dwRejectType == 2)
                // flag = SERVERCALL_RETRYLATER.
                {
                    // Retry the thread call immediately if return >=0 & 
                    // <100.
                    return 99;
                }
                // Too busy; cancel call.
                return -1;
            }

            int IOleMessageFilter.MessagePending(System.IntPtr hTaskCallee,
              int dwTickCount, int dwPendingType)
            {
                //Return the flag PENDINGMSG_WAITDEFPROCESS.
                return 2;
            }

            // Implement the IOleMessageFilter interface.
            [DllImport("Ole32.dll")]
            private static extern int
              CoRegisterMessageFilter(IOleMessageFilter newFilter, out
              IOleMessageFilter oldFilter);
        }

        [ComImport(), Guid("00000016-0000-0000-C000-000000000046"),
        InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
        interface IOleMessageFilter
        {
            [PreserveSig]
            int HandleInComingCall(
                int dwCallType,
                IntPtr hTaskCaller,
                int dwTickCount,
                IntPtr lpInterfaceInfo);

            [PreserveSig]
            int RetryRejectedCall(
                IntPtr hTaskCallee,
                int dwTickCount,
                int dwRejectType);

            [PreserveSig]
            int MessagePending(
                IntPtr hTaskCallee,
                int dwTickCount,
                int dwPendingType);
        }

    }
}

public class ResultsTest
{
public string status { get; set; }
public List data { get; set; }
}

public class ResultsTestList
{
public int option { get; set; }
}

public class ResultsTestList
{
public List<ResultsTest> ResultsItems { get; set; }
}

public class ResultsTest
{
public string status { get; set; }
public List<string> data { get; set; }
}

Quote:

a) request the full JSON API details from the third party - this should be language independant

public class ApplicationCommand
{
  public char Shortcut { get; set; } // Assuming a single key entry here rather than key combinations
  public Action Command { get; set; }
}

public class CommandMap
{
  private Dictionary<string, ApplicationCommand> applicationCommands = new Dictionary<string, ApplicationCommand>();
  public void AddCommand(string application, ApplicationCommand command)
  {
    Add(application, command);
  }
}

public class MyGameLoop
{
  private CommandMap commandMap = new CommandMap();
  public void Initialize()
  {
    commandMap.AddCommand("Load", new ApplicationCommand('L', ()=> { Debug.WriteLine("Loading"); }));
    commandMap.AddCommand("Save", new ApplicationCommand('S', ()=> { Debug.WriteLine("Saving"); }));
  }
  public void UpdateEntries()
  {
    // Read in from your store here
    ConfigurationStoreReader reader = new ConfigurationStoreReader();
    foreach (Tuple<string, char> element in reader.CommandUpdateMap)
    {
      command[element.Item1] = element.Item2;
    }
  }
  public CommandMap Mapping { get { return command; } }
}

public class Game
{
  private Dictionary<char, Action> actionToPerform = new Dictionary<char, Action>();
  public Game(CommandMap mapping)
  {
    foreach (ApplicationCommand appCommand in mapping.Mapping)
    {
      actionToPerform.Add(appCommand.Shortcut, appCommand.Command);
    }
  }

  public void HandleKeyPress(char keyPress)
  {
    if (actionToPerform.ContainsKey(keyPress))
    {
      actionToPerform[keyPress]();
    } 
  }
}

Pete O'Hanlon wrote:

I've just typed this up in the web editor here

int n;
Stack<int> s;
Stack<n.GetType()> ns; // this will not even compile!