Eastgroup.pl

Spotkanie inauguracyjne 2011

Sun, 27 Feb 2011 13:37:00 +0100

Zapraszam na pierwsze, inauguracyjne spotkanie grupy w nowym semestrze, które odbędzie się w czwartek (13.10.2011) o godzinie 18:15 w sali D09.

Nie śpij – programuj!

Thu, 24 Feb 2011 14:55:00 +0100

Jesteś zapalonym programistą i chętnie podejmujesz nowe wyzwania? Nie może Cię zabraknąć na eliminacjach do 24-godzinnego maratonu programistycznego! Razem z przyjaciółmi stwórz trzyosobowy team i przekonaj się, jak wiele można zrobić w krótkim czasie, gdy pracuje się razem.

Ogólnopolskie zawody programistyczne Deadline24 to prawdziwy test wytrzymałości, kreatywnego myślenia i interdyscyplinarnej wiedzy. Po przejściu eliminacji, najlepsze drużyny zostaną zaproszone na finał do Gliwic, gdzie czekać je będzie 24-godzinny programistyczny maraton. Zawodnicy, odcięci od zewnętrznego świata, będą rywalizować między sobą, pisząc nietypowy program. O wygranej zadecyduje jakość wykonanej w tak krótkim czasie pracy. Uczestnicy mogą uzbroić się w dowolny sprzęt i oprogramowanie. Organizatorzy zapewniają każdej drużynie jedno gniazdko 230V i dostęp do wirtualnej areny - serwera konkursowego. Liczy się inwencja i praca zespołowa. W pierwszej edycji konkursu zadaniem informatyków była tresura żukoskoczków - musieli opanować motywowanie, ruch, a nawet rozmnażanie tych stworzonek, by uratować świat przed zagładą i negatywną energią. Tegoroczne zadanie będzie z pewnością nie mniej ekscentryczne.

Udział w zawodach jest bezpłatny. Zarówno w eliminacjach jak i w finale uczestnicy pracują na swoim sprzęcie, mając pełną swobodę wyboru systemu operacyjnego, środowiska i języka programowania. Eliminacje trwają 5 godzin, odbywają się zdalnie. Drużyny otrzymują zadania i dane wejściowe do zadań. Celem jest wygenerowanie (w dowolny sposób) odpowiedzi i przesłanie ich na serwer sprawdzający w wyznaczonym czasie. Finał trwa 24 godziny, odbywa się na Politechnice Śląskiej w Gliwicach. Uczestnicy mogą korzystać ze wszelkich materiałów przyniesionych ze sobą, lecz dostęp do pomocy zewnętrznej jest zabroniony. Zadanie będzie miało charakter interaktywny, komunikacja z serwerem konkursowym będzie się odbywała za pomocą TCP/IP.

Pomysł na organizację Deadline24 zrodził się na początku 2009 roku. Są to pierwsze tego typu zawody w Polsce. Organizatorami konkursu są: firma Future Processing i Politechnika Śląska. Strona www z poprzedniej edycji wraz z regulaminem, galerią, wynikami i zadaniem konkursowym jest dostępna pod adresem http://www.deadline24.pl.

Filozofią konkursu jest przyciągnięcie do udziału pasjonatów programowania, oryginalnych, kreatywnych i kompetentnych osób. Konkurs wyłoni młodych programistów o nieprzeciętnych umiejętnościach, indywidualistów w akademickim świecie IT, utalentowanych ludzi z branży. Konkurs ma niestandardową formułę. Promuje ludzi o wyjątkowych zdolnościach programistycznych, działających w nietypowych dla siebie warunkach.

Nagrody dla zwycięzców będą równie niezwykłe, jak programistyczne zadanie, z którym się zmierzą. Dobra zabawa gwarantowana! Eliminacje już 26 marca. Wejdź na stronę konkursu http://www.deadline24.pl, zapoznaj się z regulaminem i aplikuj! Drużyny, które pomyślnie przejdą pierwszy etap, wezmą udział w maratonie programistycznym. Konkurs rozpocznie się w Gliwicach 26 kwietnia i potrwa całą dobę.

Windows Phone 7

Tue, 30 Nov 2010 11:27:08 +0100

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:

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 ).

No dobra ale wracając do mojej prezentacji (a dokładnie dwóch ). 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 ) 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ć

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:

Trainig Kit dla Windows Phone 7, w którym znajduje się część dem, które pokazywałem i każdy może sobie ściągnąć, uruchomić i potestować - http://www.microsoft.com/downloads/en/details.aspx?FamilyID=ca23285f-bab8-47fa-b364-11553e076a9a&displaylang=en
darmową książkę o Windows Phone 7 autorstwa Charles Petzold, która opisuje jak tworzyć aplikacje dla Windows Phone 7 - http://blogs.msdn.com/b/microsoft_press/archive/2010/10/28/free-ebook-programming-windows-phone-7-by-charles-petzold.aspx

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

Hasło - aplikacja MVVM

Thu, 18 Nov 2010 22:13:00 +0100

Na prezentacji pokazałem sposób tworzenia aplikacji WPF z wykorzystaniem Visual Studio, Blend i wzorca projektowego MVVM. Kod i slajdy będą na SkyDrive grupy. Dzisiaj chcę wam pokazać jak można wykonać podobną aplikacje która może nam posłużyć do „wymyślania” haseł na konta ;p
To do dzieła.

