Po co podpisywać assembly?

Zasadnicza odpowiedź na to pytanie jest prosta: z tych samych powodów, dla których podpisuje się cokolwiek innego. Jeśli podpiszesz swoim kluczem prywatnym wiadomość email, odbiorca będzie mógł sprawdzić, że email rzeczywiście pochodzi od Ciebie; jeśli podpiszesz plik cyfrowo, będziesz mógł sprawdzić, czy nikt nie zmienił jego treści.

Między innymi z tych powodów stosuje się podpisywanie assembly – żeby potwierdzić tożsamość podzespołu.

Pełna tożsamość assembly składa się z 4 części:

• krótkiej nazwy. Na platformie Windows jest to nazwa pliku bez rozszerzenia, np.:  Microsoft.DirectX.Direct3D;
• kultury, czyli wersji lokalizacyjnej, np.: en;
• tokena publicznego klucza podpisu: np.: 31bf3856ad364e35;
• wersji np:  1.0.2902.0.

lub  w postaci jednego łańcucha:

Microsoft.DirectX.Direct3D, Culture=en, 
PublicKeyToken=31bf3856ad364e35, Version=1.0.2902.0

Dopóki nie podpiszesz swojego podezspołu, część PublicKeyToken pozostaje pusta.

Zmiana wartości jednej z tych 4 części skutkuje zmianą tożsamości biblioteki/assembly. Taki sposób identyfikacji bibliotek rozwiązał stary problem DLL Hell, który polegał na tym, że nowe instalacje nadpisywały starsze wersje jakiejś współdzielonej biblioteki, a wcześniej zainstalowane programy odwoływały się do tej nowej biblioteki próbując wykonać operacji, której implementacja się zmieniła w nowej wersji. Skutkował oto błędnym działaniem programów a czasami i systemu operacyjnego.

.NET Framework częściowo rozwiązuje ten problem za pomocą GAC (Global Assembly Cache), gdzie różne wersje tych samych współdzielonych bibliotek mogą być przechowywane bez przeszkód. Jak zatem .NE T rozróżnia rozmaite wersje bibilotek (np. DirectX for Managed Code)? Ano właśnie za pomocą tych 4-częściowych nazw.

Żeby jednak biblioteka (podzespół) mogła być umieszczona w GAC musi mieć silną nazwę.

Silna nazwa podzespołu – Assembly Strong Name

Silna nazwa (strong name) to owa 4-częściowa nazwa, która zawiera PublicKeyToken plus cyfrowy podpis. Jak powstaje ten podpis?

Żeby go utworzyć potrzeba pary kluczy (publiczny-prywatny) o długości 1024-bitów.  Klucz publiczny jest dołączany do 4-częściowej nazwy podzespołu właśnie jako PublicKeyToken. Taka komplementarna para jest wykorzystywana do szyfrowania za pomocą algorytmu RSA.

Kiedy kompilator jest proszony o cyfrowe podpisanie podzespołu, najpierw oblicza skrót z jego zawartości za pomocą funkcji haszującej. Później ten skrót jest szyfrowany kluczem prywatnym pochodzącym z pary kluczy i umieszczany w podzespole.

Tak powstaje podpisany podzespół z silną nazwą.

Kiedy później zachodzi potrzeba zweryfikować tożsamość danego podzespołu (mówiąc wprost: sprawdzić, czy nikt w nim nie grzebał), wykonywane są następujące kroki:

• liczony jest skrót z zawartości podzespołu;
• wyłuskiwany jest publiczny klucz (zapisany w podzespole);
• klucz ten jest używany do rozszyfrowania skrótu podzespołu utworzonego podczas kompilacji;
• oba skróty (ten z kompilacji i ten wyliczony w kroku pierwszym) są porównywane;
• jeśli nie są równe znaczy to, że zawartość podzespołu została zmieniona.

Jak utworzyć silną nazwę i podpisać assembly?

Można to zrobić na kilka sposobów, np. za pomocą Visual Studio lub narzędzia linii komend sn.exe.

Omówię pierwszy sposób.

Wybieramy ustawienia naszego projektu (prawy przycisk na nazwie projektu > Properties) i przechodzimy do zakładki Signing. Zaznaczamy opcję Sign the assembly.

Podpisywanie podzespołu

Możemy skorzystać z istniejącego pliku z kluczami, bądź utworzyć nowy. Stwórzmy nowy:

Podpisywanie podzespołu - tworzenie klucza

Wpisujemy nazwę i hasło, które będzie chroniło nasze klucze przed niepowołanym dostępem.

Klikamy OK., zapisujemy projekt i kompilujemy. I już mamy podpisany podzespół z silną nazwą. Wygenerowany plik z kluczami zachowujemy do późniejszego użycia.

Jak zweryfikować, czy nasz podzespół ma poprawną tożsamość? Możemy użyć narzędzia sn.exe z opcją –v. Opcja –T wyświetla publiczny token.

Sprawdzanie podpisu

Global Assembly Cache

Jak wspomniałem GAC – Global Assembly Cache (globalna pamięć podręczna podzespołów) jest miejscem składowania współdzielonych bibliotek DLL używany przez programy na platformie .NET. Dzięki GAC możemy przestać martwić się o fizyczne położenie używanych przez nas bibliotek na dysku. Jeśli podzespół został dodany do GAC, CLR zawsze będzie w stanie go znaleźć i załadować. GAC rozwiązuje też słynny problem DLL hell (”piekło DLL“) – umożliwia przechowywanie na jednej maszynie dowolnej liczby wersji danej biblioteki.

