20. Atrybuty i mechanizm refleksji

20. Atrybuty i mechanizm refleksji

 Paweł Kruczkowski
Paweł Kruczkowski
00:00
05.02.2007
99866 wyświetleń

Tematem dzisiejszego - ostatniego już w tej części nauki programowania w języku C# 2.0 na łamach portalu CentrumXP.pl – artykułu, będą atrybuty oraz mechanizm refleksji. Pokrótce zdefiniujemy sobie pojęcie atrybutu oraz przybliżymy sobie sposób jego użycia w oparciu o przykłady. Opowiemy sobie również o refleksji: co to jest, jakie ma zalety i wady oraz gdzie ją stosować i w jaki sposób.

Na początku wprowadźmy sobie prawidłowe pojęcie atrybutu. Najprościej mówiąc atrybut to mechanizm, który służy do dodawania do naszego programu metadanych za pomocą instrukcji bądź innych danych. Metadane to informacje jakie są przechowywane w plikach wykonywalnych (pliki z rozszerzeniem .exe czy .dll), i które opisują typy czy metody umieszczone w tych plikach. Z atrybutami ściśle powiązany jest mechanizm refleksji, gdyż program używa go do odczytu własnych metadanych bądź metadanych innych programów. Innymi słowy, nasz program „rzuca refleksję” sam na siebie bądź na program, z którego chcemy sczytać właśnie metadane, a następnie te metadane można wyświetlić na ekranie komputera lub dzięki nim zmodyfikować dalsze działanie naszej aplikacji.

Atrybuty są dostarczane nie tylko przez system (przez środowisko CLR). Możemy bowiem tworzyć własne atrybuty i używać ich do własnych celów (najczęściej robi się tak przy używaniu mechanizmu refleksji). Jednak większość programistów używa tych wbudowanych atrybutów.

Powróćmy jeszcze na chwilkę do definicji atrybutów. Atrybuty to obiekty, które reprezentują dane wiązane z pewnym elementem w programie. Elementy te nazywamy adresatami (ang. target) atrybutu.

Poniższa tabela prezentuje wszystkie możliwe adresaty atrybutów:

Nazwa adresata Zastosowanie
All Można stosować do dowolnego elementu: pliku wykonywalnego, konstruktora, metody, klasy, zdarzenia, pola, właściwości czy struktury
Assembly Można stosować do samego podzespołu (pliku wykonywalnego)
Class Można stosować do klasy
Constructor Można stosować do konstruktora
Delegate Można stosować do delegata
Enum Można stosować do wyliczenia
Event Można stosować do zdarzenia
Field Można stosować do pola
Interface Można stosować do interfejsu

Method Można stosować do metody
Parametr Można stosować do parametru metody
Property Można stosować do właściwości (get i set)
ReturnValue Można stosować do zwracanej wartości
Struct Można stosować do struktury

Aby przypisać atrybut do adresata musimy umieścić go w nawiasach kwadratowych przed elementem docelowym (klasą, metodą czy właściwością etc.). Na przykład:

[Serializable]
      class MojaKlasa

      { … }

W powyższym fragmencie kodu znacznik atrybutu znajduje się w nawiasach kwadratowych bezpośrednio przed adresatem (czyli klasą MojaKlasa). Tak na marginesie, atrybut [Serializable] to jeden z najczęściej używanych atrybutów przez programistę. Umożliwia on serializację klasy na np. dysk lub poprzez sieć komputerową.

Jak już wyżej zostało napisane, programiści używają nie tylko atrybutów, jakie dostarcza nam system, ale również piszą swoje własne.

Wyobraźmy sobie sytuację, że jesteśmy twórcami klasy, która wykonuje operacje matematyczne (np. dodawanie i odejmowanie). Informacje o autorze tej klasy (imię, nazwisko, data oraz krótki komentarz) trzymamy w bazie danych, a w naszym programie w postaci komentarza.  Z czasem jednak nasza klasa zostanie poszerzona przez kogoś innego o dodatkowe funkcjonalności (operacje mnożenia i dzielenia). Owszem, programista, który poszerzy naszą klasę może opisać swoje zmiany w kolejnym komentarzu, ale..lepszym rozwiązaniem byłoby stworzenie mechanizmu, który automatycznie aktualizowałby nasz wpis w bazie o autorze tejże klasy na podstawie nowego komentarza. W takiej sytuacji idealnym rozwiązaniem jest stworzenie własnego atrybutu, który będzie działał w programie jak komentarz. Drugą zaletą takiego podejścia jest to, że atrybut ten będzie pozwalał nam na programowe pobranie treści wspomnianego komentarza i na jej podstawie aktualizację bazy danych.