1 Tworzymy nowy projekt.

Nowy projekt utworzymy z wykorzystaniem Blenda. Jeżeli ktoś nie ma Blenda może śmiało to samo wykonać w Visual Studio. Uruchamiamy Blenda po czym w okienku które nam wyskoczyło naciskamy New Project. Alternatywnie możemy zrobić to samo przez File-> New Project. Wybieramy typ projektu jako WPF Application. Nazywamy nasz projekt Haslo, zapamiętujemy gdzie go zapisujemy i klikamy OK.

2 Projektujemy widok

Powinno ukazać się nam okno domyślnie utworzone przez Blenda. Będziemy dążyć aby wygląd naszej aplikacji był taki jak niżej.

Tworzyć nasz widok możemy na dwa sposoby, poprzez przeciąganie kontrolek(niektórzy mogą preferować ten sposób) lub przez deklaracje bezpośrednio w kodzie. Ja osobiście wolę ta druga metodę wiec jej będziemy używać. Aby zobaczyć nasz kod klikamy na View-> Active Document View-> Split View ( będziemy widzieć kod i wygląd naszej aplikacji ). Zabieramy się za tworzenie widoku. Zaczynamy od zdefiniowania w naszym Gridzie dwóch wierszy do których będziemy przypisywać kontrolki. Uzyskujemy to przez następujący kod:

<Grid.RowDefinitions>
<RowDefinition Height="Auto"/>
<RowDefinition Height="auto"/>
</Grid.RowDefinitions>

Następnie dodajemy dwa StackPanele. Jeden przypisujemy do pierwszego wiersza, drugi do drugiego.

W pierwszym tworzymy Labela który będzie nam wyświetlać losowane liczby. Wielkość czcionki ustawiamy na 40, wyśrodkowujemy w pionie i poziomie. Jego zawartość(Content) musimy połączyć z właściwością ViewModel który będziemy tworzyć w dalszej części. Drugi StackPanel będzie troche bardziej złożony. W jego wnętrzu deklarujemy dwa kolejne StackPanele. W obu ustawiamy orientację na poziomą i wyrównujemy w poziomie na środek. Do tej pory nasz fragment powinien wyglądać następująco.

Postępujemy analogicznie jak w przypadku pierwszego. Wypełniamy drugi następującym kodem:

Przy przyciskach pojawila się nowa właściwość – Command.

Nasz widok powinien być już gotowy. Później będziemy musieli na chwile do niego wrócić alby połaczyć nasz ViewModel z przed chwila utworzonym widokiem. Budujemy nasz projekt (Ctrl+Shift+B)

3 Visual Studio

W tej części zajmiemy się logika naszej aplikacji. Otwieramy w Visual Studio projekt który wczesniej utworzyliśmy. Na początku zajmiemy się utworzeniem naszego ViewModelu później przystąpimy do klas które będą mu potrzebne. Tworzymy nowa klasę :

Nazywamy ją MainViewModel i zatwierdzamy. Nowo utworzona klasa musi implementować interfejs INotifyPropertyChanged. Do tego potrzebne będzie nam dodanie przestrzeni nazw (using System.ComponentModel) . Aby przyśpieszyć sobie prace Visual Studio zaimplementuje go za nas. Klikamy prawym przyciskiem myszki na przed chwila zadeklarowanej implementacji, wybieramy Implement Interface -> Implement Interface.

Dodajemy metodę która będzie wywoływana przy każdej zmianie jakiejkolwiek właściwości. Będzie nam to potrzebne aby nasz widok mógł się zorientować, że zmiana miała miejsce i należy jego dane zaktualizować.

public void PropertyChangedInvoker(string name)
{
if (PropertyChanged != null)
{
PropertyChanged(this, new PropertyChangedEventArgs(name));
}
}

Teraz kolej nadeszła na utworzenie właściwości w naszej klasie, dodajemy następujący kod:

//wartosc suwaka w postaci double
private double _slider;
public double Slider
{
   get { return _slider; }
   set
{
   _slider = value;
   SliderValue = Convert.ToInt32(_slider);
   }
}

//pozycja suwaka w postaci int
private int _sliderValue;
public int SliderValue
{
   get { return _sliderValue; }
   set
   {
   _sliderValue = value;
   PropertyChangedInvoker("SliderValue");
   }
}

//liczby które są wyświetlane w widoku
private string _liczby;
public string Liczby
{
   get { return _liczby; }
   set
   {
   _liczby = value;
   PropertyChangedInvoker("Liczby");
   }
}

//odpowiada za trzymanie informacji czy przcisk Stop został nacisniety
private bool _stopButtonClicked;
public bool StopButtonClicked
{
   get { return _stopButtonClicked; }
   set
   {
   _stopButtonClicked = value;
PropertyChangedInvoker("StopButtonClicked");
   }
}

//odowiada za trzymanie informacji czy przycisk Stop jest aktywny
private bool _canStopButtonExecute;
public bool CanStopButtonExecute
{
   get { return _canStopButtonExecute; }
set
{
_canStopButtonExecute = value;
   PropertyChangedInvoker("CanStopButtonExecute");
}
}