Standardowo GAC znajduje się w katalogu C:\Windows\Assembly\GAC.

Podzespoły znajdujące się w GAC są traktowane jako bezpieczne. Aby rzeczywiście tak było, podczas instalacji podzespołu w GAC przeprowadzana jest weryfikacja jego cyfrowego podpisu. A więc w GACu mogą być umieszczone tylko podzespoły z silną nazwą.

Poza tym tylko użytkownicy z grup administratorzy i użytkownicy zaawansowani mogą dodawać podzespoły do GAC.

Dla każdego nowododanego podzespołu tworzony jest katalog o nazwie tożsamej z krótką nazwą podzespołu (np. Microsoft.DirectX.Direct3D) a w nim podkatalogi odpowiadające wersjom – nazwy są tworzone wg wzorca wersja__publiczny token (np. 1.0.2902.0__31bf3856ad364e35).

Jak dodawać swoje podzespołu do GAC? Służy do tego narzędzie GACUTIL.EXE (parametry /i i /il instalują podzespoły; parametry /u i /ul odinstalowują podzespoły)

Jak bardzo jest to bezpieczne?

Krótko mówiąc: nie bardzo. Zmiana zawartości podpisanego assembly nie uniemożliwia jego uruchomienia przez CLR. Można co prawda zweryfikować integralność pliku, ale nie można uniemożliwić jego uruchomienia, zwłaszcza na poziomie pełnego zaufania.

Jeśli chodzi o GAC to integralność podzespołu jest sprawdzana wyłącznie w momencie dodawania go do GACa. Później już nie jest. Osoba z uprawnieniami administratora może więc podmienić zweryfikowany podzespół na niezweryfikowany.

Co więcej, silną nazwę można usunąć lub zamienić, co zostało opisane w tym artykule.

Jak więc zabezpieczyć swój kod, tak żeby nie można było go uruchomić, gdy jego integralność została naruszona? Zajmę się tym w jednym z kolejnych wpisów.

Celem egzaminu numer 70-562 jest potwierdzenie kompetencji w zakresie programowania aplikacji internetowych za pomocą ASP.NET na platformie .NET 3.5. Jak czytamy na stronie poświęconej egzaminowi profil idealnego kandydata do zdania tego egzaminu to osoba pracująca w średnich-dużych zespołach z dwu-, trzyletnim doświadczeniem w dziedzinie tworzenia aplikacji webowych.

Prócz tego egzamin obejmuje wszystkie zagadnienia dotykające tematyki webaplikacji, między innymi:

• Dostęp do danych za pomocą ADO.NET
• Webserwisy
• WCF
• AJAX i Javascript
• Konfiguracja IIS.

Zakres jest dość rozległy, ale nadal obraca się wokół pisania aplikacji internetowych i w tym kontekście sprawdza wiedzę z dodatkowych dziedzin.

Oczywiście – tak jak w przypadku innych egzaminów – samo kilkuletnie doświadczenie programistyczne nie gwarantuje pozytywnego złożenia egzaminu. Potrzebne jest jeszcze solidne powtórzenie swojej wiedzy i nauczenie się pewnych rzeczy na pamięć (co w codziennej pracy z powodzeniem jest zastępowane choćby przez Intellisense). Jak zatem dobrze przygotować się do złożenia egzaminu?

70-562 – jak zdać?

Dobrą pomocą do powtórzenia materiału jest na przykład książka: MCTS Self-Paced Training Kit (Exam 70-562): Microsoft .NET Framework 3.5-ASP.NET Application Development. Rozdział po rozdziale omawia  poszczególne zagadnienia, szczególnie dużo miejsca poświęcając ADO.NET. Trzeba zaznaczyć, że nie jest to książka do nauki programowania w ASP.NET  – można ją raczej nazwać repetytorium. Na uwagę zasługują ramki „Exam tip” z sugestiami, na co szczególnie zwrócić uwagę podczas egzaminu.

