Роман

Любой язык на это способен :-)

В C# работа с процессами может быть примерно такой:

// запускаем процесс
var process = System.Diagnostics.Process.Start(@"C:\windows\system32\calc.exe");
// убиваем процесс
process.Kill();
// или отправляем команду на закрытие главного окна
// process.CloseMainWindow();

// запуск можно выполнить через ProcessStartInfo,
// это может быть более удобней и больше возможностей
var processStartInfo = new System.Diagnostics.ProcessStartInfo();
// путь к файлу программы
processStartInfo.FileName = @"C:\windows\system32\notepad.exe";
// передаем аргументы (в данном случае путь файла для открытия)
processStartInfo.Arguments = @"C:\Windows\System32\drivers\etc\hosts";

// запускаем процесс
var process2 = System.Diagnostics.Process.Start(processStartInfo);

// если необходимо, можем получить список всех процессов
var processes = System.Diagnostics.Process.GetProcesses();

// для примера, выводим в консоль
foreach(var p in processes)
{
  Console.WriteLine("PID#{0}, {1}", p.Id, p.ProcessName);
  // можем поубивать все блокноты
  // if (p.ProcessName == "notepad")
  // {
  //   p.Kill();
  // }
}

При запуске процессов, вы можете просто запомнить их идентификаторы (например в коллекцию, типа List<int> или же использовать свой тип, и/или запоминать экземпляры Process) и в последующем завершить работу этих процессов.

Информацию о запущенных процессах можно получать с помощью методов: System.Diagnostics.Process.GetProcessById() - по идентификатору процесса, System.Diagnostics.Process.GetProcessByName() - по имени процесса.

Если необходимо, к каждому создаваемому процессу можно подключить обработчик завершения работы процесса:

// создаем параметры запуска процесса
var processStartInfo = new System.Diagnostics.ProcessStartInfo();
processStartInfo.FileName = @"C:\windows\system32\notepad.exe";
processStartInfo.Arguments = @"C:\Windows\System32\drivers\etc\hosts";
      
// создаем экземпляр процесса
var process = new System.Diagnostics.Process();
// передаем параметры
process.StartInfo = processStartInfo;
// разрешаем использование обработчиков событий
process.EnableRaisingEvents = true; // <-- требуется для работы обработчика завершения процесса

// цепляем обработчик завершения работы процесса 
// (лучше сделать нормальную функцию, а не анонимную, как показано в примере)
process.Exited += (object sender, EventArgs e) =>
{
  // этот блок будет выполнен, когда работа процесса будет завершена
  // экземпляр процесса можно найти в sender: строгий тип - ((System.Diagnostics.Process)sender)
  // (хотя в данном примере без проблем можно использовать process, это будет даже удобней)

  // для примера, выводим в консоль идентификатор завершенного процесса
  Console.WriteLine("PID#{0} завершил работу", ((System.Diagnostics.Process)sender).Id);
};

// запускаем процесс
process.Start();

https://msdn.microsoft.com/ru-ru/library/hb7xxkfx(...

В с# есть рефлексия которая поможет достать эту инфу.
Вот пример как раз об этом
https://msdn.microsoft.com/en-us/library/4d848zkb(...

a в чем собственно проблема?
они никак друг с другом не взаимодействуют и не мешают один другому (кроме потребления ресурсов).

Path.GetFullPath(Directory.GetCurrentDirectory() + "\\..\\..\\");

там идет рекурсия.
public static void Draw(int len, int n) {
...
Draw(len / 3, n - 1);
...

Вот тут Draw означает, что вызовется еще раз функция Draw, но с "n-1"
Если n будет равно 0, а это произойдет на третьем вложенном вызове Draw, то вызовется команда с move.

Да, это хорошая статья. Так оно обычно и делается - bearer token и атрибуты Authorize.

Кроме обычных токенов есть еще дополнительный тип - refresh token. Они используются в том случае, если срок жизни первого токена истекает и нужно его обновить. Использовать их необязательно - зависит от кейса. Но на всякий почитайте:

https://leastprivilege.com/2013/11/15/adding-refre...

Про интерфейсы IEnumerable и IQueryable почитай мой ответ тут.

Интерфейс ICollection наследуется от IEnumerable и подразумевает, что реализующие его классы умеют эффективно вставлять и удалять элементы.

Интерфейс IList наследуется от ICollection и подразумевает, что реализующие его классы умеют предоставлять доступ к элементу по индексу.

List это конкретный класс, который реализует интерфейсы IList, ICollection т.е. подразумевается, что он умеет эффективно вставлять/удалять и давать доступ по индексу.

Попробую на пальцах когда и что использовать...
Функция получает:
IEnumerable - подразумевается, что ты только перебираешь элементы.

IQueryable - клиентам придется попотеть что бы ты мог дополнить дерево выражений, что бы обеспечить более точный запрос.

ICollection - ты уверен, что хочешь что то добавить или удалить в коллекции в этой функции ? Один из звоночков, что с архитектурой могут быть проблемы.

IList - а ты уверен что тебе очень критично иметь доступ по индексу в этой функции ? Второй звоночек про архитектуру.

List - работаю только со списками и не пытайтесь дать мне другой контейнер.

Функция возвращает:
IEnumerable - никаких обещаний, пусть клиенты рассчитывают только на перебор.

IQueryable в функции запрос (например к дб) фактически не выполняется и клиенты могут попытаться его дополнить условиями, что бы с базы шло меньше данных.

ICollection - ты возвращаешь коллекцию путь кто хочет тот и добавляет и удаляет в ней элементы.

IList - ты уже создал в функции соответствующую коллекцию, возможно кому то понадобится доступ по индексу.

List - да мне наc..ть на интерфейсы создал список - отдал список и я всегда буду создавать список, даже если мне потребуется создать последовательность из 100500 миллионов элементов.

2.0-3.5
4.0-4.6
это 2 различные ветки. Так что придется ставить