Naszemu ViewModelowi dalej czegoś brakuje. W Widoku utworzyliśmy 2 przyciski. Teraz pokaże co zrobić żeby je trochę ożywić. Pierwszym zadaniem będzie utworzenie i klas które będą implementowały interface ICommand. Klasy będą nazywać się odpowiednio StartCommand i StopCommand. Sama implementacja wygląda dokładnie tak samo jak wcześniej pokazałem. Wcześniej jednak do każdej z nich musimy dodać następującą przestrzeń nazw - using System.Windows.Input; Po tym nasze klasy, w tym wypadku StartCommnad, powinny wyglądać tak:

class StartCommand : ICommand
{
public bool CanExecute(object parameter)
   {
   throw new NotImplementedException();
   }

   public event EventHandler CanExecuteChanged;

   public void Execute(object parameter)
{
throw new NotImplementedException();
}
}

Klasa posiada dwie metody i jeden event. Pierwsza metoda(CanExecute) jest wywoływana gdy event (CanExecuteChanged) zostanie „wzniesiony”. Tak nasz widok sprawdza czy dana komenda może być wykonana.

Druga metoda (Execute) zawiera kod który będzie wywołany w przypadku gdy komenda ma zostać wykonana ( w naszym przypadku przez naciśniecie przycisku).

Musimy trochę rozbudować nasze klasy gdyż puste metody niewiele nam pomogą J. Pierwszym krokiem będzie utworzenie konstruktora i dodanie referencji do naszego ViewModelu dla naszych klas. Pozwoli nam to odwoływać się do jego właściwości.

private readonly MainViewModel _vm;
public StartCommand(MainViewModel viewModel)
{
_vm = viewModel;
}

Dodamy teraz trochę logiki do naszych metod. Rozbudujemy tez nasz event.

public bool CanExecute(object parameter)
{
return _vm.CanStopButtonExecute == false && _vm.SliderValue != 10 && _vm.SliderValue != 0;
}

public event EventHandler CanExecuteChanged
{
add { CommandManager.RequerySuggested += value; }
remove { CommandManager.RequerySuggested -= value; }
}

public void Execute(object parameter)
{
_vm.CanStopButtonExecute = true;
System.Threading.ThreadPool.QueueUserWorkItem(_vm.Losowanie);
}

Wytłumaczenia wymagają dwie rzeczy. Pierwsza to co to jest losowanie. Losowanie to będzie metoda która będziemy jeszcze implementować w ViewModelu. Będzie ona odpowiedzialna za losowanie liczb. Drugą rzeczą dla niektórych może być tajemnicze wywołanie metody -System.Threading.ThreadPool.QueueUserWorkItem. Pozwala nam ono wykonać dana metodę w osobnym wątku które będzie „obliczać” swoje rzeczy niezależnie od głównego wątku naszej aplikacji. Więcej informacji znajdziecie we wcześniejszych wpisach z tamtego roku. Dlaczego tak ? Nie chcemy aby nad naszą aplikacja pojawiła się klepsydra :P Nie odpowiadałaby ona na nasze żądania.Teraz do rzeczy bo zostało nam trochę roboty jeszcze. Druga nasza klasa powinna wyglądać podobnie:

class StopCommand : ICommand
{
   private readonly MainViewModel _vm;
   public StopCommand(MainViewModel viewModel)
   {

_vm = viewModel;
   }

   public bool CanExecute(object parameter)
   {

return _vm.CanStopButtonExecute;
}

public event EventHandler CanExecuteChanged
{

add { CommandManager.RequerySuggested += value; }
remove { CommandManager.RequerySuggested -= value; }
}

public void Execute(object parameter)
{

_vm.StopButtonClicked = true;
}
}

Musimy teraz „podpiąć” dopiero co stworzone klasy do ViewModelu. Przechodzimy do niego i tworzymy kolejne dwie właściwości i w konstruktorze przypisujemy do nich nowe obiekty:

public ICommand Start { get; set; }

public ICommand Stop { get; set; }
public MainViewModel()
{

Start = new StartCommand(this);
Stop = new StopCommand(this);
}

Dokładnie do tych dwóch właściwości bindowaliśmy nasze przyciski poprzez Command.

Kolejnym krokiem ( obiecuje ze już nie wiele tego zostało ) jest utworzenie klasy która będzie nam losować liczby o danej długości jak i metoda o której wcześniej wspomniałem. Zaczniemy od klasy.

Tworzymy i nazywamy ja Losomat. Oto logika która jest w niej zawarta:

public static class Losomat

{

private const int max = 999999999;

private const int min = 100000000;

private static readonly Random Random = new Random();

public static string Losuj(int ilosc)

{

return

Random.Next(Convert.ToInt32(min / Math.Pow(10, 9 - ilosc)), Convert.ToInt32(max / Math.Pow(10, 9 - ilosc))).ToString();
}
}

Mam nadzieje że wszytko w niej jest jasne.

Weźmiemy się teraz za metodę. Przechodzimy do ViewModelu i dodajemy.

public void Losowanie(object param)
{
for (int i = 0; i < SliderValue; i++)

{

Liczby += "0";

}

for (int i = SliderValue; i > 0; i--)

{

while (!StopButtonClicked)

{

var temp = Losomat.Losuj(i);

Liczby = Liczby.Substring(0, SliderValue - i) + temp;

System.Threading.Thread.Sleep(10);

}

StopButtonClicked = false;

}

CanStopButtonExecute = false;
}