Książka na pierwszy rzut oka przeraża objętością – jest przynajmniej tak duża jak Self-Paced Training Kit dla egzaminu 70-536. Pamiętajmy jednak, że przykładowe kody źródłowe pisane są podwójnie (w C# i w VB.NET), a sporą cześć zajmują powtórki rozdziałów i przykładowe scenariusze.

Zasadniczo są dwa sposoby używania książki. Można próbować czytać ją tzw. ciurkiem i… po mniej więcej pół godziny odpłynąć do krainy Morfeusza. Nie polecam.

Drugi sposób – znacznie bardziej efektywny – to czytanie książki z otwartym Visual Studio i wypróbowywanie konstrukcji, o których właśnie czytasz. Oczywiście – pewnie większość z nich już kiedyś używałeś, ale być może nie zauważyłeś pewnych detali, które mogą zaważyć na tym, jak odpowiesz na pytania.

Olbrzymią wartością dodaną jest płyta z przykładowymi pytaniami testowymi. Jest 125 pytań podsumowujących poszczególne lekcje i 200 pytań praktycznych przypominających te, które będą na egzaminie.

W sieci można też kupić zestawy przykładowych pytań na MeasureUp lub na SelfTestSoftware, które także przypominają pytania na prawdziwym egzaminie i pozwalają ocenić stan przygotowania.

Tak na marginesie: w komentarzach do wpisu o egzaminie 70-536 użytkownik Matol napisał, że można kupić prawdziwe (lub zbliżone do prawdziwych) pytania z egzaminów albo nawet dostać je za darmo, w związku z czym – jego zdaniem – egzaminy te nie sprawdzają jakiejkolwiek rzeczywistej wiedzy. Z takim stwierdzeniem nie mogę się zgodzić (z wielu powodów). Jeśli natomiast Matol miał na myśli, że przez dumpy z pytań egzaminacyjnych wartość egzaminów się obniża, to owszem, skłonny jestem przyznać rację. Ale jednocześnie można powiedzieć, że również maturę i pracę magisterską można kupić (i także deprecjonuje to wartość tych egzaminów), a jednak nikt nie wyobraża sobie nie zrobić matury albo nie złożyć egzaminu magisterskiego. Tym niemniej Matol poczynił ciekawą uwagę i odniosę się do niej w innym wpisie.

Wracając do pytań testowych – oczywiście uczenie się odpowiedzi na pamięć nie ma najmniejszego sensu. Ale wykonywanie testów i sprawdzanie swoich odpowiedzi pozwala szybko zidentyfikować te obszary, w których nasza wiedza wymaga ulepszenia.

Ten model nauki sprawdził się w moim przypadku. Nie korzystałem z dumpów i nie mogę się pochwalić wynikiem 1000/1000, ale z powodzeniem zdałem egzamin. Oczywiście z powodu NDA nie mogę ujawniać treści egzaminu, ale zaskoczyła mnie minimalna liczba pytań dotycząca LINQ. Pozostałe proporcje były „w normie”.

Kilka podstawowych informacji dla osób, które jeszcze nie zdawały: egzamin pisze się w centrum szkoleniowym, które może organizować certyfikację Microsoft (aktualna lista ośrodków) za pomocą programu testującego na komputerze. Wynik zna się od razu po egzaminie. Do zaliczenia potrzeba 700 punktów na 1000 możliwych.

70-562 – zdałem i co dalej?

Jeśli planujesz przystąpić do egzaminu 70-562 raczej wątpię, że Twój wybór jest przypadkowy. Egzamin ten jest zwykle wybierany jako drugi, po zdaniu 70-536 (przeczytaj, jak przygotować się do egzaminu 70-536). Zdanie dwóch tych dwóch egzaminów skutkuje przyznaniem certyfikatu: Microsoft Certfified Technology Specialist  – .NET Framework 3.5, ASP.NET Application. Jeśli zdałeś te dwa egzaminy to jesteś wśród 59 osób w Polsce (dane na 8 grudnia 2009 – możesz zajrzeć do oficjalnej statystyki). Brzmi nieźle, prawda?

Jeśli chcesz uzyskać wyższy poziom certyfikacji  – Microsoft Professional Developer (MPD) w dziedzinie ASP.NET na platformie .NET 3.5 i znaleźć się wśród 20 osób w Polsce posiadających ten certyfikat, będziesz zainteresowany zdaniem egzaminu 70-564: Pro: Designing and Developing ASP.NET Applications Using the Microsoft .NET Framework 3.5.

Podsumowanie

Na koniec krótkie podsumowanie:

1. Egzamin 70-562 jest dla programistów ASP.NE T z kilkuletnim doświadczeniem.
2. Istnieje sporo materiałów do nauki do egzaminu, w tym książka z MS-Press typu Self-Paced.
3. Przydatne jest wykonywanie opisywanych ćwiczeń (pisanie kodu), tak żeby zaznajomić się z treścią w sposób praktyczny.
4. Pomocne jest rozwiązywanie przykładowych testów i wyciąganie wniosków ze swoich błędnych odpowiedzi.
5. Zdanie dwóch egzaminów 70-536 i 70-562 skutkuje uzyskaniem certyfikatu Microsoft Certified Specialist.

Powodzenia!

Ten wpis nie będzie o tworzeniu web partów – chcę skupić się na pewnym małym wycinku tematu – mianowicie na tworzeniu połączeń między web partami.

Po co łączyć web parts

Przypuśćmy, że tworzysz aplikację webową, która wyświetla szczegóły na temat europejskich miast. Chciałbyś zorganizować te stroną w taki sposób, żeby korzystała z web parts. W ten sposób umożliwiłbyś użytkownikowi samodzielne zarządzanie wyglądem strony. Załóżmy, że w jednym web parcie użytkownik będzie wpisywał (bądź wybierał z listy) nazwę miasta. W innych web partach pojawią się wówczas informacje takie jak:

• liczba ludności miasta,
• slideshow ze zdjęciami z miasta,
• aktualna prognoza pogody, itd.

Aby uzyskać opisaną funkcjonalność, jako programista, musisz ustalić połączenie między web partami. Można to zrobić na dwa sposoby – 1) ustalić statyczne połączenie lub 2) umożliwić użytkownikom tworzenie dynamicznych powiązań. Omówię pierwszy z nich.