Napiszmy więc taki program, który będzie prezentował powyższy problem biznesowy:

using System;
using System.IO;
 
namespace CentrumXP_20
{
    // deklaracja wlasnego atrybutu
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Field |
                    AttributeTargets.Property, AllowMultiple = true)]
    //deklaracja klasy, ktora dziedziczy po klasie System.Attribute
    public class MojPierwszyAtrybut : System.Attribute
    {
        // wlasciwosci odpowiadajace wpisowi do bazy danych na temat tworcy klasy
        private int autorID;
        /// ID autora klasy
        public int AutorID
        {
            get { return autorID; }
            set { autorID = value; }
        }
        private string imie;
        /// imie autora klasy
        public string Imie
        {
            get { return imie; }
            set { imie = value; }
        }
        private string nazwisko;
        /// nazwisko autora klasy
        public string Nazwisko
        {
            get { return nazwisko; }
            set { nazwisko = value; }
        }
        private string data;
        // data stworzenia klasy
        public string Data
        {
            get { return data; }
            set { data = value; }
        }
        private string komentarz;
        // krotki komentarz na temat klasy
        public string Komentarz
        {
            get { return komentarz; }
            set { komentarz = value; }
        }
 
        // konstruktor klasy MojPierwszyAtrybut
        public MojPierwszyAtrybut(int autorID, string imie, string nazwisko, string data, string komentarz)
        {
            this.autorID = autorID;
            this.imie = imie;
            this.nazwisko = nazwisko;
            this.data = data;
            this.komentarz = komentarz;
        }
 
        //przypisanie atrybutu do klasy
        [MojPierwszyAtrybut(1, "Paweł", "Kruczkowski", "22-10-2006", "dodawanie i odejmowanie 2 liczb całkowitych")]
        [MojPierwszyAtrybut(2, "Gal", "Anonim", "24-10-2006", "uzupełnienie klasy o metody mnożenia i dzielenia")]
        public class Operacje
        {
            public int Dodawanie(int a, int b)
            {
                return a + b;
            }
 
            public int Odejmowanie(int a, int b)
            {
                return a - b;
            }
 
            public int Mnozenie(int a, int b)
            {
                return a * b;
            }
 
            public double Dzielenie(int a, int b)
            {
                return a / b;
            }
        }
 
        class Glowna
        {
            public static void Main()
            {
                Operacje o = new Operacje();
                Console.WriteLine("Podaj pierwszą liczbę całkowitą:");
                int a = Int32.Parse(Console.ReadLine());
                Console.WriteLine("Podaj drugą liczbę całkowitą:");
                int b = Int32.Parse(Console.ReadLine());
                Console.WriteLine("Wynik dodawania tych liczb to: {0}.", o.Dodawanie(a, b));
                Console.WriteLine("Wynik odejmowania tych liczb to: {0}.", o.Odejmowanie(a, b));
                Console.WriteLine("Wynik mnożenia tych liczb to: {0}.", o.Mnozenie(a, b));
                Console.WriteLine("Wynik dzielenia tych liczb to: {0}.", o.Dzielenie(a, b));
            }
        }
    }
}

Powyższy przykład prezentuje sposób definiowania i używania artybutów. Jak widzimy, atrybuty tworzymy w klasie, która dziedziczy po System.Attribute. W klasie tej umieszczamy wszystkie informacje dla odpowiednich elementów, które będą bezpośrednio powiązane z atrybutem. Elementy te są definiowane w następujący sposób:

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Field |
      AttributeTargets.Property, AllowMultiple = true)]

AttributeUsage to po prostu metaatrybut (udostępnia dane, które opisują metadane). Do konstruktora tego atrybutu należy przekazać 2 parametry:

  • Adresaty atrybutu: klasa, metoda, konstruktor, zmienne oraz właściwości
  • Określenie, czy dana klasa może mieć przypisane więcej niż jeden atrybut MojPierwszyAtrybut (warunek spełniony, bo AllowMultiple = true).