Rzeczą która może się przydać z tego kawałka kodu może być System.Threading.Thread.Sleep. Jest to metoda która usypia dany watek na podana ilość czasu. Czas podajemy w milisekundach.

Ostatnia rzeczą jaka musimy wykonać jest złączenie Widoku z ViewModelem. Przechodzimy do Widoku, przed Gridem dodajemy przestrzeń nazw i definiujemy zasób dla naszego okna.

xmlns:Haslo="clr-namespace:Haslo"
<Window.Resources>

<Haslo:MainViewModel x:Key="ViewModel"/>
</Window.Resources>

Łączymy nasz nowy zasób z Gridem poprzez DataContext:

W ostateczność nasz początek kodu Widoku powinien wyglądać następująco :

<Window.Resources>
<Haslo:MainViewModel x:Key="ViewModel"/>
</Window.Resources>

Po tych wszystkich bojach możemy przystąpić do kompilacji naszego programu i cieszyć się jego możliwościami :D Kod z komentarzami będzie można pobrać z linku niżej.

Haslo.rar (223,85 kb)

Express App Framework - wstęp

Mon, 15 Nov 2010 14:51:00 +0100

Ostatnio w ramach grupy .NET, miałem okazję na prezentacji, opowiedzieć Wam o XAF-ie. Po prezentacji wpadłem na pomysł żeby założyć bloga, i opisać ten Framework. Dlatego też, nie będę umieszczał materiałów które prezentowałem, a w zamian w ramach autopromocji zapraszam Was na http://dawidtulski.net :) Tam w cyklu wpisów, znajdziecie na pewno to co już pokazywałem oraz wiele innych (mam nadzieje ciekawych) rzeczy dotyczących XAF-a.

Ustalenia po spotkaniach organizacyjnych

Mon, 25 Oct 2010 10:11:00 +0100

Hej :)

W ubiegłym tygodniu odbyły się dwa, organizacyjne, spotkania grupy. Postanowiliśmy, że tak, jak w latach poprzednich, będą dwa typy spotkań: Warsztaty oraz Prezentacje. Na warsztatach, w tym semestrze będziemy uczyli się C# oraz pisali małe projekty. Spotkania zawsze będą odbywały się we wtorki (prezentacje) o godzinie 17.30 oraz w czwartki (warsztaty) o godzinie 19.

Zapraszam również na jutrzejsze spotkanie (wtorek 26.10), na którym Mateusz Jaskółowski opowie o tworzeniu aplikacji w WPF z użyciem wzorca MVVM. Opowie również o narzędziu do tworzenia wyglądu naszej aplikacji WPF. Zapraszamy!

Nie zapomnijcie zarejestrować się na: https://codeguru.pl/group-82/LectureDetails/1,4686.aspx

Pierwsze, powakacyjne spotkanie

Wed, 13 Oct 2010 08:54:00 +0100

Witam Was w nowym roku akademickim!

Czas zacząć spotkania naszej grupy :) Już niebawem, bo we wtorek 19 października o godzinie 18.00 w sali 49 na Wydziale Matematyki i Informatyki odbędzie się pierwsze powakacyjne spotkanie. Będzie to spotkanie organizacyjne, na którym chcemy ustalić jak będą wyglądały spotkania w tym roku, co chcielibyście robić na warsztatach, prezentacje na jaki temat chcielibyście usłyszeć itp.Będzie też trochę o nowych zasadach premiowania aktywnych uczestników i wiele więcej.
Gorąco zapraszamy.

P.S Przypominam o rejestracji na spotkanie: https://codeguru.pl/group-82/LectureDetails/1,4622.aspx

Konkurs – vouchery na egzamin - pytania

Fri, 11 Jun 2010 12:00:00 +0100

Tak jak wczoraj pisaliśmy, dzisiaj publikujemy dwadzieścia pytań związanych z egzaminami, do których w ciągu ostatnich trzech miesięcy publikowaliśmy artykuły przygotowujące. Pytania są zamknięte i pierwsza osoba, która w komentarzu (przypominamy o poprawnym podaniu adresu email, na który wyślemy vouchery) poda poprawną odpowiedz na wszystkie pytania otrzyma nagrodę voucher na egzamin oraz voucher na kurs e-learningowy ASP.NET 3.5. Poniżej lista pytań:

70-562 – ASP:

Masz DataSet zawierającego Customer DataTable oraz Order DataTable. Chcesz łatwo przechodzić z Order DataRow do Customer, który jest autorem zamówienia. Który obiekt umożliwi Ci łatwe przechodzenie z obiektów Order do obiektów Customer?

A. DataColumn

B. DataTable

C. DataRow

D. DataRelation
Która z poniższych metod klasy HttpServerUtility może zostać użyta to przejścia na inną stronę aplikacji bez przesyłania o tym informacji do klienta:

A. Redirect

B. MapPath

C. Transfer

D. UrlDecode
Potrzebujesz przechowywać dane, które są dostępne dla każdego użytkownika, który odwiedza Twoją stronę. Jakiej kolekcji powinieneś użyć w tym celu?

A. Session

B. Application

C. Cookies