Statyczne powiązanie web partów

Statyczne powiązanie polega na wskazaniu jednego web parta jako dostawcy (provider) i jednego bądź więcej odbiorców (consumer).

Uwaga: dla ułatwienia jako web partów będziemy używać własnych kontrolek (user controls).

Stworzenie dostawcy polega na dodaniu do gotowej kontrolki metody, która będzie zwracała pewną wartość. W naszym przykładzie chcemy, aby była to nazwa miasta pochodząca z rozwijalnej listy. Oto, jak mógłby wyglądać przykładowy kod takiej kontrolki:

public partial class CityChooser : System.Web.UI.UserControl
{

    string _cityName = CityData.GetData().First().Name;

    [ConnectionProvider("My web parts connection", "GetCityName")]
    public string GetCityName()
    {
        return _cityName;
    }

    protected void Page_Load(object sender, EventArgs e)
    {
        if (IsPostBack)
        {
            string userCity = DropDownList1.SelectedValue;
            _cityName = CityData.GetData().First(city => city.Name == userCity).Name;
        }

    }
}

Obiekt CityData zawiera po prostu listę miast w postaci struktur zawierających wszystkie potrzebne dane (np. pole Name czy Population). Dokładny wygląd tej klasy nie jest w tej chwili istotny. Najistotniejsza jest metoda:

[ConnectionProvider("My web parts connection")]
public string GetCityName()
{
    return _cityName;
}

Metoda ta (ważne – publiczna!) zwraca po prostu nazwę miasta wybranego z listy rozwijalnej. Atrybut ConnectionProvider określa, że jest to nasz dostawca danych dla innych web partów (konsumentów). Tu używamy z jednym parametrem (”przyjazną” nazwą połączenia), ale jest też przeciążona wersja z dwoma typu string. Wówczas pierwszy określa “przyjazną” nazwę naszego połączenia, a drugi definiuje unikalną nazwę naszego punktu połączenia. Można pominąć drugi parametr – wówczas nasz punkt będzie się nazywał default (oczywiście, gdybyśmy chcieli zdefiniować drugi ConnectionProvider, to wówczas trzeba już użyć drugiego parametru – nazwa default byłaby już zajęta).

Mamy zatem zdefiniowanego dostawcę naszych danych. Czas na konsumentów.

Stworzenie konsumenta polega na dodaniu do kontrolki będącej web partem metody (znów publicznej), która będzie przyjmować parametr – tego samego typu, jaki jest zwracany przez naszą metodę-dostawcę. Metodą tą należy opatrzyć atrybutem ConnectionConsumer. Całość mogłaby wyglądać następująco:

public partial class PopulationDisplayer : System.Web.UI.UserControl
{
    [ConnectionConsumer("My consumer")]
    public void ShowPopulation(string city)
    {
        lblCityPop.Text = CityData.GetData().First(c => c.Name == city).Population.ToString();
    }
}

I znów najważniejszy jest atrybut ConnectionConsumer. Parametry mają takie samo znaczenie jak w poprzednim przypadku.

Teraz, gdy mamy już zdefiniowanego dostawcę i co najmniej jednego odbiorcę, możemy ustalić połączenie. W tym celu musimy stworzyć stronę, na której będą działać nasze web party. Dodajemy oczywiście kontrolkę WebPartManager oraz WebPartZone, w której w ZoneTemplate umieszczamy nasze web party. Kod kontrolki WebPartZone może wyglądać następująco:

<asp:WebPartZone ID="WebPartZone3" runat="server" Style="width: 650px; height: auto;">
    <ZoneTemplate>
        <uc2:CityChooser ID="Provider" runat="server" />
        <uc3:PopulationDisplayer ID="Consumer" runat="server" />
    </ZoneTemplate>
</asp:WebPartZone>

Samo powiązanie definiujemy natomiast w kontrolce WebPartManager w części StaticConnections:

<asp:WebPartManager ID="WebPartManager1" runat="server">
    <StaticConnections>
        <asp:WebPartConnection
            ID="CityToPopulation"
            ProviderID="Provider"
            ConsumerID="Consumer">
        </asp:WebPartConnection>
    </StaticConnections>
</asp:WebPartManager>

I tak oto, gdy w jednym web parcie z listy wybierzemy miasto, to w drugim zobaczymy liczbę ludności tego miasta:

Powiązanie Web Parts

Gdybyśmy w atrybutach definiujących naszego dostawcę i konsumenta podali unikalne nazwy dla naszych punktów, np:

[ConnectionProvider("My web parts connection", "ProvideData")]

[ConnectionConsumer("My consumer", "ConsumeData")]

wówczas kod kontrolki WebPartManager wyglądałby nieco inaczej:

    <asp:WebPartManager ID="WebPartManager1" runat="server">
        <StaticConnections>
            <asp:WebPartConnection
            ID="CityToPopulation"
            ProviderID="Provider"
            ProviderConnectionPointID="ProvideData"
            ConsumerID="Consumer"
            ConsumerConnectionPointID="ConsumeData">
            </asp:WebPartConnection>
        </StaticConnections>
    </asp:WebPartManager>

Musielibyśmy wówczas określić, że chodzi nam o konkretne metody za pomocą właściwości: ProviderConnectionPointID i ConsumerConnectionPointID.

