czwartek, 8 listopada 2012

Prezent od Microsoft - Darmowa książka o programowaniu w Windows 8

Microsoft konsekwentnie kontynuuje taktykę ściągania nie .NETowych programistów - udostępnił darmową książkę w ramach Microsoft Press: "Programming Windows 8 Apps with HTML, CSS, and JavaScript". Jest ona dostępna pod adresem:
http://blogs.msdn.com/b/microsoft_press/archive/2012/10/29/free-ebook-programming-windows-8-apps-with-html-css-and-javascript.aspx
Nie do końca jestem przekonany do tego, że HTML5, JavaScript i CSS jest tym kierunkiem, w którym powinny podążać systemy operacyjne. Wg mnie te technologie są chaotyczne, mają pełno złych zaszłości historycznych i są ciężkie w utrzymaniu. (Nie)stety nie tylko Microsoft podąża w tą stronę - Apple, Google również mocno w nią idą. 
A wy co o tym wszystkim sądzicie?

wtorek, 30 października 2012

Serializacja dla .NET 4.5 oraz Windows Runtime przy pomocy Sharpserializer

Trochę mnie nie było, dawno już nie pisałem - ten post będzie dla mnie nietypowy - krótki. Mam nadzieję, że to będzie jego zaleta.
W swoim projekcie-po-godzinach do serializacji danych używam biblioteki SharpSerializer. Projekt ma środowiska klienckie napisane w Silverlight i Windows Phone. Nie ma w nich klasy BinaryFormatter przez co bez stosowania zewnętrznych bibliotek trzeba by stosować sztuczki z serializacją poprzez mechanizm DataContract z WCF (więcej szczegółów na blogu Damona Payne'a). Nie jest to zbyt wygodne wg mnie.
SharpSerializer pozwala w prosty, wygodny i efektywny sposób serializować dane do postaci binarnej. 
Dlaczego tak nagle o tym piszę? W tym tygodniu zacząłem przenosić kod projektu na .NET 4.5 i Windows Runtime. Niestety nie zostały do tej pory wypuszczone wersje na te środowiska.
Na szczęście ze strony można ściągnąć kody źródłowe.
Pobrałem je, przekonwertowałem, poprawiłem część rzeczy, przekompilowałem i okazało się, że wszystko wygląda jakby działało.
Efekt moich prac możecie pobrać: tutaj (src + dll).
Więcej informacji na temat SharpSerializer pod linkami:
- http://www.sharpserializer.com/en/tutorial/index.html
- http://www.codeproject.com/Articles/76530/XML-Serialization-of-Generic-Dictionary-Multidimen
- http://www.codeproject.com/Articles/240621/How-to-serialize-data-effectively-Custom-serializa
- http://www.codeproject.com/Articles/116020/Binary-Serialization-to-Isolated-Storage-in-Silver
Zachęcam do zabawy z SharpSerializerem, naprawdę dobra biblioteka.

niedziela, 15 kwietnia 2012

Jak z kilku dllek zrobić jedną, czyli modularność przy pomocy ILMerge

Wstęp

Pracuję aktualnie nad strukturą pewnego projektu. Ideą, która przyświeca przy jej tworzeniu jest to, żeby była jak najbardziej modularna - tak by składała się z niezależnych, niepowiązanych ze sobą podaplikacji. 
Aby lepiej przybliżyć problem przyjrzyjmy się przykładowi:

Rysunek 1 - Przykładowa struktura
Przyjmijmy, że chcemy stworzyć moduł zarządzania użytkownikami, który będziemy używać w kilku tworzonych przez nas aplikacjach. Nie chcemy, bowiem za każdym razem wynajdywać koła od początku.  Moduł ten składać się będzie z podmodułów odpowiadających za rejestrację, logowanie, uprawnienia. 
Standardowo do każdego z tych "klocków" utworzylibyśmy osobny projekt, chcąc dodać do naszych aplikacji musielibyśmy wrzucić 4 osobne dllki:
- główną - Modułu Zarządzania Użytkownikami
- 3 zależne - Moduł Rejestracji, Moduł Logowania, Moduł Uprawnień
Dorzucenie 4 dllek nie wydaje się chyba wielkim problemem, prawda? 

Pójdźmy jednak dalej. Załóżmy, że nasza firma zajmuje się tworzeniem stron internetowych. Mamy kilka "żyjących" i rozwijanych stron. Każdą z nich zajmuje się osobny zespół programistów, mamy również dział geeków, którzy zajmuje się core'em. Nasi klienci stwierdzili, że chcieliby mieć możliwość logowania się i rejestracji przy pomocy otwartych systemów uwierzytelniania jak OpenID, Google, Facebook. Zespół naszych geeków czym prędzej zaczyna się tym zajmować i na koniec generuje następującą strukturę:

Rysunek 2 - Rozszerzona struktura

Przy uaktualnianiu Modułu Zarządzania Użytkownikami musimy pamiętać, że musimy dodać kolejne dziewięć dllek dla każdego z podmodułów. W sumie mamy trzynaście dllek, może i pechowa liczba, ale to dalej nie jest krytyczny problem, czyż nie? Krytycznie jednak zaczyna się robić, gdy mamy kilka używanych w wielu miejscach modułów, z których każdy składa się z podmodułów. Gdy jeszcze trzymamy się zasadom luźno powiązanych klas, inversion of control i korzystamy z kontenerów dependency injection to sytuacja robi się jeszcze bardziej problematyczna, a zapomnienie dorzucenia dllki łatwiejsze i bardziej problematyczne.

Dużym uproszczeniem byłaby sytuacja gdy każdy moduł jest osobną dllką. Dzięki temu programiści, którzy z niego korzystają nie muszą się zastanawiać z czego on dokładnie się składa, musiał by tylko wiedzieć jak się go używa. 

Co to jest ILMerge?

ILMerge jest narzędziem dostarczonym przez Microsoft, pozwalającym na łączenie kilku asemblatów w jeden (stąd jego nazwa - łączenie ILa). Radzi on sobie bez większych problemów również z łączeniem plików .pdb umożliwiając tym samym debugowanie. Dostarczany jest w postaci pliku EXE (można go pobrać pod linkiem), który uruchomiony z odpowiednimi parametrami pozwala nam na złączenie asemblatów. Przykładowe jego wywołanie to:

ilmerge /target:winexe /out:myprogram.exe yourexe.exe yourlibrary.dll

Gdzie:
- ilmerge - nazwa pliku ilmerge'a 
- /target - parametr mówiący czy nasz asemblat ma być plikiem exe (winexe) cz dllką (module
- /out: - parametr mówiący o nazwie wynikowego pliku, podajemy też asemblaty, które chcemy złączyć


Jak to zobaczyłem to stwierdziłem, że bardzo to fajne, tylko że wywoływanie za każdym razem polecenia z linii komend. Na szczęście znalazłem świetny artykuł Scotta Hanselmana jak można ten proces zautomatyzować.


Automatyczne wywołanie ILMerge


MSBuild pozwala na zdefiniowanie akcji, które będą wykonywane po procesie zbudowania projektu (tzw. Post build actions). Możemy zatem zdefiniować akcję, która będzie polegała na wywołaniu ILMerge'a z odpowiednimi parametrami dla wybranych przez nas projektów. Jak tego dokonać? Ponieważ pliki projektów są zarazem plikami MSBuilda możemy je odpowiednio zmodyfikować.
Zacznijmy od utworzenia nowej solucji i struktury projektów. Niech wygląda ona następująco:

Rysunek 3 - przykładowa struktura projektów

Odpowiada ona przykładowej strukturze projektów przedstawionej wcześniej. Mamy projekt ILMergeSample.UserManagementModule, który ma referencję do trzech podmodułów. Zbudujmy teraz nasz solucję i przejdźmy do katalogu Debug dla naszego projektu modułu obsługi pracowników.

Rysunek 4 - Wynik standardowego builda

Zgodnie z przewidywaniami standardowo skopiował dllki podmodułów. Przejdźmy więc do sedna artyukułu i zacznijmy łączyć je w jedną. Rozpocznijmy od skopiowania pliku ILMerge.exe do struktury naszej solucji (domyślnie znajduje się w "C:\Program Files (x86)\Microsoft\ILMerge"). Pozwoli nam to uniezależnić od tego czy inny developer ma go na swoim komputerze i pod jaką ścieżką się u niego znajduje.
Dodajmy również plik o nazwie "Ilmerge.CSharp.targets".
Nasza struktura solucji powinna wyglądać teraz następująco:


Rysunek 5 - Struktura projektu po dodaniu ILMerge'a


Otwórzmy teraz plik "Ilmerge.CSharp.targets" i wklejmy do niego następujące dane:
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">  
<Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />   
 <Target Name="AfterBuild">     
 <CreateItem Include="@(ReferencePath)" Condition="'%(CopyLocal)'=='true' and '%(ReferencePath.IlMerge)'=='true'">
    
 
 <Message Text="MERGING: @(IlmergeAssemblies->'%(Filename)')" Importance="High" /> 
 
 <Exec Command="&quot;$(SolutionDir)\Ilmerge.exe&quot;
    /targetplatform:v4,&quot;%ProgramFiles%\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0&quot; 
    /out:@(MainAssembly) &quot;@(IntermediateAssembly)&quot; @(IlmergeAssemblies->'&quot;%(FullPath)&quot;', ' ')" /> 
 </Target> 
 
 <Target Name="_CopyFilesMarkedCopyLocal"/>     
</Project>

Co to tak naprawdę robi? Prześledźmy to po kolei:
- Project DefaultTargets="Build" - określamy tutaj, że definiujemy akcję dla builda
- Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" - importujemy tutaj domyślne ustawienia builda, nie chcemy bowiem wszystko definiować od początku, tylko nadpisać część ustawień
- CreateItem Include="@(ReferencePath)" Condition="'%(CopyLocal)'=='true' and '%(ReferencePath.IlMerge)'=='true'" - dzięki temu warunkowi wybieramy do złączenia te asemblaty, które są dołączone do naszego projektu i mają zaznaczoną opcję "Copy Local" oraz "ILMerge" na true
- Message Text - tutaj definiujemy wiadomość, która będzie informowała nas w outputcie o tym, że dokonujemy złączenia asemblatów w trakcie budowania projektu
- Exec Command - tutaj definiujemy odpowiednie wywołanie ILMerge'a. Moja konfiguracja jest specyficzna dla .NET 4.0, jeżeli macie asemblaty w innej wersji .NET powinniście zmodyfikować parametr /targetplatform


Mając konfigurację MSBuilda z ILMerge powinniśmy jeszcze poinformować nasz projekt, że ma z niej korzystać. Dokonujemy tego poprzez ręczną modyfikację pliku projektu (naciskamy na niego prawym przyciskiem i wybieramy opcję "Edit Project File").
Po otworzeniu pliku projektu naszego Modułu Zarządzania Użytkownikami powinniśmy odnaleźć następujące linijki:


Rysunek 6 - Plik projektu przed modyfikacjami


Jedyne co musimy zrobić to zmodyfikować plik następująco:


Rysunek 7 - Plik projektu po modyfikacjach


Dodaliśmy tylko dla wybranych przez nas projektów zmienną <IlMerger> z wartością true informując o tym, że chcemy, żeby projekt został połączony i podmieniliśmy domyślną konfigurację builda przygotowaną wcześniej w pliku "Ilmerge.CSharp.targets".

Zapiszmy teraz plik projektu, przeładujmy go i przebudujmy. Ponownie zerknijmy do katalogu Debug naszego Modułu Zarządzania Użytkownikami
i ujrzymy, że została wygenerowana tylko jedna dllka.


Rysynek 8 - Wygenerowane pliki po konfiguracji ILMerge


Czy ILMerge działa dla Silverlighta i Phone'a?


Ależ owsze, czemu nie. Należy tylko odpowiednio spreparować nasz plik targets:
- dla Phone'a nasz plik wyglądał by następująco:
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">    
  <Import Project="$(MSBuildExtensionsPath)\Microsoft\Silverlight for Phone\$(TargetFrameworkVersion)\Microsoft.Silverlight.$(TargetFrameworkProfile).Overrides.targets" />
  <Import Project="$(MSBuildExtensionsPath)\Microsoft\Silverlight for Phone\$(TargetFrameworkVersion)\Microsoft.Silverlight.CSharp.targets" />
   
 <Target Name="AfterBuild">     
 <CreateItem Include="@(ReferencePath)" Condition="'%(CopyLocal)'=='true' and '%(ReferencePath.IlMerge)'=='true'">
    
 
 <Message Text="MERGING: @(IlmergeAssemblies->'%(Filename)')" Importance="High" /> 
 
 <Exec Command="&quot;$(SolutionDir)\Ilmerge.exe&quot;
    /targetplatform:v4,&quot;%ProgramFiles%\Reference Assemblies\Microsoft\Framework\Silverlight\v4.0\Profile\WindowsPhone&quot; 
    /out:@(MainAssembly) &quot;@(IntermediateAssembly)&quot; @(IlmergeAssemblies->'&quot;%(FullPath)&quot;', ' ')" /> 
 </Target> 
 
 <Target Name="_CopyFilesMarkedCopyLocal"/>     
</Project>
- dla Silverlight'a nasz plik wyglądał by następująco:
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">  
<Import Project="$(MSBuildExtensionsPath32)\Microsoft\Silverlight\$(SilverlightVersion)\Microsoft.Silverlight.CSharp.targets" />   
 <Target Name="AfterBuild">     
 <CreateItem Include="@(ReferencePath)" Condition="'%(CopyLocal)'=='true' and '%(ReferencePath.IlMerge)'=='true'">
    
 
 <Message Text="MERGING: @(IlmergeAssemblies->'%(Filename)')" Importance="High" /> 
 
 <Exec Command="&quot;$(SolutionDir)\Ilmerge.exe&quot;
    /targetplatform:v4,&quot;%ProgramFiles%\Reference Assemblies\Microsoft\Framework\Silverlight\v5.0&quot; 
    /out:@(MainAssembly) &quot;@(IntermediateAssembly)&quot; @(IlmergeAssemblies->'&quot;%(FullPath)&quot;', ' ')" /> 
 </Target> 
 
 <Target Name="_CopyFilesMarkedCopyLocal"/>     
</Project>

Jak łatwo zauważyć podmieniliśmy tylko ścieżki do plików z domyślnymi ustawieniami buildów dla tych środowisk oraz poprawiliśmy wywołanie ILMerge'a w Exec Command tak aby dotyczyła właściwej platformy.


ILMerge i Resharper


Jeżeli zrobiliście wszystko zgodnie z powyższym opisem to po dodaniu klas i próbie wywołania ich w projekcie Application okaże się, że Resharper nie widzi klas z podmodułów (Authorization, Registration, Login). Dzieje się tak dlatego, że projekty naszych modułów znajdują się w tej samej solucji co projekt Application. Jeżeli utworzylibyśmy osobną solucję, w której nie znajdowałyby się nasze podmoduły, a tylko projekt Application okaże się, że Resharper widzi je już bez większych problemów.
Jest to błąd Resharpera - chociaż oni twierdzą inaczej. Zapewne nie chce im się tego naprawiać, ale oczywiście mają na to mądre wytłumaczenie. Mówią, że jeżeli doprowadziło się do takiej sytuacji to znaczy, że układ projektów jest zły. Można by się było z nimi po części zgodzić, bo moduły powinny być traktowane jako całość i posiadać osobne solucje a nie być wepchnięte w jedną dużą. Jest to jednak spore uniedogodnienie, szczególnie na początku tworzenia systemu, gdy moduły są często zmieniane - trzeba wtedy pracować na kilku solucjach na raz, albo ignorować błędnie podświetlony przez Resharpera kod.


Podsumowanie i linki


Mam nadzieję, że tym artykułem udało mi się przybliżyć to jak ILMerge może pomóc nam przy tworzeniu modularnych aplikacji oraz przede wszystkim ułatwić życie programistom.
Kody źródłowe przykładów z tego artykułu możecie znaleźć tutaj.

Linki do artykułów z których korzystałem przy tworzeniu tego wpisu to:
- http://www.hanselman.com/blog/MixingLanguagesInASingleAssemblyInVisualStudioSeamlesslyWithILMergeAndMSBuild.aspx
- http://blogs.msdn.com/b/jomo_fisher/archive/2006/03/05/544144.aspx
- http://blogs.clariusconsulting.net/kzu/leveraging-ilmerge-to-simplify-deployment-and-your-users-experience/
- http://awkwardcoder.blogspot.com/2011/05/using-ilmerge-for-windows-phone-7.html
- http://albao.wordpress.com/tag/ilmerge-error-documentation-exception-net/
- http://nitoprograms.blogspot.com/2010/09/using-ilmerge-with-net-40-andor-rx.html
- http://devnet.jetbrains.net/message/5253869#5253869

piątek, 23 marca 2012

WrocNet - Team Foundation Server to nie SVN - Materiały

Przedwczoraj (środa 21.03) debiutowałem w roli "wykładowcy" na spotkaniu Wrocławskiej grupy .NET. Zaprezentowałem tam rozwinięcie moich wpisów związanych z połączeniem SCRUM z Team Foundation Server. 
Mnie jako prezentującemu na pewno podobało się zaangażowanie słuchaczy, za co serdecznie dziękuję. Nie wiem jak było w drugą stronę, jeżeli ktoś był i chce się podzielić swoimi wrażeniami (nawet najbardziej negatywnymi) to bardzo proszę o komentarze.
Obiecałem, że przedstawię materiały, z których dociekliwi mogliby się dowiedzieć więcej o przedstawianym przeze mnie temacie.
Jako pierwsze zareklamuje swoje wcześniejsze wpisy:
A teraz linki z których korzystałem:
Polecam również dwie świetne książki (dotyczą one co prawda TFS 2010, ale większość porad i opisów ma również zastosowanie w przypadku nowej wersji):
Miłej lektury!
   

niedziela, 5 lutego 2012

Multiplatforomowe aplikacje w .NET, Silverlight i Windows Phone Cz.3 - Konfiguracja komunikacji socketami

Wstęp

W poprzednich dwóch wpisach, przedstawiłem ogólne zasady tworzenia aplikacji multiplatformowych, pokazałem jak można zapisywać i odczytywać dane z socketów. Oparłem się przy tym mocno na przykładzie Johna Papa. W tym przykładzie pójdę dalej tym tropem i pokażę jak można uruchomić komunikację klient serwer. Jak sprawić, żeby sockety zaczęły nasłuchiwać i ze sobą rozmawiać.

Odczyt/zapis socketa

W poprzednim wpisie przedstawiłem dwie klasy do odczytywania poleceń przesyłanych przez sockety (kody źródłowe dostępne są tutaj), Ponieważ nasze sockety będą miały komunikować się dwustronnie dla uproszczenia sprawy wprowadźmy jeszcze dodatkową klasę opakowującą CommandReaderWriter.

public class CommandReaderWriter
{
    public Socket Socket { get; protected set; }
    public delegate void OnConnectedDelegate(object sender, SocketAsyncEventArgs e);

    public event OnConnectedDelegate OnConnectedEvent = delegate { };

    public CommandReader Reader { get; protected set; }
    public CommandWriter Writer { get; protected set; }

    public CommandReaderWriter()
    {

    }

    public CommandReaderWriter(Socket socket)
    {
        InitializeConnection(socket);
    }

    /// <summary>
    /// Metoda inicjująca połączenie z konkretnym socketem
    /// </summary>
    /// <param name="socket"></param>
    public void InitializeConnection(Socket socket)
    {
        Reader = new CommandReader(socket);
        Writer = new CommandWriter(socket);
    }

    /// <summary>
    /// Metoda inicjująca połączenie z socketem
    /// znajdującym się pod wskazany adresem i portem
    /// </summary>
    /// <param name="serverName">adres serwera</param>
    /// <param name="port">port</param>
    public void InitializeConnection(string serverName, int port)
    {
        var s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        var e = new SocketAsyncEventArgs
                {
                    RemoteEndPoint = new DnsEndPoint(serverName, port)
                };
        e.Completed += OnConnected;
        s.ConnectAsync(e);
    }

    /// <summary>
    /// Metoda obsługująca zdarzenie połączenia się z socketem
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void OnConnected(object sender, SocketAsyncEventArgs e)
    {
        Socket s = (Socket)sender;
        if (e.SocketError != SocketError.Success)
        {
            throw new Exception("Nie udało się połączyć!");
        }

        InitializeConnection(s);

        OnConnectedEvent(this, e);
    }

    /// <summary>
    /// Metoda zakańczająca nasłuchiwanie socketu
    /// </summary>
    public void StopReading()
    {
        Reader.StopReading();
    }

    /// <summary>
    /// Metoda rozpoczynająca nasłuchiwanie socketu
    /// </summary>
    /// <param name="h"></param>
    public void StartListening(ICommandHandler h)
    {
        Reader.StartListening(h);
    }

    /// <summary>
    /// Metoda wysyłająca polecenie poprzez socket
    /// przekazany w konstruktorze
    /// </summary>
    /// <param name="command">polecenie</param>
    public void Write(Command command)
    {
        Writer.Write(command);
    }

    public void DoCommand(CommandReader r, Command cmd)
    {
        //tutaj dodana zostanie obsługi polecenia
    }
}

Klasa ta oprócz opakowania metod CommandReader i CommandWriter posiada też metody odpowiedzialne za jego inicjalizację. Ta z adresem i numerem portu powinna być używana przez aplikację kliencką, ta z Socketem w aplikacji serwerowej.
Mamy już tak naprawdę komplet klas, które pozwolą nam na odczytywanie i zapisywanie z socketów. Musimy teraz utworzyć klasy, które je nam wywołają.


Konfiguracja klienta


Zacznijmy od sprawy prostszej - konfiguracji klienta. Otwórzmy definicję głównego okna aplikacji Multiplatform.Client.Silverlight - MainPage.xaml.cs i zmodyfikujmy je następująco:

public partial class MainPage : UserControl, ICommandHandler
{
    private CommandReaderWriter _commandReaderWriter;

    public MainPage()
    {
        InitializeComponent();

        InitializeNetworkConnection();
    }

    /// <summary>
    /// Metoda inicjująca połączenie z serwerem
    /// </summary>
    private void InitializeNetworkConnection()
    {
        _commandReaderWriter = new CommandReaderWriter();
        _commandReaderWriter.InitializeConnection("localhost", 4529);
        _commandReaderWriter.OnConnectedEvent += CommandReaderWriter_OnConnectedEvent;
    }

    /// <summary>
    /// Metoda przechwytująca zdarzenie połączenia z serwerem
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    void CommandReaderWriter_OnConnectedEvent(object sender, SocketAsyncEventArgs e)
    {
        //skoro udało się połączyć, to rozpocznij nasłuchiwanie
        _commandReaderWriter.StartListening(this);
    }

    public void DoCommand(CommandReader r, Command cmd)
    {
        //tutaj będzie obsługa poleceń
    }
}

Dodaliśmy do niego zainicjowanie połączenia z serwerem poprzez podanie adresu oraz numeru portu, na którym będziemy nasłuchiwać. Klasa ta implementuje również interfejs ICommandHandler, dzięki czemu może obsługiwać polecenia wysłane przez serwer.
Dokładnie to samo moglibyśmy zrobić w przypadku MainWindow aplikacji WPF oraz MainPage w aplikacji na Phone'a, z małym wyjątkiem w przypadku tego ostatniego. Nie możemy podać jako adres serwera "localhost", gdyż emulator telefonu potraktuje to jako odwołanie się do siebie, a nie do naszego komputera. Możemy to łatwo obejść wpisując zamiast "localhost" nazwę sieciową naszego komputera. Należy uważać też na numer portu, ale o tym szerzej w kolejnym punkcie.


Konfiguracja serwera


Serwer w swoim zachowaniu będzie zbliżony do klienta, poza tym, że będzie musiał rozpocząć nasłuchiwanie na połączenie z klientem, a nie łączyć się bezpośrednio z nim. Utwórzmy nowy katalog solucji "Server" oraz nowy projekt "Multiplatform.Server" typu "Class Library". Dodajmy klasę ServerProgram - będzie ona odpowiadała za rozpoczęcie nasłuchiwania oraz obsługę poleceń od klienta. Powinna ona wyglądać następująco:


public class ServerProgram : ICommandHandler
{
    readonly TcpListener _server = new TcpListener(IPAddress.Any, 4529);

    private CommandReaderWriter _commandReaderWriter;

    void Run()
    {
        _server.Start();
        while (true)
        {
            Socket s = _server.AcceptSocket();

            _commandReaderWriter = new CommandReaderWriter(s);
            _commandReaderWriter.StartListening(this);
        }
    }

    /// <summary>
    /// Statyczna metoda tworząca nową instancję serwera
    /// </summary>
    public static void Start()
    {
        Console.WriteLine("Starting PictureHunt Server on port 4529");
        var p = new ServerProgram();
        p.Run();
    }

    /// <summary>
    /// Metoda obsługująca polecenie od klienta
    /// </summary>
    /// <param name="r"></param>
    /// <param name="cmd"></param>
    public void DoCommand(CommandReader r, Command cmd)
    {
        //tutaj będziemy obsługiwać polecenie
    }
}

Utwórzmy jeszcze projekt Multiplatform.Server.Host w katalogu solucji Server, który będzie uruchamiał metodę Start naszego Servera w swojej metodzie Main (oszczędzę sobie trudu wklejania, a Wam czytania tej jakże zawiłej klasy).


Wprawiamy to wszystko w ruch


Mamy już zatem 3 rodzaje klientów - WPF, Silverlight, Phone oraz serwer. Co prawda jest to póki co dosyć oszukany serwer bo może obsłużyć, ale zawsze... 
Wypadało by teraz zrobić jakąś własną komendę, dzięki której będziemy mogli przetestować czy nasz szkielet, ma już mięśnie, czy dalej odmawia uczynienia choćby małego ruchu. Zróbmy klasę we współdzielonym projekcie TextCommand, będzie ona pozwalała na przesłanie tekstu.


public class TextCommand : Command
{
    public string Text { get; set; }

    public TextCommand()
    {
        CommandType = 1;
    }

    public TextCommand(string text) : this()
    {
        Text = text;

        // tutaj powinna być serializacja binarna
        // obiektu Text i przypisanie do tablicy Data
    }
}

Jak widzimy jest to bardzo prosta klasa. Dziedziczy po klasie Command, ma konstruktor domyślny oraz przyjmujący parametr z tekstem, który chcemy przesłać. Na pewno was zastanawia dlaczego nie zrobiłem tutaj standardowej serializacji przy pomocy BinaryFormattera. Otóż nie mogłem tego zrobić, bo z nieznanych mi powodów w Silverlight tej klasy nie ma. Można kombinować i robić hacki stosując serializację WCFową, ja jednak polecam użycie Open Source'owej biblioteki SharpSerializer. Pozwala ona na całkiem sprawną i szybką serializację zarówno w zwykłych projektach .NETowych jak i Silverlight, Windows Phone.
Po pobraniu i dołączeniu plików dll do projektów dodajmy klasę opakowującą do dla tej biblioteki.


public static class BinaryUtils
{
    private static readonly SharpSerializer SharpSerializer = new SharpSerializer(true);

    public static byte[] Serialize(object obj)
    {
        using (var memoryStream = new MemoryStream())
        {
            SharpSerializer.Serialize(obj, memoryStream);

            return memoryStream.GetBuffer();
        }
    }

    public static object Deserialize(byte[] bytes)
    {
        using (var memoryStream = new MemoryStream(bytes))
        {
            return SharpSerializer.Deserialize(memoryStream);
        }
    }
}


Jak widać, użycie biblioteki jest banalnie proste, nie wymaga specjalnego tłumaczenia. Mając to już gotowe, możemy dodać serializację tekstu w konstruktorze naszej klasy TextCommand. Ostatecznie wygląda on:

public TextCommand(string text) : this()
{
    Text = text;

    Data = BinaryUtils.Serialize(Text);
}
Dodajmy więc prostą funkcjonalność przesyłania tej komendy pomiędzy klientem a serwerem i odwrotnie. Klient po nawiązaniu połączenia wyśle wiadomość "Ping", serwer mu odpowie wiadomością "Pong". Musimy dokonać zmian w obsłudze Poleceń zarówno po stronie klienckiej ja i stronie serwerowej.
Klasa okna klienta wyglądało będzie po zmianach:
public partial class MainWindow : Window, ICommandHandler
{
    private CommandReaderWriter _commandReaderWriter;

    public MainWindow()
    {
        InitializeComponent();

        InitializeNetworkConnection();
    }

    /// <summary>
    /// Metoda inicjująca połączenie z serwerem
    /// </summary>
    private void InitializeNetworkConnection()
    {
        _commandReaderWriter = new CommandReaderWriter();
        _commandReaderWriter.InitializeConnection("localhost", 4529);
        _commandReaderWriter.OnConnectedEvent += CommandReaderWriter_OnConnectedEvent;
    }

    /// <summary>
    /// Metoda przechwytująca zdarzenie połączenia z serwerem
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    void CommandReaderWriter_OnConnectedEvent(object sender, SocketAsyncEventArgs e)
    {
        //skoro udało się połączyć, to rozpocznij nasłuchiwanie
        _commandReaderWriter.StartListening(this);
        _commandReaderWriter.Write(new TextCommand("Ping!")); // 1.
    }

    public void DoCommand(CommandReader r, Command cmd)
    {
        switch (cmd.CommandType)
        {
            case 1:
                string text = (string)BinaryUtils.Deserialize(cmd.Data); //2
                Debug.WriteLine(text);
                break;
        }
    }
}


Dodałem przesłanie polecenia z tekstem po nawiązaniu połączenia z serwerem (oznaczone numerem 1) oraz przechwycenie polecenia z serwera i obsłużenie go (oznaczone numerem 2). Analogicznie klasa serwera po zmianach będzie wyglądała:


public class ServerProgram : ICommandHandler
{
    readonly TcpListener _server = new TcpListener(IPAddress.Any, 4529);

    private CommandReaderWriter _commandReaderWriter;

    void Run()
    {
        _server.Start();
        while (true)
        {
            Socket s = _server.AcceptSocket();

            _commandReaderWriter = new CommandReaderWriter(s);
            _commandReaderWriter.StartListening(this);
        }
    }

    /// <summary>
    /// Statyczna metoda tworząca nową instancję serwera
    /// </summary>
    public static void Start()
    {
        Console.WriteLine("Starting PictureHunt Server on port 4529");
        var p = new ServerProgram();
        p.Run();
    }

    /// <summary>
    /// Metoda obsługująca polecenie od klienta
    /// </summary>
    /// <param name="r"></param>
    /// <param name="cmd"></param>
    public void DoCommand(CommandReader r, Command cmd)
    {
        switch (cmd.CommandType)
        {
            case 1:
                string text = (string)BinaryUtils.Deserialize(cmd.Data);
                Console.WriteLine(text);
                //odpowiedz klientowi "Pong!"
                _commandReaderWriter.Write(new TextCommand("Pong!"));
                break;
        }
    }
}
Pozostało nam tylko dodać jeszcze obsługę naszego polecenia w CommandReaderze w metodzie TransformData
private void TransformData(SocketAsyncEventArgs e)
{
    [...]
    while (data.Length >= 12)
    {
        [...]

        //zainicjuj obiekt polecenia
        Command cmd = null;
        switch (opcode)
        {
            case 1:
                cmd = new TextCommand {Data = newData};
                break;
            default:
                cmd = new Command{Data = newData};
                break;
        }

        [...]
    }
}
Możecie śmiało odpalić serwer, i jedną z aplikacji klienckich, wszędzie zadziała dobrze oprócz Silverlighta. Dlaczego? Wytłumaczenie znajdziecie w kolejnym punkcie...

Silverlight i Sockety

Silverlight jako chyba najbardziej irytująca technologia Microsoftu i tutaj musi utrudniać programistom życie. Oczywiście celem jest dobro i bezpieczeństwo użytkowników końcowych. Ja jednak nie do końca ufam i nie do końca wierzę tym tłumaczeniom, skoro w Windows Phone nie ma już takich utrudnień związanych z socketami.
Szczegółowo można przeczytać na ten temat w artykule Network Security Access Restrictions in Silverlight na MSDN - ja postaram się to skrócić w kilku zdaniach. Aby zachować bezpieczeństwo i wygodę użytkowników w Silverlight można łączyć się z Socketami tylko z zakresu 4502-4534. Dodatkowo aplikacja Silverlightowa łącząca się z serwerem na zadanym adresie i zadanym porcie najpierw próbuje połączyć się z tym adresem z portem 943. Oczekuje, że na tym porcie będzie wystawiona usługa, która mu dostarczy plik xml z informacjami o zasadach bezpieczeństwa (tzw. "policy file").
Jeżeli nie odnajdzie tej usługi i nie pobierze tego pliku, to automatycznie ignoruje połączenie uznając, że jest ono niebezpieczne. Wszystko dla naszego dobra, oczywiście.
Nie będę tutaj wklejał tego kodu, jest on dostępny w przedstawionym wcześniej artykule, oraz w kodach źródłowych na końcu artykułu. Należy pamiętać, żeby usługa ta była zawsze uruchomiona na tym samym adresie co nasz serwer.

Podsumowanie

W tym artykule pokazałem już jak wprawić w ruch machinę komunikacji socketami pomiędzy klientem a serwerem i serwerem a klientem. W kolejnych artykułach przedstawię jak zrobić serwer obsługujący wielu użytkowników oraz jak ukryć za fasadą tą niezbyt elegancką obsługę komend.

Kody źródłowe możecie pobrać stąd.

Multiplatforomowe aplikacje w .NET, Silverlight i Windows Phone Cz.2 - Wstęp do komunikacji socketami

Wstęp

W poprzednim wpisie przedstawiłem wstęp oraz kilka problemów, które napotykamy przy rozpoczęciu zabawy z aplikacji wieloplatformowych. Tak jak zapowiedziałem, w tym wpisie przedstawię kolejny krok do utworzenia gry multiplayer w Kuku. Tym razem na warsztat wzięte zostają metody komunikacji klient-serwer, serwer-klient przy pomocy socketów. Dlaczego przy pomocy socketów, a nie WCF? Szczegóły później. Najpierw się zastanówmy czego tak naprawdę potrzebujemy.
Naszą wersję Kuku można opisać następująco:
- zbierają się gracze,
- każdemu z nich rozdajemy karty, pierwszy gracz dostaje 4, resta 3,
- jeżeli któryś z graczy ma 3 karty w jednym kolorze lub z tymi samymi figurami, to może krzyknąć "kuku!". Jeżeli nikt tego nie zrobił, to
- zaczyna się tura pierwszego gracza,
- wybiera on jedną kartę i przekazuje ją kolejnemu graczowi,
- zaczyna się jego tura,
- jeśli karta do niego wróci, może ją wymienić,
- kto pierwszy skompletuje kuku ten wygrywa.

Zatem nasza gra powinna:
- umożliwić dołączanie graczy,
- reagować na wybory gracza,
- powiadamiać graczy o zmianie stanu gry. 

Potrzebujemy zatem komunikacji pomiędzy graczami. Niektórym z Was od razu może się to skojarzyć z grami/programami typu P2P (Peer To Peer). Będzie to bardzo dobre skojarzenie. Implementując nasz system można by było w teorii pokusić się o to, żeby gracz, wysyłał kolejnemu graczowi informację: "Stary teraz twoja kolej!". A pozostałym o tym, że to zrobił. Niestety takie systemy są trudne do utrzymania, kontroli i rozwoju. Dodatkowo cała logika biznesowa jest przechowywana w aplikacji klienckiej, co powoduje ich nadmierny rozrost, tworząc je za dużymi do zastosowania na stronach internetowych oraz telefonach komórkowych. Według mnie lepsze jest rozwiązanie pośrednie:
- gracz przesyła informację do serwera o swoim wyborze,
- serwer decyduje o tym jaka akcja powinna być wykonana - to on mówi kolejnemu graczowi o jego turze, on rozsyła informacje do pozostałych graczy.
Komunikacja musi być zatem dwustronna:
- klient - serwer
- serwer - klient



Podejrzewam, że większość z Was miała już do czynienia z web service'ami pisanymi przy pomocy WCF. Są one dobre dla standardowych rozwiązań biznesowych, w których wysyłamy zapytanie, dostajemy odpowiedź - typowa komunikacja jednostronna. Niestety ten model komunikacji nie sprawdzi się w przypadku naszego problemu. U nas żądania wysyłane są w dwie strony, nie wiemy również kiedy dokładnie one wystąpią. Niektórzy z Was zapewne natrafili na Duplex Channel, pozwalający oprogramować w WCF komunikację dwustronną. Niestety w Silverlight dostępna jest tylko jego uboższa wersja, mając dużo ograniczeń, nie nadająca się do rozwiązań komercyjnych (więcej szczegółów na blogu Tomasza Janczuka tutaj i tutaj). Z pomocą przyjdą nam stare jak świat sockety.

Sockety 

Jest to rozwiązanie znane od dawien dawna, istnieje ono zarówno w C++ jak i w Javie. Nie będę się nad tym przesadnie rozpisywał, raczej przedstawię ich ogólną zasadę.
Sockety pozwalają na bezpośrednią komunikację pomiędzy dwoma komputerami. Aby nawiązać połączenie musimy znać adres internetowy komputera oraz port, na którym on nasłuchuje. Klient znając te dane serwera łączy się z nim. Tworzone jest połączenie TCP. Połączenie jest utrzymywane cały czas, dlatego też możliwa jest komunikacja w dwie strony. Odbywa się ona przy pomocy strumienia bajtów. Zalety tego rozwiązania to szybkość i wydajność, minusem jest to, że musimy oprogramować cały mechanizm "odszyfrowywania" strumienia. Musimy sami określać, które bajty odpowiadają za co, gdzie kończy się jedno rozwiązanie, a zaczyna kolejne.
W moich rozważaniach punktem wyjściowym będzie świetny przykład Johna Papa zaprezentowany na Silverlight TV. Przedstawił on tam podstawowy mechanizm przetwarzania socketów, zachęcam do przyjrzenia się mu i porównania ze zmianami, które do niego wprowadziłem.
Zaproponował on bardzo sprytny i prosty zarazem sposób przetwarzania danych przesyłanych w socketach, wykorzystał on przy tym wzorzec projektowy Polecenie (Command).
Chcąc przesłać żądanie do serwera musimy utworzyć obiekt klasy Command. Następnie serializujemy go do postaci binarnej i przesyłamy go poprzez socket do serwera. Serwer odbiera bajty i deserializuje je. Tak utworzony obiekt polecenia przetwarzamy przy pomocy klasy pomocniczej CommandHandler. Dla każdego rodzaju operacji konieczne jest utworzenie implementacji klasy Command, dzięki temu klasa pomocnicza wie w jaki sposób ma wykonać polecenie (na podstawie jej typu).
Wspominałem wcześniej, że największym problemem przy Socketach jest określenie, w jaki sposób rozdzielić jedno żądanie od innego. Tak jak już napisałem pomiędzy klientem a serwerem utworzony jest strumień TCP. Zwykle  każde żądanie jest wysyłane osobno, lecz może dość do sytuacji gdy w jednym pakiecie wysłane zostanie kilka żądań (np. gdy są opóźnienia w sieci a klient wykonał szybko kilka akcji), lub jedno żądanie zostanie podzielone na kilka pakietów (np. gdy wysyłamy sporą liczbę danych). Nie będziemy wiedzieli więc od razu po odczytaniu danych ze strumienia, czy możemy już deserializować i wykonać Polecenie. Jak zatem sobie z tym poradzić? 
John Papa zaproponował, żeby komenda posiadała nagłówek. Nagłówek ten posiadał będzie podstawowe informacje o niej (takie jak jej rozmiar). Najważniejszą jego cechą jest to, że będzie on miał stałą wielkość. Dzięki czemu będzie można go zserializować od razu gdy zorientujemy się, że mamy do czynienia z nowym żądaniem. Po jego odczytaniu będziemy wiedzieć ile jeszcze bajtów zostało nam do odczytania, wiedząc tym samym, w którym miejscu kończy się żądanie. 



Konkrety


Klasa polecenia napisana zgodnie z tymi wytycznymi wygląda następująco:
/// <summary>
/// Klasa wzorowana na rozwiązaniu przedstawionym
/// przez Johna Papa w Silverlight TV
/// http://channel9.msdn.com/Shows/SilverlightTV/Silverlight-TV-70-Sockets-Unplugged
/// </summary>
public class Command
{
    /// <summary>
    /// Typ polecenia
    /// 
    public int CommandType;
    /// <summary>
    /// Rozmiar nagłówka
    /// </summary>
    public int HeaderLen;
    /// <summary>
    /// Dane nagłówka
    /// </summary>
    public byte[] Header;

    /// <summary>
    /// Dane polecenia
    /// </summary>
    public byte[] Data;

    public Command()
    {
        HeaderLen = 12;
        Header = null;
        Data = null;
    }
        
    /// <summary>
    /// Metoda inicjująca nagłówek
    /// </summary>
    /// <returns></returns>
    public virtual BinaryWriter InitHeader()
    {
        Debug.Assert(CommandType != 0);
        Debug.Assert(HeaderLen >= 12);
        Header = new byte[HeaderLen];
        var bw = new BinaryWriter(new MemoryStream(Header));
        bw.Write(Htonl(HeaderLen));
        bw.Write(Htonl(Data == null ? 0 : Data.Length));
        bw.Write(Htonl(CommandType));
        return bw;
    }

    /// <summary>
    /// Metoda formatująca liczby do formatu
    /// odpowiedzniego dla socketów
    /// </summary>
    /// <param name="value"></param>
    /// <returns></returns>
    public Int32 Htonl(Int32 value)
    {
        return IPAddress.HostToNetworkOrder(value);
    }
}

Do zapisywania wysłania polecenia przez Socket służy klasa CommandWriter
/// <summary>
/// Klasa służąca do wysyłania danych poprzez socket
/// </summary>
public class CommandWriter
{
    public Socket Socket;

    public CommandWriter()
    {
    }

    public CommandWriter(Socket socket)
    {
        Socket = socket;
    }

    /// <summary>
    /// Metoda wysyłająca polecenie poprzez socket
    /// przekazany w konstruktorze
    /// </summary>
    /// <param name="command">polecenie</param>
    public void Write(Command command)
    {
        Write(Socket, command);
    }

    /// <summary>
    /// Metoda wysyłająca polecenie poprzez
    /// zadany socket
    /// </summary>
    /// <param name="socket">socket</param>
    /// <param name="command">polecenie</param>
    public void Write(Socket socket, Command command)
    {
        //utwórz nagłówek
        command.InitHeader();
        var senddata = new List<ArraySegment<byte>> { new ArraySegment<byte>(command.Header) };
        //wrzuć dane polecenia
        if (command.Data != null)
        {
            senddata.Add(new ArraySegment<byte>(command.Data));
        }
        var writeEventArgs = new SocketAsyncEventArgs();
        writeEventArgs.Completed += WriteCompleted;
        writeEventArgs.BufferList = senddata;
        //wyślij socketem bajty
        socket.SendAsync(writeEventArgs);
    }
}
Klasa odczytująca polecenie z socketa będzie wyglądała następująco:
/// <summary>
/// Klasa służaca do odczytywania danych z socketa
/// wzorowana na rozwiązaniu przedstawionym
/// przez Johna Papa w Silverlight TV
/// http://channel9.msdn.com/Shows/SilverlightTV/Silverlight-TV-70-Sockets-Unplugged
/// </summary>
public class CommandReader
{
    public Socket Socket;

    byte[] data = new byte[0];

    public CommandReader(Socket socket)
    {
        this.Socket = socket;
    }
    /// <summary>
    /// Metoda zamieniająca liczbę z formatu socketa
    /// na format standardowy
    /// </summary>
    /// <param name="value"></param>
    /// <returns></returns>
    public static Int32 Ntohl(Int32 value)
    {
        return System.Net.IPAddress.NetworkToHostOrder(value);
    }

    /// <summary>
    /// Metoda rozpoczynająca nasłuchiwanie socketu
    /// </summary>
    /// <param name="h"></param>
    public void StartListening(ICommandHandler h)
    {
        Console.WriteLine("CR: Go  : Socket {0} CR {1}", Socket, this);

        //określ parametry nasłuchiwania
        const int size = 10000;
        var e = new SocketAsyncEventArgs();
        e.Completed += OnRead;
        e.UserToken = h;
        e.SetBuffer(new byte[size], 0, size);

        //rozpocznij nasłuchiwanie
        while (Socket.ReceiveAsync(e) == false)
        {
            TransformData(e);
        }
    }

    /// <summary>
    /// Metoda wywołana po zaczytaniu paczki danych z socketa
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void OnRead(object sender, SocketAsyncEventArgs e)
    {
        //przetwarzaj dane
        TransformData(e);
        //nasłuchuj czy nie przychodzą kolejne porcje danych
        while (Socket != null && Socket.ReceiveAsync(e) == false)
        {
            TransformData(e);
            if (e.BytesTransferred == 0)
            {
                break;
            }
        }

    }
    /// <summary>
    /// Metoda przetwarzająca dane otrzymane z socketa
    /// </summary>
    /// <param name="e"></param>
    private void TransformData(SocketAsyncEventArgs e)
    {
        var oldLen = data.Length;
        var newLen = oldLen + e.BytesTransferred;
        Array.Resize<byte>(ref data, newLen);
        Array.Copy(e.Buffer, 0, data, oldLen, e.BytesTransferred);
        while (data.Length >= 12)
        {
            //pobrano już co najmniej nagłówek
            var reader = new BinaryReader(new MemoryStream(data));
            var headerLen = Ntohl(reader.ReadInt32());
            var dataLen = Ntohl(reader.ReadInt32());
            var opcode = Ntohl(reader.ReadInt32());
            var totLen = headerLen + dataLen;
            var extra = data.Length - totLen;

            //jeżeli nie pobrano jeszcze całości danych
            //zakończ przetwarzanie i czekaj na kolejną
            //paczkę z danymi
            if (extra < 0)
                break;
                
            //Pobrano już co najmniej tyle danych ile ma polecenie
            //utwórz nową tablicę do przechowywania danych polecenia
            byte[] newData = new Byte[dataLen];
            Array.Copy(data, headerLen, newData, 0, dataLen);

            //zainicjuj obiekt polecenia
            Command cmd = null;
            switch (opcode)
            {
                //tutaj wstawiamy tworzenie poszczególnych poleceń
                //w zależności od typu
                default:
                    cmd = new Command{Data = newData};
                    break;
            }

            //jeżeli pobrano więcej bajtów niż miało mieć polecenie
            //przenieś je do nowej tablicy
            if (extra > 0)
            {
                Array.Copy(data, totLen, data, 0, extra);
            }
            Array.Resize<byte>(ref data, extra);

            //wykonaj polecenie
            ICommandHandler h = (ICommandHandler)e.UserToken;
            h.DoCommand(this, cmd);
        }
    }
}

Podsumowanie

W tym poście przedstawiłem ogólny zarys sposobu komunikacji dla aplikacji multiplatformowych w środowisku .NET. Pokazane zostało po co nam komunikacja dwustronna, klient - serwer, serwer - klient. Jak można zaimplementować ją przy pomocy socketów.
Popisałem się również umiejętnością czytania ze zrozumieniem i pokazałem klasy do obsługi czytania i zapisu do socketów zaprezentowane przez Johna Papa. W kolejnych postach przedstawię jak w ogóle uruchomić sockety, jak skonfigurować serwer i klienta i pokażę trochę własnej inwencji przedstawiając swoje ulepszenia do dotychczas opisanych rozwiązań.

Kody źródłowe można pobrać tutaj.

Multiplatforomowe aplikacje w .NET, Silverlight i Windows Phone Cz.1 - Współdzielenie klas

Wstęp

W kilku najbliższych wpisach postaram się przybliżyć tematykę tworzenia aplikacji multiplatformowych. Środowisko .NET dostarcza nam rozwiązań, które pozwalają tworzyć zarówno aplikacje okienkowe (WinForms, WPF), strony internetowe (ASP.NET, Siverlight) jak i programy na telefony komórkowe (Windows Phone). W dzisiejszych czasach rozpowszechniło się tworzenie aplikacji w architekturze trójwarstwowej. Dzięki niej zostaje rozdzielony dostęp do danych, logika biznesowa oraz warstwa kliencka. Ułatwia to bardzo stworzenie systemów, które będą mogły "wystawiać" środowiska klienckie na różne platformy technologiczne. Brzmi prosto, ale w praktyce okazuje się trudniejsze. Programiści muszą cały czas się pilnować i mieć świadomość tego co się robi.Według mnie najważniejsze rzeczy, które powinniśmy mieć cały czas "w głowie" przy tworzeniu systemów wieloplatformowych są:
- możliwość wielokrotnego używania tych samych klas w różnych rodzajach projektów,
- tak jak tort, cebula i ogry, nasza aplikacja powinna posiadać warstwy. Warstwy te powinny komunikować się z sąsiednimi, nie burząc łańcucha zależności
- łatwość refaktoryzacji. Twórzmy rozwiązania w ten sposób, żeby np. zmiana typu bazy danych nie pociągała za sobą zmian w aplikacji klienckiej

Oczywiście jak we wszystkim, tutaj również trzeba kierować się rozsądkiem. Nie należy tworzyć rozwiązań, które pozwolą nam oprogramować działanie świata i rozpracować teorię wielkiego wybuchu, gdy chcemy napisać prosty kalkulator. Tak samo nie ma sensu generować kilkudziesięciu warstw, do których spamiętania będziemy potrzebowali schematu na dwie kartki A0.


.NET umożliwia nam tworzenie aplikacji w różnych platformach klienckich, ale żeby nie było tak prosto do każdego z nich ma pewne obwarowania. Silverlight, WPF i Windows Phone wywodzą się z jednego pnia, ale są osobnymi gałęziami. Z różnych powodów, głównie związanych ze specyfiką technologiczną środowiska klienckiego, oraz zaszłościami historycznymi są to tak naprawdę 3 różne frameworki .NET. Współdzielą niektóre klasy, część mają innych. W dużym uogólnieniu można by było powiedzieć:
- Silverlight jest podzbiorem WPF,
- Windows Phone jest podzbiorem Silverlight.
Oczywiście nie jest to do końca prawdą, ale całkiem dobrze oddaje rzeczywistość bez wchodzenia w większe szczegóły. No ale przejdźmy wreszcie do przykładów przykładu. Na nim powinno być łatwiej przedstawić te problemy. Graliście kiedyś w Kuku? Nie? To proszę oto i zasady (znalezione na "ABC Gier Karcianych"):


"Kuku jest bardzo prostą grą karcianą trwającą zazwyczaj około 10 - 15 minut. Celem gry Kuku jest skompletowanie trzech takich samych kolorów albo trzech takich samych figur. W Kuku grać może nawet do kilkunastu osób. W Kuku można grać całą talią kart albo gdy w grze bierze udział mała liczba graczy można grać kartami od 9. Rozdający daje każdemu z graczy po trzy karty, zaś graczowi siedzącemu po swojej lewej stronie cztery. Gracz który ma cztery karty oddaje jedną kartę z nie pasujących mu kart graczowi który siedzi z lewej strony. Karty oddaje się zgodnie z ruchem wskazówek zegara. W przypadku powrotu do tej samej osoby i grające osoby potwierdzą taką możliwość wówczas gracz może zamienić kartę na jedną kartę z tali. Jeśli osoba która zbierze trzy jednakowe kolory lub figury nie krzyknie "kuku", a reszta graczy krzyknie wówczas osoba ta przegrywa. W sytuacji gdy wszyscy gracze poza jednym mają zebrane „kuku” wówczas gra się kończy a przegrany gracz musi odgadnąć „kuku” innych graczy może pomóc sobie jedynie własnymi kartami."

Spróbujemy zrobić system, który pozwoli nam na zagranie w nią zarówno w "okienkach", stronie internetowej jak i telefonie komórkowym. Jest to na tyle prosta gra, że nie będzie trzeba za dużo męczyć się z oprogramowaniem jej logiki a na tyle trudna, że będę mógł traktować nasze rozważania jako punkt wyjściowy dla kolejnych artykułów (dodatkowo uprościmy sprawę i darujemy sobie zgadywanie na koniec gry, po prostu pierwszy gracz, który skompletuje kuku wygrywa).

Przykład

Przed uruchomieniem Visual Studio polecam zainstalowanie sobie:
- Visual Studio 2010 Service Pack 1
- Silverlight 4 SDK (może być też 5)
- Windows Phone SDK 1
Gdy wszystko będzie już poinstalowane, skonfigurowane i dopięte na ostatni guziczek zapraszam do uruchomienia Visual Studio i utworzenia pustej solucji.




Następnie w nowej solucji utwórzmy dwa katalogi:
- Shared - na projekty ze wspólnymi klasami
- Client - na projekty klienckie




Do katalogu Client dodajmy projekty klienckie:
- WPF



- Silverlight




  wraz z projektem hostującym na stronie www





- Windows Phone




Do katalogu dodajmy projekt biblioteki klas




W tym projekcie będą znajdowały się klasy odpowiadające za logikę gry, które będą wspólne dla projektów klienckich. Dodajemy zatem referencję do tego niego w projekcie WPF, następnie w Silverlight i Phone. 
Udało Wam się? Mnie nie. Przy próbie dodania referencji w projekcie Silverlightowym wyskakuje komunikat:




Podobny dostaniemy przy próbie dodania referencji do projektu Phone'owego. Zatem w jaki sposób można współdzielić pliki skoro nie możemy podpiąć projektu do wszystkich typów aplikacji klienckich?
Rozwiązanie tego problemu nie jest ani eleganckie, ani najwygodniejsze, ale póki co jedyne rozsądne. Musimy utworzyć analogiczne projekty z klasami wspólnymi dla każdej z docelowych platform klienckich:
- Silverlighta




- Phone'a




Po tym wszystkim struktura projektów powinna wyglądać następująco:





Będą one tak jakby kopiami tego co mamy w głównym projekcie ze wspólnymi klasami. Aby kopia była wierna musimy skopiować właściwości projektu i generowanej dllki. Otwórzmy informacje projektu wzorcowego:




Musimy przenieść informacje:
- Assembly Name
- Default Namespace
- Assembly Information
Robimy to poprzez otworzenie właściwości projektów dla Silverlight oraz Phone i zmianę odpowiednich pól a na koniec zapisanie plików projektów.
Dzięki temu uzyskamy, to że generowane pliki będą miały ten sam namespace oraz takie same właściwości asemblatu. Będziemy mogli dzielić bez problemu klasy poprzez serwisy wcf, serializować je itd.


Domyślam się, że teraz po Waszej głowie chodzi myśl: "Wszystko pięknie, ładnie, ale czy teraz będziemy musieli dodawać te same klasy do 3 różnych projektów i przy każdej zmianie uaktualniać w 3 miejscach?". Odpowiedzią jest: "I tak, I nie". 
Tak, będziemy musieli dodawać plik do każdego projektu osobno. Nie, wystarczy że będziemy zmieniać je w jednym miejscu. Jak to możliwe? Visual Studio umożliwia dodawanie plików do projektu jako linków. Dzięki tym linkom VS nie tworzy nowego pliku tylko odwołuje się do lokacji w innym miejscu. Do projektu wzorcowego dodawać będziemy pliki w normalny sposób, do pozostałych linki do nich.
Aby pokazać jak to się robi utwórzmy interfejs IKukuGame w projekcie Multiplatform.Shared. Chcąc dodać plik jako link naciskamy na projekcie Multiplatform.Shared.Silverlight "Add Existing Item". Przechodzimy do lokalizacji gdzie znajduje się świeżo dodany interfejs. Zaznaczamy go i naciskamy małą strzałkę przy przycisku "Add". Pojawi nam się wtedy opcja "Add As Link". Naciskamy ją i et voilà!




Kody źródłowe można pobrać tutaj.


Podsumowanie


Po tym artykule powinniście już wiedzieć, że:
- zwykły .NET, Silverlight i Phone to nie to samo, 
- nie da się w prosty sposób połączyć ze sobą projektów,
- ale da się w nieco trudniejszy,
- powinniście znać zasady gry w Kuku.

W kolejnym wpisie podążymy tropem tego ostatniego punktu i zrobimy kolejny krok w stronę utworzenia gry multiplayer w Kuku.