D. ViewState
Co musisz dodać do connection stringa, aby umożliwić dostęp do danych asynchroniczny?

A. BeginExecute=true

B. MultiThreaded=true

C. MultipleActiveResultSets=true

D. Asynchronous Processing=true
Potrzebujesz generować dynamicznie dokumenty Worda, kiedy po aplikacji przychodzi żądanie pobrania pliku, którego rozszerzeniem jest .docx. Jak możesz to zrobić?

A. Zaimplementować interfejs IPartitionResolver

B. Zaimplementować interfejs IHttpModule

C. Zaimplementować interfejs IHttpHandler

D. Zaimplementować interfejs IHttpHandlerFactory
Której klasy użyjesz podczas konwersji między typami danych .NET Framework a typami XML?

A. XmlType

B. XmlCast

C. XmlConvert

D. XmlSettings
Tworzysz aplikację webową w ASP.NET w dziesiątkami stron wchodzących w jej skład. Chcesz zapisać preferencje użytkownika, tak aby można było się do tych informacji dostać z każdej strony. Dodatkowo chcesz, aby te ustawienia były zapamiętywany między kolejnymi wizytami użytkownika, nawet jak zamknie przeglądarkę. Który mechanizm zapamiętywania stanu po stronie klienta użyjesz?

A. View state

B. Control state

C. Hidden fields

D. Cookies

E. Query strings
Jaki tym uwierzytelniania na poziomie aplikacji musicie skonfigurować, aby móc skorzystać z domyślnego membership providera – AspNetSqlMembershipProvider?

A. Windows

B. Forms

C. Passport

D. None
Potrzebujesz dynamicznie zmienić master page dla strony. W którym zdarzeniu strony to zrobisz?

A. Page_Load

B. Page_Render

C. Page_PreRender

D. Page_PreInit
Chcesz napisać serwis WCF, który będzie hostowany przez IIS. Który typ projektu powinieneś użyć?

A. WCF Service library

B. WCF Service application

C. ASP.NET Web Service application

D. Windows Service

70-503 – WCF:

Mamy klasę:
```
[ServiceBehavior()]
```
```
public class ServiceImplementation : IServiceInterface
```
```
{
```
```
    private int hitCounter;
```
```
    public void Increment()
```
```
    {
```
```
        hitCounter++;
```
```
    }
```
```
}
```
Jak należy udekorować klasę ServiceImplementation aby problemy współbieżności zostały wyeliminowane bez dodawania kodu w klasie? (Wybierz wszystkie poprawne odpowiedzi)

A. ConcurrencyMode=Multiple i InstanceContextMode=Single

B. ConcurrencyMode=Single i InstanceContextMode=PerSession

C. ConcurrencyMode=Multiple i InstanceContextMode=PerSession

D. ConcurrencyMode=Single i InstanceContextMode=Single
Który z poniższych punktów rozszerzenia (po stronie serwisu) musi być też zaimplementowany po stronie klienta?

A. Message Inspection

B. Message Formatting

C. Parameter Inspection

D. Operation Invoker
W obiekcie wiadomości właściwość MessageState jest ustawiona na Written. Które z poniższych zdarzeń zaszło?

A. Metoda GetReaderAtBodyContents została wywołana.

B. Metoda WriteBodyContents została wywołana.

C. Metoda CreateBufferedCopy została wywołana.

D. Metoda CreateMessage została wywołana.
Właśnie definiujesz nowy kontrakt serwisu. Które z poniższych reprezentują atrybuty z przestrzeni System.ServiceModel, które na pewno będą potrzebne?

A. ServiceContractAttribute i FaultContractAttribute

B. OperationContractAttribute i FaultContractAttribute

C. ServiceContractAttribute i OperationContractAttribute

D. OperationContractAttribute i MessageParameterAttribute
Będziesz obsługiwać serwis napisany w javie. Które z poniższych są poprawnymi metodami utworzenia proxy WCF do obsługi serwisu? (Wybierz wszystkie poprawne)

A. Użyj klasy ChannelFactory class do utworzenia obiektu proxy dynamicznie.

B. Użyj polecenia svcutil do utworzenia obieku proxy na podstawie definicji WSDL

C. Ręcznie utwórz klasę proxy dziedziczącą po ClientBase.

D. Dodaj referencję serwisu w Visual Studio (dodając referencję WSDL serwisu do projektu).
Potrzebujesz uruchomić serwis na serwerze IIS. Która wersja IIS obsługuje protokoły nie-HTTP?

A. IIS 5.1

B. IIS 6.0

C. IIS 7.0

D. Żadna z wersji IIS
Utworzyłeś aplikację kliencką WCF, która musi obsługiwać wywołanie zwrotne z serwisu. Który z bindingów użyjesz aby spełnić to wymaganie?

A. basicHttpBinding

B. wsHttpBinding

C. wsHttpContextBinding

D. wsDualHttpBinding
Utworzyłeś aplikację kliencką WCF, która musi obsługiwać wywołanie zwrotne z serwisu. Który z poniższych bindingów NIE wspiera tego wymagania?

A. netTcpBinding

B. netNamedPipeBinding

C. netMsmqBinding

D. netTcpContextBinding

Jaki będzie rezultat poniższego kodu?

