Dostęp do rejestru systemu

Pisząc własne programy, z pewnością będziesz chciał zapisywać jego ustawienia tak, aby umożliwić użytkownikowi zapisywanie jego preferencji. Istnieje wiele dróg zapisywania ustawień – są to pliki INI, pliki XML  lub rejestr systemu. Oczywiście metody te można z powodzeniem mieszać uzyskując optymalne rozwiązanie. W Visual Studio mamy do dyspozycji narzędzie dużo potężniejsze, nowocześniejsze i uniwersalne – pliki XML. W zdecydowanej większości XML będzie wystarczające do większości projektów. Warto jednak poznać obsługę rejestru,  gdyż ta metoda jest równie prosta i skuteczna. Rejestr systemu jest bazą danych, przechowującą ustawienia systemu operacyjnego oraz zainstalowanych aplikacji. Umiejętność obsługi rejestru pozwala na kontrolę nie tylko wyglądu i zachowania systemu operacyjnego. Z rejestru można także odczytać pełną konfigurację komputera. Rejestr jest zorganizowany w klucze (ang. Key) oraz wartości kluczy (ang. Values). Choć klucze nie wymagają objaśnień, gdyż można je sobie wyobrazić jako foldery zawierające wartości, to na pojedynczą wartość składają się jego nazwa, typ przechowywanej wartości oraz dana zapisana w wartości. Aby lepiej zobrazować te pojęcia, uruchom program regedit z menu Start -> Uruchom. Poniższy obrazek przedstawia narzędzie regedit przedstawiające klucze główne rejestru.

rejestrvs1

Rejestr zawiera klucze główne, które są punktem wyjściowym do edycji kluczy zagnieżdżonych. Poniżej opisujemy zawartość kluczy głównych.

  • HKEY_CLASSES_ROOT – klucz zawiera informacje o skojarzeniach rozszerzeń plików z programami oraz klasy obiektów COM,
  • KEY_CURRENT_USER – w tym kluczu są zapisane ustawienia spersonalizowane przez każdego użytkownika,
  • HKEY_LOCAL_MACHINE – tutaj natomiast mamy dostęp do konfiguracji komputera,
  • HKEY_USERS – klucz ten zawiera informacje dotyczące ustawienia domyślne użytkowników oraz ich konta,
  • HKEY_CURRENT_CONFIG – konfiguracja danych dla danego profilu sprzętowego.

Znając klucze główne rejestru, można zacząć eksplorację jego struktury. Do podkluczy rejestru przechodzimy klikając [+] na poszczególnych gałęziach rejestru.

Uwaga – przeglądanie rejestru nie jest szkodliwe dla działania komputera, jednak należy bardzo uważać i nie modyfikować żadnych parametrów, gdyż może to spowodować poważne skutki z unieruchomieniem komputera włącznie.

Oto kilka przykładów informacji,  jakie można uzyskać z rejestru systemu:
Aby odczytać typ zainstalowanego procesora w komputerze, należy rozwinąć klucz:  HARDWARE\DESCRIPTION\System\CentralProcessor\0, co przedstawia poniższy  rysunek.

rejestr112

Po lewej stronie ekranu widać hierarchię kluczy. Po prawej zaś stronie widać wartości oraz ich dane. Warto nadmienić, że klucz, to pełna nazwa dostępu od początku hierarchii. Na przykład: Kluczem do odczytu informacji o zainstalowanym procesorze jest w tym przypadku:

HARDWARE\DESCRIPTION\System\CentralProcessor\0

Wartość zaś, to ProcesorNameString i jego dana: Intel(R) Celeron(R) CPU 3.06GHz

Jak pewnie zauważyłeś, w kluczu dostępu do typu zainstalowanego procesora, nie podano klucza głównego – HKEY_LOCAL_MACHINE. Zgodnie z hierarchią klucz powinien wyglądać tak:

HKEY_LOCAL_MACHINE\HARDWARE\DESCRIPTION\System\CentralProcessor\0
Dzieje się tak dlatego, że C# znacznie ułatwia dostęp do rejestru, o czym przekonasz się w dalszej części. Pozostało nam tylko opisać, jakiego typu dane możemy  zapisać w rejestrze.

  • REG_BINARY – dane binarne,
  • REG_DWORD – 32-bitowe wartości liczbowe, często używane jako flagi logiczne,
  • REG_SZ – łańcuchy znakowe

Odczyt rejestru z poziomu C#

Kończąc wstęp teoretyczny, spróbujemy teraz napisać program konsolowy, który będzie odczytywał z rejestru konfigurację naszego komputera. Utwórz nowy projekt. Jako typ projektu wybierz Aplikacja Konsoli i wpisz jego nazwę: rejestr. Teraz wpisz poniższy kod.

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Win32;

namespace rejestr
{
class Program
{
static void Main(string[] args)
{
RegistryKey Procesor = Registry.LocalMachine;
Procesor = Procesor.OpenSubKey(„HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0”);
Object JakiProcesor = Procesor.GetValue(„ProcessorNameString”);
Object IleMHz = Procesor.GetValue(„~MHZ”);
Console.WriteLine(„Informacje o procesorze z rejestru systemu.”);
Console.WriteLine(„Twój procesor to: „+JakiProcesor.ToString().Trim());
Console.WriteLine(”  Szybkość w MHZ: ” + IleMHz);
Procesor.Close();
Console.ReadLine();
}
}
}

Uruchom program klawiszem F5. Jak widzisz, prostym sposobem mogłeś odczytać z rejestru informację o procesorze. Oczywiście powyższy kod jest tylko przykładem możliwości odczytania pojedynczego parametru. Aby dowiedzieć się więcej na temat rejestru systemu, zajrzyj do Internetu lub lepiej do literatury tematu, gdyż rejestr systemu jest bazą niezwykle rozbudowaną. Rozłóżmy teraz nasz kod na czynniki pierwsze, aby bliżej poznać mechanizm jego obsługi.

Pobieramy klucz główny rejestru:

RegistryKey Procesor = Registry.LocalMachine;

LocalMachine oznacza tutaj HKEY_LOCAL_MACHINE. Mamy tutaj do wyboru także inne możliwości. Jeśli chcesz uzyskać informacje z HKEY_CURRENT_USER – użyj Registry.Users. Jeśli natomiast chcesz pobrać zawartość klucza głównego HKEY_CLASSES_ROOT, użyj Registry .ClassessRoot. Zawsze, gdy nie jesteś pewny używaj znakomitego dostępnego w kodzie narzędzia podpowiedzi – IntelliSense, które naprowadzi cię na właściwą drogę.

ejestrintelli12

Następnie musimy otworzyć interesujący nas podklucz klucza głównego. Robimy to w następujący sposób:

Procesor = Procesor.OpenSubKey(„HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0”);

Po otwarciu klucza, możemy już odczytać wybraną wartość:

Object JakiProcesor = Procesor.GetValue(„ProcessorNameString”);

W naszym przypadku otwieramy wartość ProcessorNameString, która zawiera nazwę zainstalowanego procesora. Teraz musimy tę wartość wyświetlić na konsoli. Jako że zwracana wartość jest obiektem, należy użyć funkcji ToString() aby przekonwertować ją na łańcuch tekstowy. Dodatkowo zastosowaliśmy funkcję Trim(), która obcina początkowe i końcowe spacje w przypadku, gdyby takie występowały.

Console.WriteLine(„Twój procesor to: „+JakiProcesor.ToString().Trim());

Na zakończenie zamykamy rejestr.
Procesor.Close();

Podczas odczytu rejestru mamy także do dyspozycji przydatne właściwości i metody.

Procesor.ValueCount; – zwraca ilość dostępnych wartości danego klucza,
Procesor.Name; – zwróci nam nazwę klucza rejestru,
Procesor.GetValueNames; – wypełni tablicę nazwami wszystkich nazw wartości klucza.

