Windows Phone 7

Tydzień temu (oraz jakiś czas temu) miałem przyjemność co nie co opowiedzieć o nowym systemie na urządzenia mobilne Microsoftu – Windows Phone 7. Ba nawet udało się wypożyczyć jeden telefon z Microsoftu – LG GW910, który widać na rysunku poniżej:

image

Przy okazji pożyczenia korzystam sobie z niego od dwóch tygodni i muszę przyznać, że nowy system i sam telefon spisuje się bardzo dobrze, jestem pozytywnie zaskoczony działanie. Nie sądziłem, że system na telefonie może tak szybko działa, przy tym tak stabilnie (jak na razie nie miałem żadnych problemów). No ale nie ma co się dziwić, jednak pod maską siedzi mały potwór jak na urządzenia mobilne (ostatnio dla wujka oddałem swój stary komputer, aby mógł sobie korzystać z Internetu, który ma parametry zbliżone do parametrów tego telefonu Open-mouthed smile ).

No dobra ale wracając do mojej prezentacji (a dokładnie dwóch Smile ). Ogólnie była podzielona na trzy części.

Podczas pierwszej opowiedziałem o samym telefonie i systemie, co pojawiło się nowego i dlaczego. Nie będę tutaj tego wszystkiego opisywał szczególnie, że w innych miejscach w Internecie można znaleźć opisy ale wspomnę o jednej rzeczy. Osobiście bardzo podoba mi się nowy interfejs użytkownika (tak zwane Metro wzorowane na istniejących metrach – kolejkach podziemnych Smile ) zaproponowany przez Microsoft. Pamiętam kiedyś (bodajże na prezentacji z MIXa, gdzie po raz pierwszy został pokazany Windows Phone 7) jak na filmie widziałem nowy interfejs miałem co do niego mieszane uczucia, czy będzie fajny. Ale wystarczyło trochę poużywać nowy interfejs i bardzo przypadł mi do gustu. Bardzo szybko można się odnaleźć w nim i po chwili z nim bez problemów pracować.

Przy interfejsie też widać, że jednak Microsoft sporo czasu poświęcił na myślenie (nie wiem, czy gdzieś indziej ktoś na to wpadł, więc mogę się myli) ale zastanawialiście się, czemu domyślny interfejs Windows Phone 7 jest czarny? Okazuje się, że nie bez powodu. W telefonach z Windows Phone 7 wykorzystywane są wyświetlacze OLED, które jak “świecą” na czarno zużywają dużo mniej energii niż świecąc na jasno. W materiałach o Windows Phone 7 podaje się, że gdy właśnie ekran OLED “świeci” na czarno to zużywa połowę mniej energii niż identyczny ekran LCD, czyli jak widać znacznie mniej. Natomiast w przypadku świecenia jasno, tutaj ekrany OLED wypadają dużo gorzej niż ekran LCD – zużywa “tylko” trzy razy więcej energii niż ekran LCD. Więc widać to, że interfejs domyślnie jest ciemny to nie tylko widzi misie kogoś tam ale zamierzony cel, dzięki któremu telefon może działać dłużej na baterii.

Kolejną częścią prezentacji był Marketplace ale nie od strony zwykłego użytkownika ale od strony potencjalnego twórcy oprogramowania. Tutaj wspomnę tylko o dwóch rzeczach. Po pierwsze warto pisać aplikacje na Windows Phone 7, teraz jest ich bardzo mało w porównaniu np. z innymi systemami. Nie na ile w tej chwili te dane są aktualne ale z tego co się orientuje to w marketplace dla Windows Phone 7 aplikacji jest około 1500 tysiąca, natomiast w przypadku Androida jakiś czas temu widziałem informacje, że pękła liczba 100 tysięcy, czyli jak widać jest co nadgonić i co fajne od razu wrzucając aplikację do marketplace dystrybuowana jest ona globalnie.

Dodatkowo studenci aplikacje mogą wrzucać za darmo wystarczy mieć tylko konto w Dreamsparku, a takie konto może mieć każdy student. Niestety na razie tak różowo nie jest i jakimś cudem polscy studenci z tego nie mogą korzystać. Ale z tego co wiem to polski odział Microsoft pracuje nad tym, aby jednak dać możliwość studentom z Polski wrzucania aplikacji za darmo do marketplace. Jak coś więcej będę wiedział to na pewno dam znać Smile