using (TransactionScope ts1 = new TransactionScope(

    TransactionScopeOption.Required,

    new Timespan(0, 0, 30)))

    using (TransactionScope ts2 = new TransactionScope(

        TransactionScopeOption.Required,

        new Timespan(0, 0, 40)))

        // Update database

        // Sleep for 35 seconds

        ts2.Complete();

    ts1.Complete();

A. Obie transakcje zostaną zatwierdzone.

B. Obie transakcje zostaną wycofane.

C. Transakcja ts2 zostanie zatwierdzona a ts1 wycofana.

D. Transakcja ts1 zostanie zatwierdzona, a ts2 wycofana.

Masz aplikację Windows Forms. W pojedynczej transakcji Twoja aplikacja musi zaktualizować dwie bazy Microsoft SQL Server. Który koordynator transakcji zarządza tymi transakcjami?

A. Lightweight Transaction Manager

B. Microsoft Distributed Transaction Controller

C. Kernel Transaction Manager

D. Web Services Transaction Manager

Powodzenia!

Konkurs – vouchery na egzamin

Thu, 10 Jun 2010 10:30:00 +0100

Tak jak zapowiadaliśmy wcześniej, mamy dla Was niespodziankę!

Mamy do rozdania kilka nagród:

2 vouchery na dowolny egzamin (ważne do 30 lipca 2010)
2 vouchery na kurs e-learningowy 6364: Visual Studio 2008 ASP.Net 3.5 (ważne do 30 czerwca 2010)

Chcieliśmy podziękować Olsztyńskiej Grupie IT za vouchery. Dzięki!!!

Konkurs na najlepszą “zajawkę”

Waszym zadaniem jest napisanie notki z linkami (70-536, 70-562, 70-503) do naszych kursów w jakimś blogu/serwisie. Najlepsza “zajawka” będzie nagrodzona: voucherem na egzamin, a kolejna voucherem na kurs e-learningowy.

Termin zgłaszania “zajawek” (termin wpisania linku do nich w komentarzach) godz. 12.00, poniedziałek 14 czerwca 2010 r!

Konkurs na najszybszego czytelnika

Jutro (piątek 11 czerwca 2010) o godzinie 12.00 pojawią się 20 pytania z zakresu przedstawianych przez nas kursów (dziesięć z WCF, dziesięć z ASP.NET).

Najszybsza osoba, która wpisze w komentarzu poprawne odpowiedzi na wszystkie pytania otrzyma voucher na egzamin i voucher na kurs e-learningowy.

Skrócony regulamin:

nagrody nie podlegają wymianie na ich wartość pieniężną
wszelkie konflikty rozwiązuje oraz “zajawki” ocenia komisja w składzie: Daniel Plawgo, Dawid Cieszyński, Kamil Lemański, Daniel Jarzynka, Dawid Tulski
członkowie komisji nie mogą brać udziału w konkursach
do komunikacji z zwycięzcami będzie użyty adres email pozostawiony w komentarzu

70-503: Synchronization

Tue, 25 May 2010 00:54:00 +0100

Ten artykuł pochodzi z serii przygotowań do egzaminu 70-503: Windows Communication Foundation.

Ci z Was, którzy obsługiwali już wątki w .NET wiedzą, że nie jest to specjalnie skomplikowane. Najczęściej problemy występują przy obsłudze kontrolek Windows Forms, ponieważ ich właściwości mogą być zmieniane tylko w wątku, który je stworzył. Innym problemem jest wykorzystywanie lokalnej pamięci wątków do przechowywania informacji o kontekście, gdy proces nieoczekiwanie zmienia wątki, te dane mogą zniknąć. Z tej lekcji dowiemy się jak powyższe problemy są obsługiwane w WCFie.

Kontekst synchronizacji

W .NET 2.0 została wprowadzona rzadko używana funkcjonalność zwana kontekstem synchronizacji (klasa SynchronizationContext). Umożliwia ona sprawdzenie czy aktualnie wykonywany kod znajduje się w odpowiednim wątku. Aktualny kontekst możemy otrzymać odwołując się do statycznego pola SynchronizationContext.Current. Gdy jakaś metoda ma być wywołana w wątku, który nie jest bieżącym wątkiem, wywołujący wątek tworzy delegat typu SendOrPostCallback odwołujący się do żądanej metody a następnie jest przekazywany do metody Post (wywołanie asynchroniczne) lub Send (wywołanie synchroniczne) obiektu SynchronizationContext.

WCF i synchronizacja

A co ma kontekst synchronizacji do WCF’a? Nie wiem czy wiecie, że jeśli nie jest ustawione inaczej, każde wywołanie metod obiektu serwisu jest wykonywane przez wątki wejścia/wyjścia, z których żaden nie należy do naszej aplikacji. Gdybyśmy chcieli teraz zaktualizować coś w interfejsie użytkownika to napotkamy problem.

Z pomocą przychodzi nam właściwość UseSynchronizationContext klasy ServiceBehavior:

[ServiceBehavior(UseSynchronizationContext=true)]

public class UpdateService : IUpdateService

Ustawienie tego atrybutu na true spowoduje, że WCF będzie sprawdzał wątek uruchamiający hosta i jeśli wątek ten posiada kontekst synchronizacji i metoda serwisu jest wywołana z innego wątku, to będzie ona przekazywana do właściwego wątku i przez niego uruchomiona.