Przykładowy program: zapis i odczyt parametrów z rejestru z poziomu C#

Zajmiemy się teraz tworzeniem własnych kluczy w rejestrze, ich odczytem oraz usuwaniem. Napiszemy aplikację, która będzie miała możliwość zapisywania w rejestrze swojego położenia na ekranie. Dodatkowo będziemy mogli wpływać na tytuł aplikacji. Po zakończeniu testowania, usuniemy zbędne informacje z rejestru przyciskiem Wyczyść rejestr. W naszej aplikacji skorzystamy także z dobrodziejstw kontroli ImageList do przechowywania obrazków wykorzystywanych w przyciskach.

  1. Utwórz nowy projekt,
  2. Dopasuj rozmiar formatki Form1, zmień jej właściwość Text na Nasz program, StartPosition na Manual oraz zmień ikonę okna głównego na dowolną opcją Icon, właściwość FormBorderStyle ustaw na FixedSingle,
  3. Wstaw do projektu groupBox i zmień jej właściwość Text na Współrzędne startowe okna oraz wstaw dwie etykiety (label2 i label3) jak na obrazku poniżej,
  4. Dodaj trzy przyciski (button1, button2, button3). Zmień ich parametry Name na bt_zapisz, bt_koniec, bt_wyczysc. Dodatkowo zmień ich właściwości Text na takie, jak na rysunku.
  5. Do formy dodaj także komponent imageList, w którym dodaj trzy obrazki mające pojawić się na przyciskach. Jest to opcjonalne, ale znacznie poprawia efektowność oraz czytelność programu. Kolekcje obrazków możesz zakupić lub znaleźć w Internecie. Aby dodać kolekcje obrazków, kliknij na strzałce w prawym, górnym rogu kontrolki. Pojawi się okno:

rejestrwe12

Z ona wybierz opcję Choose images. Zostanie wyświetlone okna wyboru kolekcji obrazków. Obrazki te są grupowane według indeksów od zera.

rejsd123

Możesz dodawać kolejne obrazki przyciskiem Add, lub je usuwać z listy przyciskiem Remove. Po zakończeniu kliknij przycisk OK.

6.    Po zakończeniu dodawania obrazków, zaznacz po kolei każdy przycisk, zmieniając jego właściwości: ImageList – imageList1, ImageAlign – MiddleLeft, ImageIndex na właściwy obrazek.
7.    Na koniec dodaj do formy pole tekstowe (textBox), które będzie umożliwiało wpisanie tytułu aplikacji. Zmień jego właściwość Text na Nasz program – będzie to nazwa tytułowa naszej aplikacji.

rejestr_fullprogram

Kolejną czynnością jest zaprogramowanie zdarzeń okna oraz przycisków. Pierwszym zdarzeniem będzie podpięcie zdarzenia generowanego podczas przesuwania okna po ekranie. Zdarzenie to nosi nazwę Form1_Move. Aby dodać nowe zdarzenie do formy głównej – zaznacz ją, z okna właściwości przełącz się na edycję zdarzeń i kliknij na zdarzeniu Move. Zostaniesz przeniesiony do edycji kodu źródłowego, bezpośrednio do nowo utworzonej funkcji zdarzenia. Wpisz poniższy kod:

private void Form1_Move(object sender, EventArgs e)
{
label2.Text = „X = ” + this.Location.X; // this oznacza okno bieżące
label3.Text = „Y = ” + this.Location.Y;
}

Spróbuj wypróbować działanie programu klawiszem F5. Niestety nic się nie stanie. Spróbuj jednak przenieść okna w inne miejsce i… widać efekt naszej pracy! Etykiety label2 oraz label3 wyświetlają nam współrzędne okna. Następnym krokiem będzie zaprogramowanie zdarzenia zachodzącego podczas kliknięcia przycisku Zapisz ustawienia. Jak pamiętasz, przypisywanie zdarzenia kliknięcia przycisku polega na podwójnym kliknięciu na nim w trybie projektowania formularza. Teraz wystarczy tylko wpisać poniższy kod:

private void bt_zapisz_Click(object sender, EventArgs e)
   {
    RegistryKey XYForma = Registry.LocalMachine; // Klucz główny
    XYForma = XYForma.OpenSubKey("Software", true); // Otwieramy
    RegistryKey klucz = XYForma.CreateSubKey("NaszaFormatka");
    klucz.SetValue("Nazwa", textBox1.Text); // Wstaw wartość
   klucz.SetValue("X1", this.Location.X); 
   klucz.SetValue("Y1", this.Location.Y);
   XYForma.Close();
   MessageBox.Show("Ustawienia zapisane w rejestrze!");
  }

W trakcie wpisywania kodu lub kompilacji, możesz otrzymać komunikat o błędzie: The type or namespace name ‚RegistryKey’ could not be found (are you missing a using directive or an assembly reference?)

Problemem jest brak deklaracji w sekcji using Microsoft.Win32. Problem można rozwiązać na trzy sposoby. Wpisać deklarację ręcznie, lub uzyć inteligentnego narzedzia podpowiedzi – IntelliSense. Celowo w nioniejszej książce często przypominamy o tym doskonałym narzędziu programisty. Wszak nie zawsze będziesz pewny, jakiej deklaracji użyć. Zresztą nie muszisz pamiętać wszystkiego. Wystarczy, że najedziesz wskaźnikiem myszy na błędną instrukcję, w tym przypadku RegistryKey, i wywołasz menu kontekstowe. Z dostępnych opcji menu wybierz Resolve ->  using… Sekcja using zostanie uzupełniona o brakującą bibliotekę automatycznie.

rejskwe323

Można jeszcze prościej. Przytrzymując chwilę wskaźnik myszy na błędzie, zostanie wyświetlona ikona, z której od razu uzupełnisz sekcje using w wymagane biblioteki.

rejestr_vs121

Zajmiemy się teraz zdarzeniem Form1_Load, generowanym zawsze podczas ładowania formy. Musimy przecież sprawić, aby przy każdym otwarciu programu była odczytywana konfiguracja z rejestru, która posłuży do opisania pozycji X i Y okna oraz jej tytułu. Zaznacz formularz i używając edytora właściwości i sekcji zdarzenia znajdź na liście Load. Kliknij podwójnie na zdarzeniu, aby utworzyć metodę obsługi zdarzenia.

private void Form1_Load(object sender, EventArgs e)
  {
   RegistryKey XYForma = Registry.LocalMachine;
     try
     {
      XYForma = XYForma.OpenSubKey("Software\\NaszaFormatka", true);
      Object nazwa = XYForma.GetValue("Nazwa");
      Object X = XYForma.GetValue("X1");
      Object Y = XYForma.GetValue("Y1");
      this.SetDesktopLocation(Convert.ToInt32(X), Convert.ToInt32(Y));
       label2.Text = "X = " + this.Location.X;
       label3.Text = "Y = " + this.Location.Y;
       this.Text = Convert.ToString(nazwa);
       textBox1.Text = Convert.ToString(nazwa);
      XYForma.Close();
     }
 catch { MessageBox.Show("Ustaw parametry i klinkij zapisz ustawienia.");     
 }       
}

Odczyt rejestru należało umieścić w sekcji try – catch, gdyż podczas pierwszego uruchamiania okna klucz konfiguracji w rejestrze nie istnieje. Powodowało by to zawieszenie się programu. Dzięki catch zaś zostaniemy kulturalnie poinformowani, aby zapisać ustawienia programu odpowiednim przyciskiem.

Spróbuj teraz wypróbować działanie programu. Co prawda, podczas pierwszego uruchomienia wyświetli się okienko informacyjne, to jeśli zapiszemy parametry przyciskiem Zapisz ustawienia, to przy następnym uruchomieniu okno programu znajdzie się dokładnie tam, gdzie zostało zapisane a tytuł okna zostanie odtworzony z rejestru.