Gdybyśmy chcieli użyć większej ilości konsumentów, musielibyśmy zdefiniować odpowiednie WebPartConnection dla każdej pary web partów.

W taki sposób można łatwo definiować statyczne połączenia. O tym, jak umożliwić użytkownikom strony tworzenie dynamicznych połączeń, będzie następny (krótki) wpis.

Tym razem załączam kod źródłowy przykładowego rozwiązania – wersja dla Visual Studio 2008. Żeby korzystać z web partów, trzeba mieć SQL Server wersję Express, ponieważ web parts korzystają z bazy danych (App_Data/ASPNETDB.MDF), żeby zapamiętywać preferencje użytkownika. Paczka z kodem nie zawiera tego pliku – trzeba go sobie stworzyć samemu (np. przy pomocy narzędzia ASP.NET Configuration).

WebParts static connections – kod C# (6,29 KB)

Polecam także stronę ze zdjęciami ze spotkania. Fotografie są wyświetlane za pomocą rewelacyjnego programu – Photosynth – opracowanego w Microsoft Live Labs.

Problem przedstawia się zatem następująco: mając zadaną tablicę ze stringami (lista wszystkich możliwych sugestii), dla określonego prefiksu (ciągu znaków), podać listę tych stringów z tablicy wejściowej, które rozpoczynają się od prefiksu.

Trywialne rozwiązanie:

//dane wejściowe
String[] input = strings.ToArray();

//prefiks, dla którego szukamy podzbioru
String prefix = "ab";

String[] subset = Array.FindAll<String>(
    input,
    new Predicate<string>(s => s.StartsWith(prefix))
    );

ma jedną zaletę – zajmuje mało kodu. Niestety poza tym ma same wady:

1. Czas ustalenia interesującego nas podzbioru zależy liniowo od wielkości danych wejściowych (liczby stringów w tablicy). Przy, powiedzmy, 50 tysiącach stringów użytkownik zauważalnie długo czeka na podpowiedź.
2. Łatwo zauważyć, że dla każdej kolejnej wpisanej litery prefiksu, zawężamy wynik poszukiwań – dla n-tej litery prefiksu wynikiem jest podzbiór uzyskany w poprzednim kroku, dla n-1 litery. Trywialna metoda nie korzysta jednak z tej obserwacji i dla każdej litery proces poszukiwania zaczynany jest na nowo.

Z pomocą przychodzą drzewa trie (czyt. traj). Trie jest drzewem poszukiwań, którego wierzchołki są oznaczone kolejnymi prefiksami słów z listy. Prócz prefiksu wierzchołek zawiera informacje o słowach z listy, które “pasują” do tego prefiksu. Oczywiście w celach optymalizacji, w drzewie nie są przechowywane same podzbiory wyjściowego zbioru, tylko indeks początkowy i końcowy danego podzbioru.

Przykład:

Trie - przykład

Powyższe drzewo trie zawiera dane o prefiksach dla następującej listy słów:

• AR
• AS
• B
• DO
• ELA
• ELF
• EM

Żeby otrzymać informację o podzbiorze stringów zaczynających się od prefiksu “EL” należy przejść od korzenia przez węzeł “E” aż do węzła “L” – otrzymujemy indeksy 4-5, czyli słowa “ELA” i “ELF”. Warto zauważyć, że koszt wyszukania interesującego nas podzbioru nie zależy teraz od wielkości danych wejściowych.

Zanim przystąpimy do napisania funkcji budującej drzewo, zdefiniujmy najpierw dane pomocnicze: strukturę Prefix, i klasę TreeNode<T>.

Prefix:

public struct Prefix
{
    int _start;
    public int Start
    {
        get { return _start; }
        set { _start = value; }
    }

    int _end;
    public int End
    {
        get { return _end; }
        set { _end = value; }
    }

    char _letter;
    public char Letter
    {
        get { return _letter; }
        set { _letter = value; }
    }

    public Prefix(int start, int end, char letter)
    {
        _start = start;
        _end = end;
        _letter = letter;
    }
}

TreeNode:

public class TreeNode<T>
{
    private TreeNode _parent = null;
    protected List<TreeNode> _children = new List<TreeNode>();
    private T _value;

    public void AddChild(TreeNode child)
    {
        if (!_children.Contains(child))
        {
            _children.Add(child);
            child._parent = this;
        }
    }

    public TreeNode Parent
    {
        get { return _parent; }
        set { _parent = value; }
    }

    public TreeNode(T value)
    {
        this._value = value;
    }

    public TreeNode(T value, TreeNode[] children)
    {
        new TreeNode(value);
        _children = new List<TreeNode>(children);
    }

    public T Value
    {
        get { return _value; }
        set { _value = value; }
    }

    public List<TreeNode> Children
    {
        get { return _children; }
    }
}

Powyższa klasa jest bardzo prostą implementacją węzła drzewa przechowującego zadany typ danych o zbiorze synów trzymanych za pomocą listy generycznej.

Mając tak zdefiniowane klasy pomocnicze, możemy napisać rekurencyjną metodę tworzącą drzewo trie:

public class Trie
{
    private String[] _input;
    private TreeNode<Prefix> _tree;
    private char[] _availableChars;