Ostatnią częścią prezentacji był już sam Silverlight dla Windows Phone 7. Pokazałem kilka prostych dem, jak korzystać z tego co daje nam telefon i jak łatwo niektóre z nich osiągnąć. Nie będę tutaj opisywał dem (ale planuje to zrobić za jakiś czas na swoim blogu – http://plawgo.pl). Jak ktoś byłby zainteresowany już teraz jak pisać aplikacje to mogę polecić dwa miejsca w sieci:

Dla wszystkich, którzy chcą tworzyć aplikacje dla Windows Phone 7 życzę powodzenia!!!

Tagi:

70-562: Building Mobile Application

Artykuł pochodzi w serii przygotowań do egzaminu 70-562 ASP.NET.

W dzisiejszej lekcji będzie na temat budowania, uruchamiania oraz testowania mobilnych wersji aplikacji webowych stworzonych w technologii ASP.NET.

Tworzenie aplikacji mobilnych mocno nie różni się od tworzenia zwykłych aplikacji webowych. Trzeba tylko pamiętać, że w większości urządzenia mobilne mają większe ograniczenia w stosunku do normalnych komputerów. Dlatego wersje mobilne aplikacji powinny być jak najmniej skomplikowane oraz zawierać jak najmniej elementów, aby urządzenie poradziło sobie z jej wyświetleniem.

Dodanie mobilnej strony do aplikacji

Aplikacja ASP.NET może zawierać jednocześnie strony w wersji normalnej oraz wersje mobilne. Nie ma oddzielnego projektu w Visual Studio dla mobilnych aplikacji ASP.NET. Nie ma również szablonu dla strony mobilnej, który można by wykorzystać dodając taką stronę do projektu. W celu dodania mobilnej strony, programista musi dodać normalną stronę, a następnie zmienić trzy elementy na niej:

  • w kodzie behind danej strony zmieniamy klasę, z której dziedziczy klasa strony z System.Web.UI.Page na System.Web.UI.MobileControls.MobilePage
  • w kodzie aspx po dyrektywie page dodajemy dyrektywę, która załaduje przestrzeń nazw System.Web.UI.MobileControls, z której będą pochodzi kontrolki na stronie
       1: <%@ Register TagPrefix="mobile" Namespace="System.Web.UI.MobileControls" %>
  • zamieniamy wygenerowany przez Visual Studio formularz, który korzysta z wcześniej dodanej przestrzeni nazw:
   1: <mobile:Form id="form1" runat="server">
   2: </mobile:Form>

Mobilne kontrolki

Przestrzeń nazw System.Web.UI.MobileControls udostępnia programiście szereg kontrolek, które może wykorzystać tworząc mobilne wersje aplikacji ASP.NET, które są przystosowane do pracy z urządzeniami mobilnymi. Tymi kontrolkami są między innymi (większość kontrolek jest bardzo podobna do normalnych kontrolek ASP.NET):

  • Label – za jej pomocą programista może z poziomu kodu behind wyświetlić tekst na stronie. Gdy ma zostać wyświetlona większa ilość tekstu, lepiej skorzystać z kontrolki TextView
  • TextBox – służy do pobierania danych tekstowych od użytkownika
  • TextView – służy do wyświetlenia większej ilości tekstu. Umożliwia użycia prostego formatowania HTML (np. a (link), b (pogrubienie), br (znak nowej lini), i (kursywa), p (akapit))
  • Command – przycisk, który może kliknąć użytkownik. Wywoływane jest zdarzenie OnClick, gdy użytkownik kliknie w przycisk
  • Image – kontrolka służy do wyświetlenie obrazka, w przypadku, gdy format obrazka nie jest obsługiwany, wyświetlany jest tekst z właściwości AlternateText
  • List – kontrolka służy do wyświetlenie elementów w formie listy
  • SelectionList – jest podobna do kontrolki List, dodatkowo umożliwia wielokrotny elementów z listy
  • ObjectList – jest to odpowiednik GridView z normalnego ASP.NET, czyli umożliwia wyświetlenie danych w postaci tabelki
  • Calendar – kontrolka kalendarza umożliwiająca wybranie daty przez użytkownika. Kontrolka może wyglądać różnie w zależności od urządzenia (patrz opis niżej)
  • Kontrolki walidujące – dostępne są wszystkie kontrolki walidujące dostępne w normalnym ASP.NET

Brak obsługi cookie

Większość urządzeń mobilnych niestety nie obsługuje plików cookie przez co mogą wystąpić problemy między innymi z sesją oraz uwierzytelnianiem, gdzie domyślnie te mechanizmy korzystają z plików cookie (np. do przechowywania ID sesji). Dlatego w przypadku sesji należy ustawić właściwość cookieless na true, dzięki czemu ID sesji będzie przekazywany w adresie url. Aby to zrobić trzeba w web.configu (dla system.web) dodać:

   1: <sessionState cookieless="true" />

Adaptacyjny rendering

Na rynku istnieją różnego rodzaju urządzenia mobilne, które czasami mają bardzo ograniczone możliwości wyświetlania strony. Dlatego kontrolki mobilne ASP.NET umożliwiają renderowanie strony w zależności od przeglądarki, z której jest wysłane żądanie do serwera. I tak na SmartPhonie kontrolka kalendarza może być wyświetlona w sposób identyczny, jak w normalnej wersji strony w przeglądarce na komputerze, co widać na rysunku niżej:

imageNatomiast w prostym telefonie wybór daty z kalendarza może przebiegać w kilku etapach, co widać na poniższym rysunku:

image 

Gdzie wybór daty może przebiegać w trzech krokach:

  • wybór miesiąca np. wrzesień 2006
  • wybór tygodniach np. 10 – 16 września
  • wybór dnia tygodnia środa 12 września

W każdym żądaniu HTTP jest przekazywany nagłówek User-Agent, w którym znajduje się ciąg znaków identyfikujący przeglądarkę z jakiej korzysta użytkownik. ASP.NET przechowuje w plikach o rozszerzeniu browser konfigurację sposobu wyświetlania strony w zależności od przeglądarki. Globalnie pliki te przechowywane są w katalogu c:\Windows\Microsoft.NET\Framework\v2.0.50727\CONFIG\Browsers\. Właśnie na podstawie tych plików ASP.NET decyduje w jaki sposób ma zostać wyświetlona strona, czy to kontrolki (np. Calendar pokazany wyżej).

Dodatkowo programista z poziomu kodu behind może sprawdzić, czy żądanie przyszło z urządzenia mobilnego, czy nie. Na podstawie tej informacji może wykonać odpowiedni kod. Aby to sprawdzić, wystarczy sprawdzić wartość właściwości Request.Browser.IsMobileDevice.

   1: if(Request.Browser.IsMobileDevice)
   2: {
   3:     //kod dla mobilnej wersji   
   4: }else
   5: {
   6:     //kod dla wersji normalnej
   7: }

Tagi: , , , ,

70-562: Working with User Profiles

Artykuł pochodzi w serii przygotowań do egzaminu 70-562 ASP.NET.

ASP.NET udostępnia programiście mechanizm profili, który może wykorzystać do przechowywania informacji specyficznych dla poszczególnych użytkowników. Informacje przechowywane mogę być dowolne np. szablon strony, adres zamieszkania lub dowolne dane potrzebne do działania aplikacji. Dane te są przechowywane między kolejnymi wizytami użytkownika na stronie. ASP.NET automatycznie ładuje dane z źródła na podstawie tożsamości użytkownika. W tym artykule zostanie opisana praca z mechanizmem profili ASP.NET.

Aby wykorzystać powyższy mechanizm należy zrobić kilka kroków:

  • Konfiguracja providera, który zostanie wykorzystany przez mechanizm
  • Zdefiniować przechowywane dane
  • Ustawić i zapisać dane w profilu
  • Rozpoznać powracającego użytkownika i wykorzystać dane w profilu

Konfiguracja providera

Domyślnie ASP.NET posiada skonfigurowanego SqlProfileProvidera, który przechowuje dane w lokalnej bazie danych MS Sql Server. Baza ta znajduje się w pliku (ASPNETDB.MDF) i jest w katalogu App_Data. Natomiast domyślna konfiguracja znajduje się w pliku machine.config i wygląda następująco:

   1: <connectionStrings>
   2:     <add name="LocalSqlServer" 
   3:         connectionString="data source=.\SQLEXPRESS;Integrated Security=SSPI;AttachDBFilename=|DataDirectory|aspnetdb.mdf;User Instance=true" 
   4:         providerName="System.Data.SqlClient"/>
   5: </connectionStrings>
   1: <profile>
   2:     <providers>
   3:         <add name="AspNetSqlProfileProvider"
   4:             connectionStringName="LocalSqlServer"
   5:             applicationName="/"
   6:             type="System.Web.Profile.SqlProfileProvider, System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"/>
   7:     </providers>
   8: </profile>

W przypadku, gdy programista chce skorzystać z innej bazy musi zmienić connectionStringa, który będzie zawierał informacje o sposobie połączenia z bazą oraz musi wygenerować odpowiednią strukturę danych w bazie. Aby wygenerować odpowiednią strukturę wystarczy skorzystać z narzędzia aspnet_regsql.exe, które znajduje się w katalogu %windows%\Microsoft.NET\Framework\%version%, a jego składania powinna wyglądać mniej więcej tak:

   1: aspnet_regsql.exe -E -S localhost -Ap

Gdzie parametr S oznacza serwer z którym ma się połączyć narzędzie (tutaj localhost), parametr E oznacza, że łącząc się z serwerem ma zostać wykorzystana tożsamość konta Windows oraz parametr –Ap oznacza wygenerowanie tabel potrzebnych do działania mechanizmu profili.

Sama narzędzie aspnet_regsql.exe jest dużo bardziej rozbudowane, ponieważ umożliwia generowanie nie tylko tabel dla profili ale również dla membershipprovidera, roleprovidera oraz web parts.

Definicja danych profilu

Mając już skonfigurowanego providera dla mechanizmu profili, następnym krokiem jest zdefiniowane danych jakie profil będzie mógł przechowywać. Dane definiujemy w pliku konfiguracyjnym web.config. Poniżej znajduje się przykład, który umożliwia przechowywanie imienia, nazwiska oraz datę ostatniej wizyty użytkownika. Jak widać dla danych o typie string nie trzeba podawać typu, ponieważ jest to domyślny typ danych.

   1: <system.web>
   2:     <profile>
   3:         <properties>
   4:             <add name="FirstName"/>
   5:             <add name="LastName"/>
   6:             <add name="LastVisit" type="System.DateTime"/>
   7:         </properties>
   8:     </profile>
   9: </system.web>

Dodatkowo możemy ustawić, że część pól profilu będzie mogła być ustawiana dla użytkowników anonimowych. W tym celu należy przy definicji danego pola dodać atrybut allowAnonymous="true" oraz dodać element <anonymousIdentification enabled="true"/> do system.web. W przypadku nieuwierzytelnionych użytkowników ASP.NET generuje unikalną wartość, która później zapisuje do pliku cookie, na podstawie, której później może zidentyfikować powracającego użytkownika.

Ustawianie i zapisywanie danych w profilu

Ustawianie i zapisywanie danych jest bardzo proste. Programista ma dostęp do właściwości Profile, które jest generowana na podstawie pliku web.config i zawiera wszystkie zdefiniowane tam właściwości. Na koniec po ustawieniu wszystkich właściwości trzeba wywołać metodę Save.

   1: Profile.FirstName = "Daniel";
   2: Profile.LastName = "Plawgo";
   3: Profile.Save();

Odczytywanie danych z profilu

Odczytanie danych jest jeszcze łatwiejsze niż ich zapis. ASP.NET automatycznie ładuje dane użytkownika na podstawie jego tożsamości i już w kodzie aplikacji możemy korzystać z właściwości Profile, która ma ustawione wszystkie właściwości na dane wcześniej zapisane.

   1: FirstNameTextBox.Text = Profile.FirstName;
   2: LastNameTextBox.Text = Profile.LastName;

Tagi: , , , ,

70-562: Troubleshooting a Running ASP.NET Application

Artykuł pochodzi w serii przygotowań do egzaminu 70-562 ASP.NET.

Nie wszystkie problemy z aplikacją ASP.NET mogą zostać znalezione za pomocą Visual Studio. Dlatego ASP.NET udostępnia możliwość śledzenia oraz sprawdzenia sposobu wykonywania się kodu aplikacji w środowisku testów oraz produkcyjnym. Dzięki czemu programista może zbadać działanie aplikacji podczas problemów, które jest trudno odtworzyć na maszynie developerskiej.

Tracing

Tracing (śledzenie) jest procesem zwracania programiście informacji o działającej aplikacji. W ASP.NET dane te zostają zapisane do pliku, który później można przejrzeć za pomocą przeglądarki. Dane te zawierają ważne dane o aplikacji. Takie jak: kto odwiedza witrynę, rezultaty jakie są otrzymywane, jak wyglądają dane protokołu HTTP i wiele, wiele innych.

Uruchomić Tracing można na dwa sposoby (które tak na prawdę robią to samo): za pomocą narzędzia administracyjnego witryny sieci Web oraz dodając odpowiedni wpis w pliku konfiguracyjnym Web.config.

Aby włączyć Tracing za pomocą narzędzia administracyjnego witryny sieci Web, uruchamiany to narzędzie za pomocą ikony w solution explorer (taki “globus z motkiem”). Następnie przechodzimy do zakładki Aplikacja i tam mamy link do strony konfiguracji debugowania oraz śledzenia. Na stronie tej zaznaczamy “Przechwytuj informacje o śledzeniu”. Dodatkowo możemy sobie ustawić różne ustawieni śledzenia. Poniżej screen strony:

image

Narzędzia administracyjne witryny sieci web tak naprawdę dodaje odpowiedni wpis w pliku konfiguracyjnym Web.config. To samo można było zrobić dodając poniższy fragment do tego pliku:

   1: <trace enabled="true"
   2:        requestLimit="100"
   3:        pageOutput="false"
   4:        traceMode="SortByTime"
   5:        localOnly="false"
   6:        mostRecent="true" />

Gdzie kolejne opcje oznaczają:

  • enabled – ustawienie na wartość true powoduje uruchomienie w aplikacji Tracing
  • requestLimit – ilość rekordów przechowywanych w cachu lub pliku logów
  • pageOutput – za pomocą tej opcji można ustawić, czy informację o Tracing są wyświetlane na poszczególnych stronach (dane te wyświetlają są na samym końcu strony)
  • traceMode – sposób sortowania wpisów
  • localOnly – możliwość ustawienia, że informację będę wyświetlana tylko dla lokalnych połączeń do witryny
  • mostRecent – ustawienie przechowywania informacji o ostatnich żądaniach do strony

Informacje zbierane przez Tracing można wyświetlić na dwa sposoby: otworzyć stronę trace.axd w głównym katalogu aplikacji lub ustawić wyświetlanie informacji na poszczególnych stronach (na takiej stronie trzeba ustawić właściwość Trace na true w dyrektywie Page na samej górze strony).

Programista może sobie sam programowo dodać wpisy do mechanizmu Tracing. W przestrzeni nazw System.Diagnostics znajduje się klasa Trace, która posiada metodę write dodającą wpis do mechanizmu Tracing. Przykładowa wywołanie metody to:

   1: Trace.Write("Kategoria", "Test");

Gdzie wpis znajdzie się w kategorii “Kategoria”, a jego treść to “Test”.

Monitorowanie aplikacji

Mechanizm Tracing bardzo przydaje się do znajdowania błędów i problemów z poszczególnymi stronami. Z drugiej strony bardzo często programista potrzebuje otrzymać informacji o działaniu całej aplikacji. ASP.NET zawiera szereg klas umożliwiających monitorowania działania strony. Monitorowane są zdarzenia wywoływane przez aplikację.

Aby uruchomić monitorowanie wystarczy dodać do pliku konfiguracyjnego web.config odpowiedni wpis. Poniżej przykład:

   1: <healthMonitoring enabled="true" heartbeatInterval="1">
   2:   <rules>
   3:     <add name="Heart Beat"
   4:          eventName="Hearbeats"
   5:          profile="EventLogProvider"
   6:          provider="Default"/>
   7:   </rules>
   8: </healthMonitoring>

Tagi: , , , ,

Visual Studio 2010 Community Launch w Olsztynie

Już 5 maja 2010 roku (środa) o godzinie 17:00 na Wydziale Matematyki i Informatyki UWM w Olsztynie startuje Visual Studio 2010 Community Launch.

12 kwietnia 2010 roku miała swoją premierę nowa wersja środowiska programistycznego firmy Microsoft - Visual Studio 2010. Kolejna odsłona tego świetnego produktu umożliwia programiście szybsze i wydajniejsze tworzenie aplikacji biznesowych.

Polskie społeczności skupione wokół produktów firmy Microsoft organizują w swoich miastach spotkania, mające na celu przybliżenie najnowszej wersji środowiska Visual Studio tak swoim członkom, jak i innym chętnym poszerzenia swojej wiedzy.

Jednym z miast, które bierze udział w cyklu, jest Olsztyn. W środowy wieczór będzie można obejrzeć dwie prezentacje na temat Visual Studio 2010:

· Nowości w Visual Studio 2010 - Sesja ma za zadanie wprowadzić uczestników w tematykę związaną z Visual Studio 2010, przede wszystkim zaś w zmiany, które w nim zaszły oraz wprowadzone nowości.

· IntelliTrace - nowe podejście do śledzenia aplikacji - Debbuger historyczny to narzędzie, który zupełnie zmieni sposób pracy programisty. To swoista "maszyna czasu dla deweloperów i testerów". Rejestruje historię działania aplikacji i pozwala odtworzyć to, jak doszło do wystąpienia danego błędu. Sesja ma przybliżyć to narzędzie użytkownikom.

W przerwie między prezentacjami będzie można zintegrować się ze społecznością oraz zebrać siły przed drugą prezentacją, posilając się dużą ilością pizzy J

Wśród uczestników spotkania rozlosowane zostaną cenne nagrody o łącznej wartości ok. 10 000zł! Będą to między innymi licencje na produkty, takie jak Telerik Premium Collection o wartości 1299$, ReSharper, Nevron Chart for .NET Lite, Gauge for SSRS, CodeRush with Refactor! Pro czy Typemock Isolator. Do rozdania mamy także książki ufundowane przez wydawnictwo O’Reilly – CLR via C# oraz C# 4.0 in a Nutshell.

Udział w wydarzeniu jest bezpłatny, wymagana jest rejestracja na stronie.

Przyjdź na Visual Studio 2010 Community Launch, poznaj najnowsze środowisko programistyczne Micosoftu, poszerz swoją wiedzę i dobrze baw się z nami!!!

Tagi: , ,

70-562: Using Web Site Programmability

Artykuł pochodzi w serii przygotowań do egzaminu 70-562 ASP.NET.

Tworząc aplikacje internetowe istnieje kilka scenariuszy, które różnią się od typowego scenariusza żądanie – obsługa żądania. Przykładem takich scenariuszy może być łapanie wyjątków na poziomie całej strony lub całej aplikacji, wykonywanie zadań asynchronicznie, tworzenie specyficznych handlerów dla protokołu HTTP.

Dzisiejszy artykuł będzie właśnie opisywał tego typu scenariusze.

Wyjątki na poziomie aplikacji oraz strony

Tworząc aplikacji programiści wykorzystują wyjątki oraz bloki try-catch do obsługi sytuacji wyjątkowych. Aby obsługa ta była efektywna w bloki try-catch powinno się obejmować jak najmniejsze fragmenty kodu. Takich przykładem może być fragment kodu, w którym następuje połączenie do bazy danych i wyciągnięcie z niej informacji. Jednakże programista na ogól nie jest w stanie lub nie opłaca mu się to, aby tworzyć kod dla wszystkich możliwych do wyrzucenia wyjątkach. Dlatego ASP.NET umożliwia wyłapywanie wyjątków na poziomie całej strony lub całej aplikacji.

W celu wyłapania wszystkich wyjątków występujących na danej stronie, które nie zostały obsłużone wystarczy dodać do kodu strony metodę Page_Error, która może wyglądać następująco:

   1: protected void Page_Error(object sender, EventArgs e)
   2: {
   3:     var error = Server.GetLastError(); //wyciągnięcie ostatniego błędu
   4:     string message = error.Message;
   5:     Server.ClearError(); //wyczyszczenie listy błędów
   6:     Response.Write("Nieoczekiwany błąd: " + message); //wyświetlenie komunikatu
   7: }

Co ważne, informacje o nieobsłużonym wyjątku musimy wyciągnąć za pomocą metody GetLastError właściwości Server klasy Page. Mając już wyjątek jaki wystąpił, możemy coś z nim zrobić (np. wyświetlić użytkownikowi informację o błędzie). Na koniec warto jeszcze wyczyścić listę błędu, które wystąpiły za pomocą metody ClearError właściwości Server. Z poziomu metody Page_Error programista nie ma dostępu do kontrolek znajdujących się na stronie.

ASP.NET umożliwia również wyłapywanie nieobsłużonych wyjątków na poziomie samej aplikacji. Aby dodać obsługę wystarczy dodać do klasy Global znajdującej się w pliku Global.asax metodę Application_Error, która może wyglądać następująco:

   1: protected void Application_Error(object sender, EventArgs e)
   2: {
   3:     //kod wykonany, gdy nastąpił nieobslużony wyjątek
   4:     Server.Transfer("HandleError.aspx");
   5: }

Podobnie jak w przypadku wyłapywaniu wyjątków na poziomie pojedynczej strony mamy dostęp do właściwości Server.

Dostęp do pliku Web.config

ASP.NET udostępnia również możliwość z programowego dostępu do pliku Web.config, w którym znajduje się konfiguracja aplikacji. W tym celu trzeba skorzystać z klasy WebConfigurationManager znajdującej się w przestrzeni nazw System.Web.Configuration. Aby odczytać jakąś sekcje z pliku konfiguracyjnego, wywołujemy metodę GetSection klasy WebConfigurationManager i przekazujemy do niej sekcje jaką chcemy odczytać. Co ważne, metoda ta zwraca typ object, dlatego musimy jeszcze zrzutować na odpowiedni typ związany z daną sekcją. Poniżej przykład kod, za pomocą którego można odczytać tryb uwierzytelniania.

   1: AuthenticationSection section =
   2:     (AuthenticationSection) WebConfigurationManager.GetSection("system.web/authentication");
   3:  
   4: string mode = section.Mode.ToString();

Klasa WebConfigurationManager umożliwia również odczytywanie ustawień aplikacji zdefiniowanych przez programistę w pliku konfiguracyjnym. Wystarczy skorzystać z właściwości AppSettings, jak to widać niżej na przykładzie:

   1: string mySetting = WebConfigurationManager.AppSettings["MySetting"];

Również klasa ta umożliwia łatwe odczytanie connection stringa z pliku Web.config. Wystarczy skorzystać z właściwości ConnectionStrings:

   1: string connectionString = WebConfigurationManager.ConnectionStrings["MyConnection"].ConnectionString;

Klasa WebConfigurationManager bardzo dobrze nadaje się do odczytywania ustawień aplikacji, już gorzej jest z zapisywaniem nowych ustawień. W celu zmiany ustawień i zapisania powinno skorzystać się z klasy Configuration z przestrzeni nazw System.Configuration.

W celu zmiany konfiguracji wywołujemy metodę OpenWebConfiguration klasy WebConfigurationManager, która właśnie zwraca obiekt klasy Configuration. Następnie za pomocą metody GetSection wyciągamy odpowiednią sekcję z pliku. Zmieniamy właściwości i na koniec wywołujemy metodę Save obiektu klasy Configuration. Najlepiej to zobaczyć na przykładzie:

   1: Configuration configuration = WebConfigurationManager.OpenWebConfiguration(null);
   2: AuthenticationSection authenticationSection = (AuthenticationSection)configuration.GetSection("system.web/authentication");
   3: authenticationSection.Mode = AuthenticationMode.Forms;
   4: configuration.Save();

Natomiast, aby zapisać plik konfiguracyjnym w innym miejscu wystarczy wywołać metodę SaveAs i przekazać do niej nową lokalizację pliku.

HTTP Handler

HTTP Handler jest kodem, który jest wykonywany w przypadku żądania HTTP do serwera dla określonego zasobu. Przykładowym HTTP handlerem jest ASP.NET page handler, który jest uruchamiany, gdy do serwera przyjdzie żądanie od pliku *.aspx.

Programista może dodawać do aplikacji webowej swoje własne handlery, w celu wykonywania kod specyficznego dla danego typu zasobu. Takim przykładowym handlerem może być handler, który generuje obrazki z ciągiem znaków, który może posłużyć za mechanizm zabezpieczający formularz przed wysyłaniem zbędnych wiadomości.

Aby stworzyć swój własny handler wystarczy do projektu dodać klasę, która implementuje interfejs IHttpHandler. Implementując ten interfejs musimy zaimplementować jedną właściwość (IsReusable) oraz jedną metodę (ProcessRequest).

Właściwość IsReusable informuje ASP.NET, czy instancje handlera mogą być wykorzystywane kilkakrotnie, czy dla każdego nowego żądania powinien być tworzony od nowa handler.

Natomiast metoda ProcessRequest wykonuje właściwy kod dla danego żądania do zasobu. Przykładowa implementacja może wyglądać następująco:

   1: public class ImageHttpHandler : IHttpHandler
   2: {
   3:     #region IHttpHandler Members
   4:  
   5:     public bool IsReusable
   6:     {
   7:         get { return false; }
   8:     }
   9:  
  10:     public void ProcessRequest(HttpContext context)
  11:     {
  12:         context.Response.ContentType = "image/jpeg";
  13:         Image image = CreateImage();
  14:         context.Response.Write(image);
  15:     }
  16:  
  17:     private Image CreateImage()...
  18:  
  19:     #endregion
  20: }

Na koniec wystarczy do pliku Web.config do sekcji system.web dodać informacje o handlerze oraz zasobie, do jakiego ma być wywoływany handler:

   1: <httpHandlers>
   2:   <add verb="*" path="*.jpg" type="ImageHandler"/>
   3:   <add verb="*" path="*.gif" type="ImageHandler"/>
   4: </httpHandlers>

Tagi: , , , , , ,

70-562: Creating and Consuming WCF Services

Artykuł pochodzi w serii przygotowań do egzaminu 70-562 ASP.NET.

W dzisiejszym artykule będzie na temat tworzenia i korzystania z web serwisów wykorzystujących technologię Windows Communication Foundation. Artykuł będzie wprowadzeniem do tej technologii. Jeśli ktoś będzie bardziej zainteresowany nią, to po więcej informacji odsyłam do równoległej serii artykułów przygotowujących do egzaminu właśnie z WCFa.

Windows Communication Foundation to technologia, która po raz pierwszy pojawiła się wraz z wersją 3.0 .NET Frameworka. WCF jest to zunifikowany model programistyczny do wszelkiego rodzaju komunikacji rozproszonej. Dzięki WCFowi identycznie pracujemy z różnymi sposobami przesyłania danych przez sieć, niezależnie, czy fizycznie wykorzystujemy połączenia TCP, czy na przykład protokół HTTP i SOAPa.

W artykule tak jak już pisałem skupie się na podstawach, a dokładniej pokaże jak tworzyć serwis WCFa oraz jak go wykorzystywać w aplikacjach ASP.NET.

Aby stworzyć i korzystać z serwisu napisanego w WCFie, trzeba zrobić kilka kroków:

  1. Zdefiniować kontrakt serwisu
  2. Zaimplementować ten kontrakt
  3. Skonfigurować punkty dostępowe serwisu
  4. Hostować serwis
  5. Dodać referencje do serwisu w aplikacji klienckiej i go wykorzystywać

W Visual Studio jest specjalny typ projektu, który umożliwia stworzenie serwisu Windows Communication Foundation – WCF Service Application. Po stworzeniu tego typu projektu mamy domyślnie dodane między innymi dwa pliki: IService1.cs oraz Service1.svc, w których odpowiednio znajduje się kontrakt serwisu oraz jego implementacja.

Przeglądając zawartość pliku IService1.cs można zauważyć, że znajduje się tam jeden interfejs oraz jedna klasa. Od razu rzuca się w oczy, że sam interfejs i klasa są oznaczone specjalnymi atrybutami oraz metody i właściwości też są oznaczone. W WCFie, aby zdefiniować kontrakt wykorzystuje się atrybuty. Mamy 4 podstawowe atrybuty:

  • ServiceContract – za jego pomocą oznacza się interfejs lub klasę, która ma definiować kontrakt serwisu WCFowego. Atrybut ten może przyjmować parametry, za pomocą których można zdefiniować właściwości serwisu.
  • OperationContract – atrybut ten służy do oznaczania metod w interfejsie lub klasie kontraktu, która będzie w ramach jego wchodziła i którą klient będzie mógł wywoływać
  • DataContract – atrybutem tym oznacza się typu (klasy, struktury, wyliczenia), które będą przesyłane przez sieć.
  • DataMember – atrybutem tym oznacza się właściwości oraz pola klasy czy struktury, które mają być serializowane podczas przesyłania obiektów przez sieć.

Visual Studio bardzo pomaga tworzenie WCFowego serwisu. Wystarczy do projektu dodać WCF Service, a Visual Studio wygeneruje sam automatycznie szkielet pliku z interfejsem kontraktu, klasę implementująca dany serwis oraz odpowiednie wpisy w pliku Web.config.

Przykładowy kontrakt serwisu oznaczony powyższymi atrybutami może wyglądać tak:

   1: [ServiceContract]
   2: public interface ICustomerServices
   3: {
   4:     [OperationContract]
   5:     Customer GetCustomer(int id);
   6:  
   7:     [OperationContract]
   8:     void DeleteCustomer(int id);
   9: }
  10:  
  11: [DataContract]
  12: public class Customer
  13: {
  14:     [DataMember]
  15:     public int Id { get; set;}
  16:  
  17:     [DataMember]
  18:     public string FirstName { get; set;}
  19:  
  20:     [DataMember]
  21:     public string LastName { get; set;}
  22: }

Mając już zdefiniowany kontrakt wygenerowanym przez Visual Studio pliku *.svc implementujemy logikę serwisu.

Visual Studio automatycznie dodaj do Web.configa odpowiednie wpisy konfigurujące serwis (podstawową typową konfigurację). Wygląda ona następująco:

   1: <system.serviceModel>
   2:   <services>
   3:     <service behaviorConfiguration="WcfService1.CustomerServicesBehavior"
   4:   name="WcfService1.CustomerServices">
   5:       <endpoint address="" binding="wsHttpBinding" contract="WcfService1.ICustomerServices">
   6:         <identity>
   7:           <dns value="localhost" />
   8:         </identity>
   9:       </endpoint>
  10:       <endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange" />
  11:     </service>
  12:   </services>
  13:   <behaviors>
  14:     <serviceBehaviors>
  15:       <behavior name="WcfService1.CustomerServicesBehavior">
  16:         <serviceMetadata httpGetEnabled="true" />
  17:         <serviceDebug includeExceptionDetailInFaults="false" />
  18:       </behavior>
  19:     </serviceBehaviors>
  20:   </behaviors>
  21: </system.serviceModel>

Nie będę szczegółowo opisywał całej konfiguracji. Z ważniejszych rzeczy w niej są konfiguracji endpointów. Za ich pomocą definiuje się punkty dostępowe do serwisu. Jego adres, wykorzystywany binding itp.

Mając już stworzony serwis pozostaje tylko go wykorzystać. W tym celu trzeba wrzucić projekt na serwer i do innego projektu dodać referencje. Klikamy prawym na nazwę projektu i z menu wybieram Add Service Reference. W okienku, które się pojawi wpisuje adres serwisu, możemy sprawdzić sobie jakie kontrakty zawiera dany serwis oraz na koniec wygenerować klasy odpowiedzialne za komunikacje z serwisem. Okienko wygląda następująco:

image

Została wygenerowana klasa w tym przypadku CustomerServicesClient, za pomocą której możemy wywoływać metody serwisu, jak zwykłe metody:

   1: CustomerServicesClient client = new CustomerServicesClient();
   2: client.GetCustomer(20);

Co fajnie w WCFie jest to, że możemy korzystać z różnych sposób przesyłania informacji. Sam kod wykorzystujący serwis się nie zmienia, tylko wszystko jest ustawione w pliku konfiguracyjnym.

To byłoby by na tyle z podstaw Windows Communication Foundation. Jak ktoś jest bardziej zainteresowany tą technologią to polecam artykuły z serii przygotowującej do egzaminu z tej technologii.

Tagi: , , , , ,

Eastgroup.pl na facebooku