Pozostało jeszcze posprzątać po sobie. Po zakończeniu zabawy z programem, w dobrym tonie jest pozostawienie rejestru takim, jakim go zastaliśmy. Zaprogramuj więc zdarzenie dla przycisku Wyczyść rejestr. Opcja ta usunie z rejestru klucz programu – NaszaFormatka.

private void bt_wyczysc_Click(object sender, EventArgs e)
 {
  RegistryKey XYForma = Registry.LocalMachine.OpenSubKey("Software",true);
  XYForma.DeleteSubKey("NaszaFormatka"); // Usuwamy klucz z rejestru
  XYForma.Close();
 }

Na koniec pozostał nam przycisk Koniec – to tylko jedna linia kodu.

private void bt_koniec_Click(object sender, EventArgs e)
  {
   Application.Exit();
  }

Oto pełny kod źródłowy naszej aplikacji wykorzystującej rejestr systemowy do zapisywania ustawień położenia początkowego okna oraz tytułu aplikacji.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using Microsoft.Win32;

namespace FormaZRejestrem
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
          RegistryKey XYForma = Registry.LocalMachine;
          try
          {
           XYForma = XYForma.OpenSubKey("Software\\NaszaFormatka", true);
           Object nazwa = XYForma.GetValue("Nazwa");
           Object X = XYForma.GetValue("X1");
           Object Y = XYForma.GetValue("Y1");
           this.SetDesktopLocation(Convert.ToInt32(X), Convert.ToInt32(Y));
            label2.Text = "X = " + this.Location.X;
            label3.Text = "Y = " + this.Location.Y;
            this.Text = Convert.ToString(nazwa);
            textBox1.Text = Convert.ToString(nazwa);
            XYForma.Close();
           }
  catch { MessageBox.Show("Ustaw parametry i klinkij zapisz ustawienia.");  }
           
       } 

   private void Form1_Move(object sender, EventArgs e)
     {
      label2.Text = "X = " + this.Location.X;
      label3.Text = "Y = " + this.Location.Y;
     }

   private void bt_wyczysc_Click(object sender, EventArgs e)
     {
      RegistryKey XYForma = Registry.LocalMachine.OpenSubKey("Software",true);
      XYForma.DeleteSubKey("NaszaFormatka");
      XYForma.Close();
     }

        private void bt_zapisz_Click(object sender, EventArgs e)
        {
            RegistryKey XYForma = Registry.LocalMachine;
            XYForma = XYForma.OpenSubKey("Software", true);
            RegistryKey klucz = XYForma.CreateSubKey("NaszaFormatka");
            klucz.SetValue("Nazwa", textBox1.Text);
            klucz.SetValue("X1", this.Location.X);
            klucz.SetValue("Y1", this.Location.Y);
            XYForma.Close();
            MessageBox.Show("Ustawienia zapisane w rejestrze!");
        }

        private void bt_koniec_Click(object sender, EventArgs e)
        {
            Application.Exit();
        }
    }
}

Wypróbuj teraz działanie programu. Zmieniaj tytuł oraz pozycję okna. Zapisuj ustawienia przyciskiem zapisz ustawienia. Po każdym ponownym otwarciu programu okno programu znajdzie się przy starcie tam, gdzie zostało zapisane. Dodatkowo na pasku tytułu oraz w linii edycyjnej znajdzie się zdefiniowany tytuł aplikacji. Ten prosty przykład miał na celu zaprezentowanie możliwości użycia rejestru jako składnicy ustawień i parametrów. Po przestudiowaniu niniejszego rozdziału, nie powinieneś mieć kłopotów z użyciem rejestru we własnych programach.

417total visits,1visits today

Tagi , .Dodaj do zakładek Link.

Dodaj komentarz

Twój adres email nie zostanie opublikowany. Pola, których wypełnienie jest wymagane, są oznaczone symbolem *

13 + = 23