    private void MakeNode(TreeNode<Prefix> root, int indexOfString)
    {
        int wordIndex = root.Value.Start;
        int lastIndex = wordIndex;
        bool nodeStarted = false;
        char character = '';
        char prevChar = character;
        while (wordIndex <= root.Value.End)
        {
            String s = _input[wordIndex];
            prevChar = character;
            if (indexOfString < s.Length)
            {
                if (s[indexOfString] != character)
                {
                    character = s[indexOfString];
                    if (nodeStarted)
                    {
                        Prefix newPair = new Prefix(lastIndex, wordIndex - 1, prevChar);
                        lastIndex = wordIndex;
                        TreeNode<Prefix> newNode = new TreeNode<Prefix>(newPair);
                        root.AddChild(newNode);
                        nodeStarted = false;
                    }
                }
                else
                {
                    nodeStarted = true;
                    wordIndex++;
                }
            }
            else
            {
                wordIndex++;
            }
        }
        if (nodeStarted)
        {
            root.AddChild(new TreeNode<Prefix>(new Prefix(lastIndex, root.Value.End, character)));
        }
        foreach (TreeNode<Prefix> child in root.Children)
        {
            MakeNode(child, indexOfString + 1);
        }
    }

    public Trie(String[] input)
    {
        _input = input;
        _tree = new TreeNode<Prefix>(new Prefix(0, _input.Length - 1, ''));
        MakeNode(_tree, 0);
    }
}

Kluczowa jest metoda MakeNode, która w sposób rekurencyjny tworzy listę synów dla istniejących wierzchołków drzewa trie, w oparciu o drugi parametr, który określa indeks bieżącej litery w szukanych stringach.

Mając utworzone drzewo trie dla danego zbioru stringów, możemy wywoływać następującą metodę z klasy Trie:

        public String[] GetStringsForPrefix(string prefix)
        {
            TreeNode<Prefix> current = _tree;
            for (int i = 0; i < prefix.Length; i++)
            {
                current = current.Children.Find(new Predicate<TreeNode<Prefix>>(t => t.Value.Letter == prefix[i]));
                if (current == null)
                {
                    return null;
                }
            }
            int length = current.Value.End - current.Value.Start + 1;
            string[] result = new string[length];
            Array.Copy(_input, current.Value.Start, result, 0, length);
            return result;
        }

która zwróci nam interesujący nas podzbiór stringów. W ten sposób mamy rozwiązanie początkowego problemu.

Powyższa implementacja struktury danych trie z całą pewnością może być bardziej optymalna – chciałem jednak zachować czytelność kodu i zaprezentować ogólną ideę tworzenia drzewa trie, a nie skupiać się na optymalizacji.

Wadą drzew trie jest ich stosunkowo duży rozmiar w pamięci (jak duży? od czego zależy? czy można go zmniejszyć?). Można to poprawić stosując tzw. drzewa Patricia, czyli wariant drzew trie, w których zamiast liter do etykietowania krawędzi (w naszej implementacji: węzłów), stosujemy całe stringi. Takie skompresowane drzewo trie tworzy się przez usuwanie węzłów mających tylko jednego syna i modyfikację drzewa, tak aby skrócić ścieżkę poszukiwań.

Drzewa trie nie są jedynym sposobem na szybkie rozwiązanie opisanego na wstępie problemu, ale warto wiedzieć o ich istnieniu i umieć je zaimplementować. W szczególności dlatego, że w pewnych okolicznościach są wydajniejsze niż drzewa BST.

Steve przybył prawie punktualnie – nie licząc kwadransa akademickiego. Kiedy wchodził na salę miał na sobie czerwono-biały szalik z napisem “Polska”, który dostał od kogoś w Polsce i obiecał powiesić sobie w gabinecie.

Spotkanie zaczęło się od 15-minutowego przemówienia. Właściwie ta prelekcja bardziej przypominała show – Steve poruszał się na scenie oświetlony reflektorami – nie miał żadnych notatek ani pulpitu, nie prezentował żadnych slajdów.

W swoim wystąpieniu Steve poruszył kwestię kryzysu ekonomicznego i jego wpływu na techonologię. Zdaniem prezesa Microsoftu, właśnie teraz – podczas kryzysu – jest czas na inwestowanie w nowe rozwiązania i nowe technologie, które zaprocentują, gdy sytuacja gospodarcza poprawi się.

Ballmer powiedział także, że Microsoft  jest zdecydowany wydać w najbliższym czasie ok. 9 miliardów dolarów na badania i rozwój. Oznacza to 45000 etatów.

W jakich obszarach technologia będzie się rozwijać najbardziej prężnie? Wg CEO Microsoftu głównie w zakresie poprawiania interakcji między użytkownikiem a komputerem: zaawansowane rozpoznawanie mowy czy gestów. Steve wyraził także niezadowolenie ze sposobu w jaki, w dzisiejszych czasach działają wyszukiwarki (tu pozwolił sobie na drobne żarty z konkurencyjnego Google). Przytaczał statystyki, z których wynika, że około połowa poszukiwań konkretnych treści kończy się fiaskiem oraz że przeciętne zapytanie składa się z 2,2 słowa. Powiedział także:

Im więcej informacji dajesz wyszukiwarce, tym mniej zadowalających wyników otrzymujesz. Silnik nie radzi sobie z dużymi liczbami słów w zapytaniu. Gdy rozmawiasz z prawdziwym człowiekiem, jest zupełnie odwrotnie – im więcej informacji dostarczysz, tym lepszą odpowiedź dostaniesz.

Po tym krótkim wystąpieniu nadszedł czas na sesję pytań i odpowiedzi. Pytania dotyczyły najróżniejszych tematów, ale postaram się przytoczyć te najciekawsze:

Gdybyś miał opisać firmę Microsoft za pomocą jednego słowa, jakiego słowa byś użył?

Steve chwilę zastanawiał się, pytając z niedowierzaniem “one word? one word???”, kiedy nagle ktoś z sali krzyknął “awesome!”. Steve podchwycił i powiedział, że gdyby miał do dyspozycji dwa słowa powiedziałby:

Awesome, baby!

Poważna odpowiedź na pytanie brzmiała natomiast:

Popular innovation

Steve wyjaśnił, że Microsoft jest firmą, która dba o innowacje i wdraża nowe rozwiązania, ale jej celem jest poruszenie masowego odbiorcy – wpłynięcie na jak największą liczbę ludzi. Jako kontrprzykład podał firmę Apple – która wg niego jest innowacyjna, ale nie trafia do mas.

Inne pytanie, dotyczyło patentów. Steve wyraził pogląd, że patenty – jeśli reprezentują prawdziwą wartość – mają sens i popiera je. Skrytykował natomiast rozwiązania prawne zarówno w Stanach jak i w Unii, ponieważ według niego pozwalają na zgłaszanie bezsensownych patentów, za którymi nie kryje się żadna wartość.

Zapytany czy statystyki pokazujące, że większość specjalistów IT nie zmigruje do Windows 7 w pierwszym roku po jego wydaniu spowodują opóźnienie wydania nowego systemu, Steve powiedział, że jest to wręcz powód, dla którego Microsoft powinien przyspieszyć datę wydania siódemki. Wyraził także przekonanie, że ci sami specjaliści, którzy podejmą decyzję o pozostaniu przy XP czy Viście w firmach, w swoich domach na pewno bardzo szybko zainstalują nowy Windows.

Spotkanie szybko dobiegło końca, ale pozostawiło bardzo przyjemne wrażenie. Chyba głównie z powodu bezpośredniego, bezpretensjonalnego i bardzo energicznego stylu bycia Steve’a. Podczas całego spotkania utrzymywał żywy kontakt z publicznością, często żartował, swobodnie poruszał się po całej scenie, gestykulował. Bardzo dobrze się go słuchało.

Jedyną wadą spotkania było to, że trwało tylko jakieś 40 minut. No i Steve tym razem nie wykonał popisowego monkey dance…

Od kilku miesięcy w Bydgoszczy działa lokalna grupa offline wspierana przez Microsoft - Bydgoska Grupa Developerów .NET. Jaki jest cel istnienia grupy?

W Internecie istnieje mnóstwo online’owych społeczności związanych z programowaniem w .NET – można choćby wymienić prężnie działający portal codeguru.pl. Nie wszystkie jednak wydarzenia mogą mieć miejsce w przestrzeni wirtualnej – na forach, blogach czy portalach. Programiści, którzy lubią swoją pracę mają potrzebę wymiany poglądów, uczenia się czegoś nowego, a chyba nie ma ku temu lepszej okazji niż spotkanie w realu. Dlatego właśnie w całej Polsce tworzone są lokalne grupy offline (w tej chwili jest ich ponad 20 i ciągle powstają następne).

BGD.NET organizuje spotkania (mniej więcej raz w miesiącu), na których prelegenci – profesjonalni programiści i specjaliści IT – prezentują wybrane zagadnienia związane z platformą .NET, programowaniem, bazami danych czy nowinkami w świecie programowania. Liczymy na to, że na spotkaniach po prezentacji wywiążą się ciekawe, owocne dyskusje.

Poza tym spotkania grup stanowią świetną okazję do poznania ludzi z innych firm w mieście, do zorientowania się czym zajmują się inni programiści czy jakie ciekawe projekty są rozwijane w regionie.

Zwykle grupy offline dysponują darmowymi pomocami technicznymi w formie elektronicznych prezentacji, podręczników czy przykładowych projektów. Dostępne są też książki (najczęściej wydane przez Microsoft Press), które można wypożyczyć.

Warto też dodać, że grupy zostały ostatnio objęte patronatem czasopisma NEXT.

Najbliższe spotkanie grupy bydgoskiej już 18 lutego. Prezentację poprowadzą Paweł Gliwiński i Marek Graczykowski – programiści zajmujący się IPTV. Tematyka będzie dotyczyć wzorców projektowych w języku C#. Może się wydawać, że o wzorcach projektowych powiedziano już wszystko, a jednak dla niektórych programistów ich właściwe używanie stanowi niemałą zagadkę. Prelegenci postarają się ją rozwiązać i zaprezentują praktyczne zastosowanie niektórych wzorców z przykładowymi scenariuszami użycia.

Zachęcam do założenia konta w portalu ms-groups.pl, a potem do rejestracji na 3. spotkanie BGD.NET.

A co jeśli bezkresne szczęście wynikające z mieszkania w Bydgoszczy nie jest Twoim udziałem? :> Sprawdź, czy w Twoim mieście działa grupa offline – portal ms-groups.pl.

