przemkovv's world

Jednym z przyczyn dla której platforma .NET jest tak elastyczna jest mechanizm refleksji. Prościej mówiąc modyfikacja programu w czasie jego działania. Przykładem użycia może być wywoływanie metod nieznając ich nazw w czasie pisania programu albo tworzenie obiektów z klas znajdujących się w zewnętrznych bibliotekach (inaczej: system wtyczek).
Żeby nie było nie występuje on tylko w produktach firmy Microsoft, ale także w innych językach: PHP, Java, Perl, Ruby. W których został zaimplementowany już dosyć dawno.

Wracając do tematu zaprezentuję tutaj jak można wykorzystać refleksję w praktyce.

Najpierw o najprostszym przypadku: wywołanie metody jakiegoś obiektu.
W pierwszej kolejności musimy pobrać typ naszego obiektu, możemy pobrać go za pomocą funkcji GetType() jeśli już jakiś obiekt istnieje, albo za pomocą typeof(Klasa). W obu przypadkach zostanie zwrócony obiekt typu Type.
Type jest w stanie dostarczyć nam wiele informacji na temat dowolnego typu, począwszy od konstruktorów, destruktorów, poprzez pola, metody aż po typy po których dziedziczy. Pozwala także na wykonywanie metod i zmianę wartości pól. Do tego ostatniego służy metoda InvokeMember. W najprostszej wersji przyjmuje pięć argumentów:

public Object InvokeMember (
	string name,
	BindingFlags invokeAttr,
	Binder binder,
	Object target,
	Object[] args
)

Pierwszy name jest nazwą pola, metody do którego chcemy się odwołać.
Drugi określa czego będziemy pod tą nazwą szukali i co zamierzamy z tym zrobić. Najbardziej interesującym flagami są:

• Public, NonPublic - czy pole jest dostępne ma status publiczny czy prywatny.
• InvokeMethod - znaleziona metoda zostać wywołana
• GetField, SetField, GetProperty, SetProperty - ma zostać pobrana/ustawiona wartość pola lub własciwości
• CreateInstance - zanim cokolwiek się wykona zostanie utworzony nowy obiekt danego typu i na nim będą przeprowadzone operacje.

Na chwilę obecną jeszcze nie za bardzo się orientuję w wykorzystaniu trzeciego parametru binder, więc swobodnie można tam wstawić wartość null. target jest obiektem na którym ma być wykonana operacja. Jeśli wybraliśmy flagę CreateInstance możemy wstawić null. Ostatnim argumentem jest tablica zawierająca wartości potencjalnych argumentów metody lub wartość jaka ma być przypisana polu.
Koniec wstępu teoretycznego, a teraz praktyka:

Type type = GetType();
type.InvokeMember("RotateXCW",
          BindingFlags.InvokeMethod |BindingFlags.NonPublic,
          null,
          this,
          null);
 

Prawda, że proste?
Pobieramy typ aktualnego obiektu w którym znajduje się ten fragment kodu, a następnie wywołujemy prywatną (NonPublic) metodę RotateXCW w bieżącym obiekcie.

Jeśli metoda ma argumenty to kod będzie wyglądał następująco:

Type type = GetType();
type.InvokeMember("RotateXCW",
      BindingFlags.InvokeMethod |BindingFlags.NonPublic,
      null,
      this,
      new object [] { "Pierwszy argument typu string", 10, new Button() );
 

Przekazujemy tablicę obiektów, w tym przypadku: napis, liczbę (integer) i kontrolkę przycisku.

Skoro już wiadomo w jak prosty sposób można wywołać metodę obiektu no to teraz pokażę, jak stworzyć obiekt i jak zrobić prosty system wtyczek.
Kod do realizujący to zadanie będzie wyglądał mniej więcej tak:

string [] files = Directory.GetFiles(pluginPath, "*.dll");
 
for(int i = 0; i < files.Length; i++)
{
// Ladujemy Assembly z pliku
Assembly asm = Assembly.LoadFrom(files[i]);
 
// Sprawdzamy typy zawarte w bibliotece
foreach (Type type in asm.GetTypes())
{
  // Szukamy tylko publicznych, nieabstrakcyjnych klas
  if(type.IsPublic && !type.IsAbstract)
  {
 
    // Sprawdzamy czy dziedziczy po naszym intefrace'ie
    Type iFace = type.GetInterface("plugInterfaces.IPlugin", true);
 
    // Jezeli tak - zapisujemy do pluginow
    if(iFace != null)
    {
      IPlugin tmp = (IPlugin)Activator.CreateInstance(asm.GetType(type.ToString())); // Tworzymy nową instancję pluginu
      plugins.Add(tmp); // Dodajemy plugin
 
      tmp = null; // Czyscimy po sobie
    }
 
    iFace = null; // Czyscimy po sobie
 
    }
}
asm = null; // Czyscimy po sobie
 

W pierwszej linii pobieramy listę plików dll z katalogu z wtyczkami. W linii 6 ładujemy każdą dll'kę i następnie pobieramy wszystkie znajdujące się w niej typy (linia 9). Sprawdzamy, czy to jest klasa której instancję możemy bezproblemowo utworzyć (filtrujemy wszystkie klasy abstrakcyjne, interfejsy, itp).
Konstrukcja z linii 16 i 19 służy do zapewnienia, że dana klasa w pełni implementuje intefejs IPlugin (który jest definiowany przez programistę). W 21 tworzymy obiekt oraz wrzucamy go na listę naszych wtyczek. Sprzątamy po sobie i w ostateczności mamy listę wszystkich obiektów-wtyczek implementujących dany interfejs, którą możemy wykorzystać w dowolny już sposób.

Category: Bez kategorii by Przemysław Walkowiak