Stworzyliśmy już własny atrybut, a więc możemy umieścić go przed jakimś adresatem. W naszym przykładzie będzie to klasa Operacje, która definiuje 4 metody matematyczne. W taki właśnie sposób atrybut ten będzie nam pomocny przy pilnowaniu informacji na temat twórcy danych metod.

Po skompilowaniu i uruchomieniu powyższego programu otrzymamy następujące wyniki:

Jak łatwo zauważyć, program bez problemu się skompilował i uruchomił, ale nasuwa się pytanie: gdzie są te nasze atrybuty w programie? Poniżej przedstawimy technikę umożliwiająca dostęp do nich w czasie – co należy podkreślić- wykonywania się programu. Mechanizm refleksji, bo o nim mowa, pozwala na przeglądanie i używanie metadanych, czy też na odkrywanie typów plików wykonywalnych.

Do zapamiętania: mechanizm refleksji w języku C# 2.0 korzysta z klas umieszczonych w przestrzeni nazw System.Reflection.

Na początku zaprezentujemy przykład, w którym będziemy przeglądać metadane. Aby to zrealizować musimy utworzyć obiekt typu MemberInfo (klasa ta znajduje się w przestrzeni nazw System.Reflection):

using System;
using System.IO;
using System.Reflection;
 
namespace CentrumXP_20
{
    // deklaracja wlasnego atrybutu
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method |
     AttributeTargets.Constructor | AttributeTargets.Field |
     AttributeTargets.Property, AllowMultiple = true)]
    //deklaracja klasy, ktora dziedziczy po klasie System.Attribute
    public class MojPierwszyAtrybut : System.Attribute
    {
        // wlasciwosci odpowiadajace wpisowi do bazy danych na temat tworcy klasy
        private int autorID;
        /// ID autora klasy
        public int AutorID
        {
            get { return autorID; }
            set { autorID = value; }
        }
        private string imie;
        /// imie autora klasy
        public string Imie
        {
            get { return imie; }
            set { imie = value; }
        }
        private string nazwisko;
        /// nazwisko autora klasy
        public string Nazwisko
        {
            get { return nazwisko; }
            set { nazwisko = value; }
        }
        private string data;
        // data stworzenia klasy
        public string Data
        {
            get { return data; }
            set { data = value; }
        }
        private string komentarz;
        // krotki komentarz na temat klasy
        public string Komentarz
        {
            get { return komentarz; }
            set { komentarz = value; }
        }
 
        // konstruktor klasy MojPierwszyAtrybut

  public MojPierwszyAtrybut(int autorID, string imie, string nazwisko, string  

  data, string komentarz)
        {
            this.autorID = autorID;
            this.imie = imie;
            this.nazwisko = nazwisko;
            this.data = data;
            this.komentarz = komentarz;
        }
 
        //przypisanie atrybutu do klasy
        [MojPierwszyAtrybut(1, "Paweł", "Kruczkowski", "22-10-2006", "dodawanie i odejmowanie
        2 liczb całkowitych")]
        [MojPierwszyAtrybut(2, "Gall", "Anonim", "24-10-2006", "uzupełnienie klasy o metody
        mnożenia i dzielenia")]
        public class Operacje
        {
            public int Dodawanie(int a, int b)
            {
                return a + b;
            }
 
            public int Odejmowanie(int a, int b)
            {
                return a - b;
            }
 
            public int Mnozenie(int a, int b)
            {
                return a * b;
            }
 
            public double Dzielenie(int a, int b)
            {
                return a / b;
            }
        }
 
        class Glowna
        {
            public static void Main()
            {
                object[] mojeAtrybuty;
                Operacje o = new Operacje();
                Console.WriteLine("Podaj pierwszą liczbę całkowitą:");
                int a = Int32.Parse(Console.ReadLine());
                Console.WriteLine("Podaj drugą liczbę całkowitą:");
                int b = Int32.Parse(Console.ReadLine());
                Console.WriteLine("Wynik dodawania tych liczb to: {0}.", o.Dodawanie(a, b));
                Console.WriteLine("Wynik odejmowania tych liczb to: {0}.", o.Odejmowanie(a,
                b));
                Console.WriteLine("Wynik mnożenia tych liczb to: {0}.", o.Mnozenie(a, b));
                Console.WriteLine("Wynik dzielenia tych liczb to: {0}.", o.Dzielenie(a, b));
 
                //tworzymy obiekt klasy MemberInfo i pobieramy atrybuty klasy
                MemberInfo mi = typeof(Operacje);
                mojeAtrybuty = mi.GetCustomAttributes(typeof(MojPierwszyAtrybut), false);
                //przechodzimy po atrybutach
                foreach (Object obj in mojeAtrybuty)
                {
                    MojPierwszyAtrybut mpa = (MojPierwszyAtrybut) obj;
                    Console.WriteLine("");
                    Console.WriteLine("Identyfikator autora metod: {0}.", mpa.AutorID);
                    Console.WriteLine("Imię i nazwisko autora metod: {1} {0}.", mpa.Imie,
                    mpa.Nazwisko);
                    Console.WriteLine("Data stworzenia metod: {0}", mpa.Data);
                    Console.WriteLine("Krótki komentarz autora: {0}", mpa.Komentarz);
                }
            }
        }
    }
}

Obiekt mi klasy MemberInfo potrafi sprawdzić atrybuty oraz pobrać je z danej klasy:

MemberInfo mi = typeof(Operacje);

W powyższej linijce wywołaliśmy operator typeof na klasie Operacje, co powoduje zwrócenie obiektu pochodnego od klasy MemberInfo. Następnie wywołujemy metodę GetCustomAttributes() na obiekcie mi. Do metody tej przekazujemy typ szukanego atrybutu. Metodę tę również informujemy o tym, że jedynym miejscem do wyszukiwania atrybutów jest klasa: MojPierwszyAtrybut  (dlatego drugi parametr tej metody to fałsz):

mojeAtrybuty = mi.GetCustomAttributes(typeof(MojPierwszyAtrybut), false);

Po uruchomieniu powyższego przykładu, program wyświetli na naszym ekranie wszystkie dostępne metadane:

Na koniec przytoczymy książkowy przykład na odkrywanie typów plików wykonywalnych (plik o rozszerzeniu np. dll). Jak już zostało wyżej napisane, mechanizm refleksji jest rewelacyjnym mechanizmem umożliwiającym sprawdzanie zawartości takich plików. Spójrzmy więc na poniższy przykład:

using System;
using System.IO;
using System.Reflection;
 
namespace CentrumXP_20
{
    public class MojaKlasa
    {
        static void Main()
        {
            Assembly assembly = Assembly.Load("Mscorlib.dll");
            Type[] typ = assembly.GetTypes();
            int i = 0;
            foreach (Type t in typ)
            {
                Console.WriteLine("{0} - {1}", i, t.FullName);
                i++;
            }
        }
    }
}

Na początku za pomocą statycznej metody Load() dynamicznie ładujemy główną bibliotekę Mscorlib.dll (zawiera ona wszystkie główne klasy platformy .NET). Następnie wywołujemy na obiekcie assembly klasy Assembly metodę GetTypes(), która zwraca tablicę obiektów Type. Obiekt typu Type to chyba jeden z najważniejszych rzeczy, jakie dostarcza nam refleksja w C# 2.0, bowiem reprezentuje deklaracje typu (np. klasy, tablice itp.). Na koniec petlą foreach „przechodzimy” po wszystkich typach jakie zawiera biblioteka Mscorlib.dll.

Poniżej przedstawiamy jedynie fragment naszych wyników jakie uzyskamy po uruchomieniu powyższego przykładu:

Temat niniejszego artykułu nie należał do łatwych, ale mamy nadzieję, że dzięki niemu poznaliśmy podstawowe informacje związane z atrybutami oraz mechanizmem refleksji, co w przyszłości powinno zaowocować poszerzeniem zdobytej tutaj wiedzy o kolejne ważne aspekty tych zagadnień.

Dzisiejszy artykuł jest również ostatnim z drugiej serii artykułów, które ukazują się na łamach portalu Centrum.XP. Miejmy nadzieję, że wszystkie omówione na łamach portalu tematy przybliżą Państwa do programowania w  języku C# 2.0 i zaowocują wieloma aplikacjami .NETowymi, których Państwo będziecie autorami.


Spodobał Ci się ten artykuł? Podziel się z innymi!

Źródło:

Polecamy również w kategorii Kurs C#, cz. II