W przypadku hostowania serwisu w aplikacji Windows Forms/WPF, jeśli najpierw zostanie utworzony host przed oknem, nie zostanie utworzony żaden kontekst synchronizacji i każda aktualizacja kontrolek spowoduje błąd. Najpierw należy utworzyć okno a potem dopiero hosta serwisu.

Własny kontekst synchronizacji

WCF udostępnia tylko jedną klasę umożliwiającą obsługę kontekstu synchronizacji, dzięki której możemy np. aktualizować kontrolki w oknie aplikacji hostującej serwis. Możemy także utworzyć własne konteksty synchronizacji. Klasa kontekstu synchronizacjo odpowiada za wykonywanie metod serwisu przez konkretne wątki. Możemy wykorzystać ją np. do priorytetowania obsługi. Nasz kontekst synchronizacji może przekazywać wykonanie ważniejszych metod do wątków o wyższym priorytecie a pozostałych do innych wątków. Możemy właściwie zrobić o wiele więcej bazując na tym co udostępniają nam wątki.

Na początek potrzebna jest klasa bazująca na SynchronizationContext.

public class ThreadPoolSynchronizer : SynchronizationContext, IDisposable

{

    Queue<WorkItem> workItemQueue;

    WorkerThread[] workerThreads;

    Semaphore itemAdded;

  

    public ThreadPoolSynchronizer(int poolSize)

    {

        if (poolSize <= 0)

            throw new InvalidOperationException("Pool size cannot be zero");

  

        workItemQueue = new Queue<WorkItem>();

  

        workerThreads = new WorkerThread[poolSize];

        for (int index = 0; index < poolSize; index++)

            workerThreads[index] = new WorkerThread(index + 1, this);

    }

  

    public void Close()

    {

        foreach (WorkerThread thread in workerThreads)

            thread.Abort();

    }

  

    public void Abort()

    {

        foreach (WorkerThread thread in workerThreads)

            thread.Abort();

    }

  

    public void Dispose()

    {

        this.Close();

    }

  

    public override void Post(SendOrPostCallback method, Object state)

    {

        WorkItem workItem = new WorkItem(method, state);

        QueueWorkItem(workItem);

    }

  

    public override void Send(SendOrPostCallback method, Object state)

    {

        if (SynchronizationContext.Current == this)

        {

            method(state);

            return;

        }

        WorkItem workItem = new WorkItem(method, state);

        QueueWorkItem(workItem);

        workItem.AsyncWaitHandle.WaitOne();

    }

  

    protected Semaphore ItemAdded

    {

        get

        {

            if (itemAdded == null)

                itemAdded = new Semaphore(0, Int32.MaxValue);

  

            return itemAdded;

        }

        set

        {

            itemAdded = value;

        }

    }

  

    virtual internal void QueueWorkItem(WorkItem workItem)

    {

        lock (workItemQueue)

        {

            workItemQueue.Enqueue(workItem);

            ItemAdded.Release();

        }

    }

  

    protected virtual bool QueueEmpty

    {

        get

        {

            lock (workItemQueue)

            {

                if (workItemQueue.Count > 0)

                {

                    return false;

                }

                return true;

            }

        }

    }

    internal virtual WorkItem GetNext()

    {

        ItemAdded.WaitOne(1000);

        lock (workItemQueue)

        {

            if (workItemQueue.Count == 0)

            {

                return null;

            }

            return workItemQueue.Dequeue();

        }

    }

 

}

Mamy tutaj prostą implementację własnej obsługi wątków. Dodatkowo utworzone są klasy WorkItem i WorkerThread (nazwy mówią same za siebie, poniżej pokażę ich kod).

Za funkcjonalność synchronizacji odpowiada pięć metod podzielonych na dwie grupy. Trzy metody operacyjne (Close, Abort, Dispose – linie 19-34) odpowiadają za zatrzymywanie wątku obsługującego żądanie. Dwie metody funkcyjne (Post i Send – linie 36-52) używane są przez WCF do uruchomienia metody. W metodzie Send (linie 44-48) sprawdzamy czy aktualny kontekst nie jest naszym kontekstem aby nie spowodować zakleszczenia.

Dla pełności przedstawiam jeszcze klasy WorkItem i WorkerThread:

   [Serializable]

  internal class WorkItem

  {

      object state;

      SendOrPostCallback method;

      ManualResetEvent asyncWaitHandle;

  

      public WaitHandle AsyncWaitHandle

      {

          get

          {

              return asyncWaitHandle;

          }

      }

  

      internal WorkItem(SendOrPostCallback method, object state)

      {

          this.method = method;

          this.state = state;

          asyncWaitHandle = new ManualResetEvent(false);

      }

  

      internal void CallBack()

      {

          method(state);

          asyncWaitHandle.Set();

      }

  }

internal class WorkerThread

{

    ThreadPoolSynchronizer context;

    public Thread threadObj;

    bool endLoop;

  

    public int ManagedThreadId

    {

        get

        {

            return threadObj.ManagedThreadId;

        }

    }

  

    internal WorkerThread(int threadNumber, ThreadPoolSynchronizer context)

