Tematem dzisiejszego wykładu jest poruszony na pewnym forum problem uruchamiania zewnętrznego programu z aplikacji napisanej w C++ (bonusowo na końcu wpisu zamieszczę także klasę tego typu pisaną w C#, a ponieważ tłumaczenia rozwiązania w obydwu językach by się pokrywały to opis będę opierał na C++). Ponieważ idziemy z duchem czasu, a bodajże chodziło tam o system Windows to postaram się przybliżyć Wam proste i kompleksowe rozwiązanie działające w Visual C++ .NET.

Nie będziemy sobie w tym wypadku zaprzątać głowy natywnym Win32. Projekt stworzymy w trybie okienkowym jako Windows Forms. Do dzieła więc! Kolejno po wejściu do środowiska należy w menu wybrać File (Plik) -> New (Nowy) -> Project… (Projekt…). W nowym okienku należy wybrać Visual C++ -> CLR -> Windows Forms Application (Aplikacja Windows Forms). Wystarczy jeszcze powyżej ustawić z listy .NET Framework 2.0 (wyższe wersje też są dozwolone, ale w gruncie rzeczy niepotrzebne dla tego co będziemy starali się osiągnąć), a także na samym dole wybrać nazwę nowego programu (Name/Nazwa:, w przykładzie będzie to process_starter) i ewentualnie zmienić miejsce zapisu projektu (Location/Lokacja:). Niektórych może zdziwić nazwa przykładowego projektu, ale fakt jest taki, że otwieranie i zamykanie programów w naszym przypadku będzie odbywać się w głównej mierze na procesach systemu.

Automatycznie został wygenerowany domyślny kod wraz z klasą formularza. Ponieważ projekt całego rozwiązania jest prosty, pozwolicie że zacznę od krótkiego wytłumaczenia części okienkowej. Dla przykładu będziemy potrzebować dwóch textbox’ów (nazwanych tutaj filenameValue i argsVal) i jednego button’a (makeButton). Nie wymieniam tu użytych label’ów, czy progressbar’a, bo to tylko części estetyczna.

Teraz możecie kliknąć dwa razy na wspomniany już przycisk i przechodzimy do partii kodu.

Pora więc na trochę teorii, czyli krótki opis jak będziemy wywoływać i niszczyć procesy. Skorzystamy tu z przestrzeni nazw, wraz z klasą przeznaczoną do tego typu rzeczy.

using namespace System::Diagnostics::Process;

Poprzez odpowiednie użycie jej elementów i metod możemy bez problemu uruchomić zewnętrzny program, a później go zabić bez wprowadzania dodatkowych danych jak w przypadku użycia WinAPI. Tyle z teoretyzowania.

Kod który stworzymy proponuję podzielić na trzy oddzielne metody, plus jedna obsługująca zdarzenie przyciśnięcia przycisku. Zajmijmy się najpierw dwoma głównymi:

• runProcess(plik_do_otwarcia, opcjonalne_argumenty_pliku) pozwalająca na otwarcie programu,
• killProcess() zamykająca proces otwartego programu.

W pierwszym z nich przede wszystkim należy wywołać metodę statyczną odpowiadającą za otwarcie pliku. Ponieważ jednak będziemy chcieli go później zamknąć to musimy jej wynik przypisać do zmiennej przechowującej stan procesu. Prócz tego przydałoby się sprawdzać wcześniej czy podana ścieżka do pliku istnieje (z tym wiąże się dodanie przestrzeni nazw System::IO). A co za tym idzie typ naszej metody musimy zmienić na logiczny, gdyż będzie zwracała wartość zależną od tego czy w.w. argument jest prawidłowy.

#using <system.dll> // dodajemy korzystanie z danego rozszerzenia (dla klasy Process i RegEx)

namespace process_starter {
[...]
	using namespace System::Data;
	using namespace System::IO; // przestrzeń nazw dla File::Exists
	using namespace System::Diagnostics; // dodajemy przestrzeń nazw
[...]
	private: System::Windows::Forms::Button^  makeButton;

	private:
		Process^ process; // dodajemy deklarację zmiennej obsługującej stan procesu
[...]
#pragma endregion
		/**
		 * Rozpoczęcie procesu podanego w parametrze proc w wypadku,
		 * gdy plik podany w parametrze istnieje.
		 *
		 * @access:		private
		 * @param:		System::String^		proc
		 * @param:		System::String^		args
		 * @return:		bool
		 */
		bool runProcess(System::String^ proc, System::String^ args)
		{
			if ( File::Exists(proc) ) // sprawdzenie, czy plik istnieje
			{
				process = Process::Start(proc, args); // wywolanie zadanego procesu
				return true;
			}
			return false;
		}
[...]

Druga metoda opiera się na sprawdzeniu, czy program który wywołaliśmy nie został już czasami zamknięty (np. ręcznie przez użytkownika) i jeśli tak się nie stało na jego zamknięciu. Wszystko zostało opatrzone dodatkowo w wyłapywanie ewentualnych wyjątków. Poniższą funkcję klasy możemy dodać pod tą zajmującą się uruchamianiem.

/**
		 * Łagodne zabicie procesu programu wywołanego wcześniej w przypadku
		 * kiedy nie został on zamknięty w międzyczasie przez użytkownika.
		 *
		 * @access:		private
		 **/
		void killProcess()
		{
			try {
				if ( !process->HasExited ) // sprawdzenie czy proces istnieje
				{
					process->Refresh(); // pozbycie się scacheowanych informacji o procesie
					process->CloseMainWindow(); // zamknięcie procesu
					process->Close(); // zwolnienie zasobów związanych z procesem
				}
			}
			catch ( Exception^ e ) // wyłapanie ewentualnego wyjątku
			{
				MessageBox::Show("Niespodziewany błąd:\n\n" + e->Message, "Błąd!", MessageBoxButtons::OK, MessageBoxIcon::Error);
			}
		}

Jakby nie patrzeć wszystko co miał poruszać ten wpis zostało już pokazane. Teraz dodatkowo należałoby złożyć to jakoś w całość (czyli nadać ciut życia i funkcjonalności przyciskowi odpowiedzialnemu za interakcję), a także napisać choć podstawowe zabezpieczenia czyniące program “idiotoodpornym”. Tutaj pojawia się trzecia metoda która za pomocą wyrażeń regularnych pozwala na sprawdzenie wprowadzonego adresu pliku z wzorcem. Ten kod także wstawiamy w sekcji private, tak jak powyższe. Dodatkowo należy także dodać przestrzeń nazwa dla klasy RegEx.

[...]
	using namespace System::Drawing;
[...]
	using namespace System::Text::RegularExpressions; // przestrzeń nazwa wyrażeń regularnych
[...]
		/**
		 * Porównanie ciągu znaków z wprowadzonym wzorcem dzięki wyrażeniom
		 * regularnym.
		 *
		 * @access:		private
		 * @param:		System::String^		string
		 * @param:		System::String^		pattern
		 * @return:		bool
		 */
		bool checkExpression(System::String^ string, System::String^ pattern)
		{
			Regex^ regex = gcnew Regex(pattern); // tworzymy definicję klasy RegEx
			Match^ match = regex->Match(string); // tworzymy definicję klasy Match
			if ( match->Value->Length > 0 ) // sprawdzamy, czy ciąg odpowiada wzorcowi
			{
				return true;
			}
			return false;
		}

No i ostatecznie kwestia nawigacji. Osobiście proponuję zdefiniowanie zmiennej klasy przetrzymującej stan przycisku (czy ma nastąpić uruchomienie, czy zamknięcie). Wg. tego po sprawdzeniu, czy wpisane dane dostępu do pliku nie są puste lub nie są nieprawidłowe wywołujemy odpowiednio, albo metodę wywołującą plik, albo zamykającą go.

[...]
	public:
		Form1(void)
		{
			this->button_mode		= true; // true, jesli uruchamia program, false jesli zabija
[...]
	private:
		bool button_mode; // dodajemy deklarację stanu przycisku
[...]
		private: System::Void makeButton_Click(System::Object^  sender, System::EventArgs^  e)
		{
			/**
			 * Sprawdzenie, czy pole tekstowe odpowiadające za ścieżkę dostępu
			 * do pliku nie jest puste lub nie jest nieprawidłowo wypełnione.
			 * Pola argumentów nie jest sprawdzane, gdyż nie są one wymagane.
			 */
			if ( this->filenameValue->Text != "" && this->checkExpression(this->filenameValue->Text, "(([a-zA-Z]{1}):|)(.*)\\.([a-z0-9A-Z]{1,3})") == true )
			{
				switch ( this->button_mode )
				{
					case true:
						// wywołanie metody otwierającej plik
						if ( this->runProcess(this->filenameValue->Text, ( this->argsVal->Text != "" ? this->argsVal->Text : "" )) == true )
						{
							this->button_mode = false;
							this->makeButton->Text = "Zamknij";
						}
						else {
							MessageBox::Show("Plik nie istnieje!", "Błąd!", MessageBoxButtons::OK, MessageBoxIcon::Error);
						}
						break;
					default:
						this->killProcess(); // wywołanie metody zamykającej program
						this->button_mode = true;
						this->makeButton->Text = "Uruchom";
						break;
				}
			}
			else if ( this->filenameValue->Text == "" ) // wyświetlenie ostrzeżenia o niewypełnieniu pola
			{
				MessageBox::Show("Nie wprowadzono nazwy lub ścieżki pliku!", "Błąd!", MessageBoxButtons::OK, MessageBoxIcon::Warning);
			}
			else { // wyświetlenie ostrzeżenia o błędnym wypełnieniu pola
				MessageBox::Show("Wprowadzono niepoprawną ścieżkę lub nazwę pliku!", "Błąd!", MessageBoxButtons::OK, MessageBoxIcon::Warning);
			}
		}

Teraz wystarczy tylko skompilować kod i uruchomić program. Wykorzystanie jest chyba proste. W jednym polu tekstowym wpisujemy nazwę pliku jeżeli znajduje się on w katalogu aplikacji lub pełną ścieżkę z nazwą pliku w wypadku, gdy znajduje się on w innym folderze. Drugie pole tekstowe (argumentów) jest niewymagane do uzupełnienia. Można tam umieścić “old schoolowe” parametry elementu docelowego skrótów, bądź spróbować np. podać adres internetowy do otwarcia w przypadku wywoływania przeglądarki. Należy wspomnieć, że w wypadku podania błędnego parametru klasa Process zlekceważy go.

Na koniec kilka przykładowych danych:

• ścieżka: c:\windows\explorer.exe; argumenty: brak,
• ścieżka: c:\program files\mozilla firefox\firefox.exe; argumenty: http://utnij.eu/

PS: zamieszczam gotowy plik exe (kompilowany z C++) i klasa C++ składająca się z powyższego kodu. Na życzenie dodaję także plik wykonywalny (kompilowany z C#) oraz klasę pisaną w c# (po ściągnięciu tego pliku jego rozszerzenie należy zmienić z .h na .cs).

Z tej strony podziękowania dla Biedrzola za ukazanie sprawy i te kilka godzin bez przerwy z stukaniem w klawiaturę w celu przejścia kolejnego “stage-a” w Tanku :D

I tak właśnie wpadłem na pomysł, żeby z chaotycznie porozrzucanych po internecie plików zrobić jedną paczkę instalacyjną. Na razie jest to wersja początkowa, nazwijmy ją dla koneserów alpha. Wymaga .net framework 3.5 i pozwala na odpalenie z poziomu na szybko pisanej przeze mnie aplikacji ponad 150 gier na Pegasusa w trzech różnych emulatorach. Sam program, pisany w Visual C# .NET nie uracza masą opcji, ale jeśli będzie zainteresowanie to postaram się go udoskonalić, dodać ciut ustawień, auto-aktualizacji i ściągania nowych gier.

Sprawa niby prosta, ale jednak jeśli tak jak chciałem to zrobić ja ktoś stara się zaimplementować algorytm nie tylko dla liczb całkowitych to można łatwo wpaść w zbędny poślizg i uzyskać niepowołany wynik. Postanowiłem utworzyć dwie osobne funkcje wektorowe oparte na tego samego typu tablicach, jedną typu string, drugą float. Wiem, wiem… mogłem pobawić się stricte szablonami i nie rozdrabniać się. Nie mniej jednak dla mnie ważny był wtedy tzw. deadline zdania pracy, a kopiuj wklej jest na pewno bardziej efektywne pod względem czasu niż samo pisanie ;]

Cała moja praca ograniczyła się do optymalizacji gotowego algorytmu, dodania funkcji zmniejszającej litery w stringach w celu uniknięcia wstawienia słowa pisanego dużymi literami, przed tym samym słowem pisanym małymi literami, a także pokazanie przykładowego wykorzystania szablonów. W kodzie wynikowym float-y są wyświetlane przed string-ami. Domyślnie wyświetla wartości od “pierwszej” do “ostatniej”.

Mam nadzieję, że kod się komuś przyda. Jeśli ktoś jest zainteresowany opisem dokładniejszym i plikiem źródłowym zapraszam tutaj (opcjonalne źródło pliku także tutaj).