Отслеживание запуска процессов в реальном времени

class Program
    {
 
        private class Dialogs
        {
            private string dialog;
 
            public string Dialog
            {
                get { return dialog; }
                set { dialog = value; }
            }
 
            public List<string> Phrases { get; private set; }
 
            //Конструктор
            public Dialogs()
            {
                //Инициализируем List
                Phrases = new List<string>();
            }
        }
 
 
        
        static void Main( string[] args )
        {
            string sPath = "phrases.txt";
 
            //Список объектов класса Dialogs
            //Сюда будут залетать все диалоги со своими фразами для конкретного процесса
            List<Dialogs> lst = new List<Dialogs>();
 
 
            while ( true )
            {
                Console.Write( "Proccess name: " );
 
                //Ввод имени интересующего процесса
                string proc = Console.ReadLine();
 
 
                using ( StreamReader sr = new StreamReader( sPath ) )
                {
                    string line;
 
                    //Начинаем читать файл...
                    while ( ( line = sr.ReadLine() ) != null )
                    {
 
                        //Если начало строки начинается с '[', значит это имя процесса
                        if ( line.StartsWith( "[" ) )
                        {
                            //Читаем имя процесса из файла
                            //Если имя процесса из файла совпало с текущим процессом...
                            if ( line.Trim( new char[] { '[', ']' } ) == proc )
                            {
                                //Читаем следующую строку
                                line = sr.ReadLine();
 
                                do 
                                {
                                    //Если это диалог (а мы ожидаем именно его:)
                                    if ( line.StartsWith( "<" ) )
                                    {
                                        //Создаем новый экземпляр класса Dialogs
                                        Dialogs dl = new Dialogs
                                        {
                                            //Извлекаем диалог - обрезаем символы <> и вставляем в поле Dialog
                                            Dialog = line.Trim( new char[] { '<', '>' } )
                                        };
 
                                        do
                                        {
                                            //Считываем следующую строку (фразы диалога)
                                            line = sr.ReadLine();
 
                                            //Если конец файла, начало нового диалога или другой процесс - выходим
                                            if ( 
                                                
                                                line == null 
                                                || line.StartsWith( "<" )
                                                || line.StartsWith( "[" ) 
                                                
                                                ) { break; }
 
                                            //Добавляем фразы с список фраз текущего экземпляра класса
                                            dl.Phrases.Add( line );
 
                                        }
                                        //Читаем до посинения
                                        while ( true );
 
                                        //Добавляем класс в список классов Dialogs
                                        lst.Add( dl );
                                    }
 
                                    //Если конец файла - выходим
                                    if ( line == null ) { break; }
                                }
 
                                //Читаем пока не закончатся диалоги текущего процесса
                                while ( !line.StartsWith( "[" ) );
                            }
                        }  
                    }
                }
 
 
                //Вывод всех диалогов текущего процесса с фразами
                //Для отладки... (удалить)
                for ( int i = 0; i < lst.Count; i++ )
                {
                    Console.WriteLine( "[{0}]", lst[ i ].Dialog );
 
                    for ( int j = 0; j < lst[ i ].Phrases.Count; j++ )
                    {
                        Console.WriteLine( "--> {0}", lst[ i ].Phrases[ j ] );
                    }
                }
 
 
                Console.WriteLine( "\n------Выборка случайного диалога------\n" );
 
                Random rnd = new Random();
                int n = rnd.Next( 0, lst.Count );
 
                //Выводим диалог
                Console.WriteLine( "[{0}]", lst[ n ].Dialog );
 
                //Выводим список фраз к нему
                for ( int i = 0; i < lst[ n ].Phrases.Count; i++ )
                {
                    Console.WriteLine( "--> {0}", lst[ n ].Phrases[ i ] );
                }
 
                Console.WriteLine( "\n" );
 
 
                //Чистим список классов Dialogs
                lst.Clear();
            }
        }
    }

            string sPath = "phrases.txt";
            string[] lines;
            List<string> list = new List<string>();
            Random rnd = new Random();
 
            using ( StreamReader sr = new StreamReader( sPath ) )
            {
                lines = sr.ReadToEnd().Split( '\n' );
            }
 
            //Вечный цикл...
            while ( true )
            {
                Console.Write( "Введите имя процесса: " );
                string proc = Console.ReadLine();
 
                //Смотрим все процессы в файле и сравниваем с нашим
                //Если такой процесс нашелся, то выбираем все его диалоги и фразы в List<>
                var proccesses = lines.Select( ( v, i ) => new { i, v } ).Where( t => t.v.StartsWith( "[" ) );
                foreach ( var s in proccesses )
                {
                    if ( s.v.Trim( new char[] { '[', ']', '\r' } ) == proc )
                    {
                        var dialogs = lines.Skip( s.i + 1 ).TakeWhile( x => !x.StartsWith( "[" ) );
 
                        foreach ( var v in dialogs )
                        {
                            if ( v == "\r" ) continue; //Здесь избавляемся от той проблемы с пустой строкой, в посте выше.
                            list.Add( v );
                        }
                        break;
                    }
                }
 
 
                //Ищем индексы вхождений строк диалогов (начинаются с "<")
                var dialIdx = list.Select( ( v, i ) => new { i, v } ).Where( t => t.v.StartsWith( "<" ) );
                List<int> idx = new List<int>();
 
                //Добавляем эти индексы в список, из которого будем брать случайный элемент (диалог)
                foreach ( var s in dialIdx )
                    idx.Add( s.i );
 
                //ГПСЧ
                int rx = rnd.Next(0, idx.Count );
 
                //Если список пуст -> уходим на второй круг... (т.е. такого процесса нет)
                if ( list.Count == 0 ) continue;
 
 
                Console.WriteLine( "\n<----------Вывод случайного диалога---------->\n" );
 
                //Печатаем диалог
                var Dialog = list.Skip( idx[ rx ] ).Take(1).Select( s => s ).ToArray();
                Console.WriteLine( Dialog[ 0 ] );
 
                //Печатаем фразы к нему
                var Phrases = list.Skip( idx[ rx ] + 1 ).TakeWhile( x => !x.StartsWith( "<" ) );
                foreach ( var s in Phrases )
                    Console.WriteLine( s );
 
                Console.WriteLine();
 
                //Моем полы
                list.Clear();