    {

        this.context = context;

  

        endLoop = false;

        threadObj = null;

  

        threadObj = new Thread(Run);

        threadObj.IsBackground = true;

        threadObj.Name = "Tread-" + threadNumber.ToString();

        threadObj.Start();

    }

  

    bool EndLoop

    {

        set

        {

            lock (this)

            {

                endLoop = value;

            }

        }

        get

        {

            lock (this)

            {

                return endLoop;

            }

        }

    }

  

    void Start()

    {

        Debug.Assert(threadObj != null);

        Debug.Assert(threadObj.IsAlive == false);

        threadObj.Start();

    }

  

    void Run()

    {

        Debug.Assert(SynchronizationContext.Current == null);

        SynchronizationContext.SetSynchronizationContext(context);

  

        while (EndLoop == false)

        {

            WorkItem workItem = context.GetNext();

            if (workItem != null)

            {

                workItem.CallBack();

            }

        }

    }

  

    public void Abort()

    {

        Debug.Assert(threadObj != null);

        if (threadObj.IsAlive == false)

        {

            return;

        }

        EndLoop = true;

  

        threadObj.Join();

    }

}



Teraz musimy przypisać nowy kontekst synchronizacji, może to wyglądać tak (przypisanie w linii 2):

ThreadPoolSynchronizer syncContext = new ThreadPoolSynchronizer(3);

SynchronizationContext.SetSynchronizationContext(syncContext);

try

{

    ServiceHost host = new ServiceHost(typeof(UpdateService));

    host.Open();

    // Block until ready to quit

    host.Close();

}

finally

{

    syncContext.Dispose();

}

Innym lepszym sposobem jest udekorowanie klasy serwisu własnym atrybutem (tworzenie atrybutów wykracza poza ramy tego kursu). Może to wyglądać np. tak (atrybut z dwoma parametrami rozmiar puli oraz nazwa klasy serwisu):

[ThreadPoolSynchronization(3, typeof(UpdateService))]

[ServiceBehavior(typeof(IUpdateService))]

public class UpdateService : IUpdateService

Atrybut ten musi implementować interfejs IContractBehavior a w nim następujące metody:

AddBindingParameters – modyfikuje bindingi,
ApplyClientBehavior – modyfikuje lub rozszerza zachowanie serwisu dla wybranych lub wszystkich wiadomości,
ApplyDispatchBehavior - “wersja od strony serwisu” metody ApplyClientBehavior – rozszerza zachowanie dla przychodzących wiadomości,
Validate – potwierdza że kontrakt i punkt końcowy mogą obsłużyć zachowanie zaimplementowane w obiekcie.

Ponieważ chcemy zmienić zachowanie po stronie serwisu, interesować nas będzie metoda AppliDispatchBehavior, która może być zaimplementowana np tak:

void ApplyDispatchBehavior(ContractDescription

description, ServiceEndpoint endpoint, DispatchRuntime dispatchRuntime)

{

    // ...

    if (dispatchRuntime.SynchronizationContext == null)

        dispatchRuntime.SynchronizationContext = new ThreadPoolSynchronizer(3);

    // ...

}

Synchronizacja i wywołania zwrotne

Obsługując wywołania zwrotne (ang. callback) także musimy brać pod uwagę problemy z współbieżnością. Podobnie jak w przypadku serwisu, u klienta możemy ustawić odpowiednie tryby synchronizacji, zarówno imperatywnie jak i deklaratywnie:

[CallbackBehavior(ConcurrencyMode = ConcurrencyMode.Single)]

class CallbackClient : ICallback

{

    // Implementation code

}

Tak jak w ConcurrencyMode w klasie ServiceBehavior tak i tutaj mamy trzy możliwe wartości:

Single – tylko jedno wywołanie zwrotne jest możliwe w danym czasie, to gwarantuje nam że WCF nie wywoła metody więcej niż raz w tym samym czasie, nie gwarantuje natomiast że inne wątki klienta będą się odwoływać do zasobów używanych w tej metodzie, o to musimy sie już sami martwić;
Multiple – dozwolone jest wielokrotne wywołanie metody, musimy sami postarać się o obsługę dostępu wielowątkowego;
Reentrant – metoda może być wywoływana ponownie przez serwis w tym samym wątku.

Wywołania zwrotne i konteksty synchronizacji

Możliwe jest także korzystanie z kontekstów synchronizacji w wywołaniach zwrotnych, wystarczy odpowiednio oznaczyć metodę:

[CallbackBehavior(UseSynchronizationContext=true)]

public class CallbackClient : ICallback

{

    // Implementation code

}

Na koniec jeszcze ważna informacja na temat wątków, wywołań zwrotnych i zakleszczeń. Załóżmy, że mamy przycisk uruchamiający metodę serwisu. Serwis dokonuje wywołania zwrotnego do aplikacji (dokładniej do wątku interfejsu użytkownika bo stamtąd pochodziło wywołanie serwisu). Wątek interfejsu użytkownika jest teraz zajęty bo czeka na odpowiedź od serwisu… No i mamy zakleszczenie. Jedynym rozwiązaniem tego problemu jest zrezygnowanie z kontekstu synchronizacji i ustawienie UseSynchronizationContext na false.

Na tym kończymy kurs.

Pozostańcie jeszcze z nami gdyż przygotowaliśmy małą niespodziankę.

Do zobaczenia na egzaminach :)