Ponieważ na co dzień zajmuję się technologiami „okołodotnetowymi” – głównie pisaniem aplikacji webowych przy użyciu frameworka 2.0, postanowiłem podejść do egzaminu Microsoftu o łatwo zapamiętywalnym tytule 70-536 – TS: Microsoft .NET Framework – Application Development Foundation.

Tytuł egzaminu świetnie oddaje szeroki zakres obejmowany zagadnień. 70-536 sprawdza praktyczną i teoretyczną wiedzę dotycząca .NET 2.0. Obejmuje wszystkie dziedziny programowania poczynając od typów danych, operacje I/0 przez szyfrowanie danych i bezpieczeństwo kodu aż po globalizację i biblioteki do rysowania. Tematyka jest zatem rozległa, ale jednocześnie dość spójna.

Podczas przygotowywania się do egzaminu korzystałem głównie z książki z rodzaju self-paced (MCTS Self-Paced Training Kit (Exam 70-536): Microsoft® .NET Framework 2.0 Foundation). Rozdział po rozdziale omawia ona większość zagadnień dotyczących frameworka. Materiał jest dobrze podzielony pod względem logicznym, każdy rozdział zawiera kilka lekcji, które z kolei kończą się podsumowaniem i kilkoma pytaniami testowymi. Informacje jednak są podane w sposób niemal encyklopedyczny – nie jest to książka, w której autor „zaprzyjaźnia się” z czytelnikiem (natknąłem się jednak na jeden żarcik w rozdziale o serializacji: „Teleportation in science-fiction is a good example of serialization (though teleportation is not currently supported in .NET Framework)”.

Pomimo sporej objętości książka nie jest pełnym przewodnikiem po programowaniu w .NET, dlatego podczas przygotowań korzystałem także z biblioteki MSDN.

Poza tym książka niestety zawiera sporo błędów – przeglądając erratę trudno oprzeć się wrażeniu, że aż roi się od błędów. W rzeczywistości nie jest tak źle, a większość błędów można bez trudu wykryć samemu. Jest to jednak odrobinę drażniące.

Podczas przygotowań starałem się pisać testowe aplikacje opisane w labach po każdej lekcji. Myślę, że taki sposób interaktywnej nauki jest najefektywniejszy. W ten sposób szybciej zapamiętuje się kolejność wykonywania kroków dla pewnych specyficznych zadań (np. szyfrowanie pliku kluczem asymetrycznym czy wywołanie zapytania przez Windows API) oraz nazwy i sygnatury metod i konstruktorów

Do Training Kita dołączona jest płytka z przykładowymi testowymi pytaniami (w sumie ponad 300 pytań ze wszystkich kategorii). Na kilka dni przed egzaminem skupiłem się prawie wyłącznie na rozwiązywaniu zestawu testów. Przyzwyczaja to do formy pytań i uczy szukania odpowiedzi w jak najprostszy sposób (np. szybkie porównywanie odpowiedzi w celu wyeliminowania oczywistych błędnych). Z drugiej jednak strony po pewnym czasie większość pytań znałem na pamięć i w zasadzie nie czytałem ich treści. Jak można się domyśleć, nie miałem problemów, żeby zaliczyć każdy zestaw testowy.

Czas przygotowań upłynął szybko (słynne wrażenie jednego brakującego dnia) i nadszedł dzień egzaminu. Zdawałem w ośrodku szkoleniowym Softronic w Poznaniu. Miejsce niczym niewyróżniające się, nie zaskoczyło ani pozytywnie ani negatywnie. Chwilowym problemem była grupa młodych kobiet (złośliwi twierdzą, że grupy młodych kobiet zawsze stanowią problem dla programistów). Dziewczyny miały przerwę w szkoleniu i dość głośno wymieniały uwagi. Ten konkretny problem został rozwiązany, ale uważam, że w centrum szkoleniowym sale egzaminacyjne powinny być lepiej odseparowane od deskupiających dźwięków z zewnątrz.

Niestety, nie mogę napisać zbyt wiele na temat samego egzaminu, ponieważ każdy przystępujący podpisuję umowę NDA (Non-Disclosure Agreement). Mogę jedynie stwierdzić, że egzamin był trochę trudniejszy niż się spodziewałem, ale te godziny spędzone na przygotowaniach robią swoje i nawet jeśli nie byłem w stu procentach pewien odpowiedzi, to wyrobiona intuicja podpowiadała najbardziej prawdopodobne rozwiązania.
Intuicja mnie nie zawiodła – udało mi się zdać egzamin na 858 punktów (zaliczenie od 700) i uzyskałem tytuł MCP (Microsoft Certified Professional)!

Następnym krokiem będzie zdanie egzaminu 70-528: Web-based Client Development i, jeśli dobrze pójdzie, uzyskam tytuł MCTS (Microsoft Certified Technology Specialist).

Jeśli miałbym podsumować ten egzamin, to wydaje mi się, że najtrudniej jest postanowić, że się przystępuje do egzaminu. Bo kiedy ustali już się termin, to nie innego wyjścia – trzeba się nauczyć i zdać. Wszystkim przystępującym do egzaminu życzę powodzenia!

Halo, halo czy to działa?
Start.