Tworzymy prostą stronę w ASP .NET 4.0 cz.2

Witam w kolejnym wpisie z cyklu wprowadzającego do ASP .NET. Dziś pokaże jak obsługiwać proste kontrolki oraz jak przygotować własną kontrolkę, która przyda nam się w następnym wpisie :)
W ASP .NET kontrolki możemy sobie obsługiwać prawie tak samo jak w WinForms. Wystarczy że przeciągniemy je z toolboxa na formatkę a później oprogramujemy.  Dziś pokażę jak obsługiwać kontrolki Label, Literal, HyperLink, Panel oraz Button. Zrobimy sobie wyświetlanie aktualności na naszej stronie. Zaczynamy:)
Otwieramy nasz projekt i wchodzimy do Default.aspx, ponieważ to tu będziemy wyświetlali aktualności. Będą one wyświetlane  w postaci: Nagłówek i wycinek aktualności. Po kliknięciu w nagłówek zostaniemy przekierowani na stronę, gdzie zobaczymy całą treść aktualności oraz będziemy mogli ją skomentować.
Do nagłówka użyjemy kontrolki HyperLink. Otwieramy toolboxa i przeciągamy kontrolkę do naszego kodu:

ToolBox

ToolBox i HyperLink

Po przeciągnięciu kontrolki wygeneruje nam się taki kod:

<asp:HyperLink runat="server">HyperLink</asp:HyperLink>

Żeby to teraz jakoś działało należy ustawić właściwości kontrolki. My póki co ustawimy wszystko ręcznie. Ustawmy jej jakieś ID oraz właściwość NavigateUrl, dzięki której po kliknięciu na kontrolkę, zostaniemy przekierowani, do podanej przez nas, strony:

<asp:HyperLink ID="Header" NavigateUrl="News.aspx" runat="server">Jestem pierwszym wpisem</asp:HyperLink>

Jak widzimy chcemy zostać przekierowani na stronę News.aspx. Stwórzmy ją sobie, wybierając naszego MasterPage. Teraz stworzymy treść wpisu, zapisując ją do kontrolki Literal. Możemy to zrobić na dwa sposoby. Albo przypisując tekst do właściwości Text:

<asp:Literal Id="Content" runat="server" Text="Jakiś tekst" />

Albo tak:

 <asp:Literal Id="Content" runat="server" > Jakiś tekst</asp:Literal>

W zasadzie nie ma różnicy jak to wpiszemy bo w każdym przypadku tekst jest zapisywany do właściwości Text :) No i to tyle od strony wyświetlania aktualności.
W stronie News.aspx umieszczamy sobie jako nagłówek kontrolkę Label i ustawiamy jej właściwość Text. Pod spodem umieszczamy Literal z tekstem wpisu. Ta część nie różni się od poprzedniej ale chcemy jeszcze dodać możliwość komentarzy, więc musimy umieścić 3 kontrolki TextBox oraz Button. TextBox służy do wprowadzania tekstu, Button to zwykły przycisk :) Pierwsze dwa textboxy zostawiamy praktycznie bez zmian. Nadajemy im tylko ID:

<asp:TextBox ID="Nick" runat="server" /><br />
 <asp:TextBox ID="Email" runat="server" /><br />

W trzecim TextBoxie oprócz ID zmieniamy również właściwości Width, Height oraz TextMode. Szerokość i wysokość jest jasna a cóż to takiego TextMode? Jest to właściwość, dzięki której możemy ustawić np. tryb, w którym kontrolka będzie mogła przyjąć wiele wierszy (ustawiamy jej wtedy Multiline):

 <asp:TextBox ID="Comment" runat="server" Width="200" Height="100" TextMode="MultiLine" />

Teraz pozostaje nam umieścić przycisk, dzięki któremu wyślemy dane z TextBoxów np. do bazy. Przeciągamy kontrolkę z ToolBoxa i nadajemy jej ID oraz Text:

<asp:Button runat="server" ID="SendButton" Text="Wyślij" />

Żeby oprogramować przycisk wejdźmy w tryb Design naszej strony i kliknijmy na przycisk dwa razy.

Tryb design

Tryb design

Po kliknięciu dwa razy na button, zostanie wygenerowana metoda

protected void SendButton_Click(object sender, EventArgs e)

Póki co nie interesują nas jej parametry :) Zostanie również dodane zdarzenie onClick do Buttona, dzięki któremu po kliknięciu na przycisk wywoła się powyższa metoda.

<asp:Button runat="server" ID="SendButton" Text="Wyślij" onclick="SendButton_Click" />

W dzisiejszym wpisie nie zaprezentuje zapisywania danych. Opiszę to w następnej części. Dziś chcę pokazać jeszcze jedną ważną rzecz, dzięki której będziemy mogli generować nasze aktualności na podstawie bazy danych. Stworzymy naszą własną kontrolkę, którą później będziemy powielać w zależności od tego ile np. mamy wpisów w bazie. Aby to zrobić tworzymy nowy obiekt w naszym projekcie (PPM na projekcie -> new item) i wybieramy WebUserControl. Jest to plik, w którym będziemy trzymali naszą kontrolkę. Teraz kopiujemy do niej to co stworzyliśmy w Default.aspx, tylko nie uzupełniamy właściwości Text i NavigateUrl. Następnie musimy wejść do tzw. CodeBehind. Klikamy prawym przyciskiem w puste pole gdzieś w kodzie i wybieramy View Code:

View Code

View Code

Przełączyliśmy się do widoku kodu C#. Musimy teraz stworzyć właściwości, które następnie będziemy wykorzystywali do dynamicznego ustawiania kontrolek (czyli ich właściwości Text, NavigateUrl itp). Będzie potrzeby również pusty konstruktor. Kod:

public ControlNews() { }

 public string Head
 {
 set { Header.Text = value; }
 }
 public string NavigateUrl
 {
 set { Header.NavigateUrl = value; }
 }
 public string ShortContent
 {
 set { Content.Text = value; }
 }

Jak widzimy w powyższym kodzie odnosimy się, we właściwości, do poszczególnych kontrolek, za pomocą ich ID i ustawiamy im wartość. I już :) Mamy stworzoną własną kontrolkę. Teraz umieścimy ją w Default.aspx. Wchodzimy do Default.aspx, kasujemy to co tam mieliśmy napisane i przeciągamy kontrolkę Panel. Jest to taka przestrzeń, w której umieścimy naszą kontrolkę. Nadajmy mu id np. ControlPanel. Musimy jeszcze zarejestrować naszą kontrolkę. W tym celu dodajemy nową dyrektywę, która wygląda tak:

<%@ Register Src="ControlNews.ascx" TagName="NewsControl" TagPrefix="uc2" %>

Jak widzimy podajemy po prostu ścieżkę do kontrolki oraz ustawiamy tag, dzięki któremu można się do niej odnosić. Teraz przechodzimy do CodeBehind pliku Default.aspx. Dziś tylko pokażę jak ustawić kontrolkę na przykładowe dane. Aby to zrobić w metodzie Page_Load dodajmy kod:

//pobieranie kontrolki
 var newsControll = (ControlNews)LoadControl(@"ControlNews.ascx");
 //dodawanie kontrolki do panelu
 ControlPanel.Controls.Add(newsControll);
 //ustawianie właściwości kontrolki
 newsControll.NavigateUrl = "News.aspx";
 newsControll.Head = "Naglowek";
 newsControll.ShortContent = "skrócony opis";

Myślę że opis w komentarzach wystarczy do zrozumienia powyższego kodu :)
Na dziś to tyle. Jeśli chcecie to w ramach treningu możecie stworzyć własną kontrolkę do widoku Aktualności ale tego szczegółowego. Kod do dzisiejszego wpisu można pobrać STĄD.
Do “usłyszenia” niebawem :)

Tworzymy prostą stronę w ASP .NET 4.0 cz.1

Tak jak obiecałem w poprzednim wpisie, zaczynam pisać krótki “kurs” ASP .NET. Będę opierał się o ASP .NET w wersji 4.0   i Visual Studio 2010 (w wersji Ultimate, która dostępna jest na MSDN AA), chociaż myślę, że te elementy, które pokaże nie będą różniły od tego, co widzieliśmy w Visual Studio 2008 i wersji frameworka 3.5. Cały cykl poświęcony jest dla bardzo początkujących, którzy chcieliby pobawić się ASP.

W całym cyklu planuję pokazać takie rzeczy jak:

  • Podstawy czyli: tworzenie nowego projektu, działanie z master page, poruszanie się w visual studio
  • Działanie z dostępnymi kontrolkami
  • Tworzenie własnych kontrolek
  • Tworzenie bazy danych i dostęp do nie j za pomocą linq

Tak planuję a co wyjdzie zobaczymy :) Zaczynamy :)

Jak pewnie się domyślacie stworzymy sobie stronę, którą będziemy rozwijać w każdej części kursu. Żeby jednak to jakoś wyglądało, ściągnąłem sobie darmowy szablon, który następnie użyję w tworzonej stronie. Żeby stworzyć nowy projekt strony w Visual Studio wybieramy: File->New->WebSite. Powinno nam wyskoczyć takie okienko:

Tworzenie nowego projektu

Tworzenie nowego projektu

Jak widzimy mamy do wyboru kilka opcji. Nas (w tym momencie) interesują dwie: ASP .NET Web Site oraz ASP .NET empty Web Site. Jeśli wybierzemy pierwszą opcję dostaniemy projekt naszej strony z przykładowym wyglądem, już zrobionym master pagem, dodaną przykładową podstroną itp. My wybierzemy drugą opcję czyli pusty projekt. Dzięki temu stworzy nam się jedynie plik konfiguracyjny Web.Config. Po stworzeniu powinno wyglądać to tak:

Widok po stworzeniu projektu

Widok po stworzeniu pustego projektu

Teraz wypadałoby dodać szablon, który ściągnęliśmy z internetu (lub zrobiliśmy sami :) ). Moja paczka z szablonem składała się z folderu Images, pliku ze stylami oraz pliku Index.html. Dodajmy najpierw obrazki. Musimy kliknąć PPM na projekcie, wybrać New Folder i nazwać go Images. Następnie PPM na nowo utworzonym folderze wybrać Add Existing Item i wybrać elementy, które chcemy dodać do projektu. To samo robimy dla pliku css z tą różnicą, że dodajemy go do głównego katalogu projektu a nie do folderu Images. Oczywiście możemy stworzyć sobie folder dla styli czy wykorzystać foldery specjalne np. App_Themes ale o tym może kiedy indziej :) Mamy już dodane wszystkie pliki, które tworzą wygląd naszej strony. Teraz dodamy nową podstronę. Aby to zrobić należy kliknąć PPM na projekcie i wybrać Add New Item. Z wielu dostępnych obiektów wybieramy Web Form, czyli pojedynczą stronę.

Nowa strona

Tworzenie nowej podstrony

Oczom naszym ukaże się poniższy widok :D

Pierwsza strona

Pierwsza strona

Visual Studio wygenerował nam szkielet prostej, pustej strony. Oczywiście my w tym momencie większość kodu skasujemy i wstawimy ten, który otrzymaliśmy razem z szablonem. W moim wypadku najpierw kasuję kod, który jest pomiędzy <form></form> a następnie do head dodaję odnośnik do stylów. Wystarczy przeciągnąć plik ze stylami do naszego kodu. Dzięki temu automatycznie wygeneruje nam odnośnik do stylów.
Kiedy już mamy wszystko możemy odpalić naszą stronę i podziwiać efekty :) Wciskamy F5, dzięki któremu uruchomimy projekt w trybie debugowania. Wyskoczy nam takie okienko:

Włączanie debugowania

Włączenie debugowania

Kompilator pyta nas czy zmodyfikować plik konfiguracyjny w celu włączenia debugowania. Oczywiście pozwalamy mu na to :) Po chwili pojawi się nasza piękna strona:

Pierwsze uruchomienie

Pierwsze uruchomienie

Teraz moglibyśmy zacząć dodawać kolejne podstrony ale najpierw musimy poznać mechanizm master page. Master page jest to plik, który trzyma tę część naszej strony, która pozostaje niezmieniona. W naszym wypadku będzie to logo, stopka oraz odnośniki do podstron. Dzięki temu wymienny będzie środek strony. Aby stworzyć master page ponownie PPM na projekcie -> new item-> master page. Wygeneruje nam się szkielet master page:

Master Page

Master Page

Widzimy zaznaczoną sekcję ContentPlaceHolder. To w tym miejscu jest nasz “Content”, czyli treść, która będzie wymienna na naszej stronie. Dookoła musimy umieścić te elementy, które będą stałe. Ja przerobiłem po prostu delikatnie szablon i stworzyłem master page. Wszystkie materiały z projektem będą dostępne na końcu posta, więc zobaczycie sobie w kodzie jak to wygląda.
Kiedy mamy już master page, kasujemy Default.aspx, który wcześniej stworzyliśmy i tworzymy go jeszcze raz. Jedyną różnicą w tworzeniu nowej WebForm jest to, że musi być zaznaczony checkbox Select Master Page.

Wybor master page

Wybór master page

Kolejne okienko,  służy do wyboru master page, którego chcemy użyć, ponieważ jest możliwość stworzenia kilku master page. Wybieramy interesujący nas plik i dajemy Ok.
Po stworzeniu pliku widzimy dwa ContentPlaceHolder’y, które są odpowiednikami tych w master page. Nasz wymienny Content umieszczamy w Contencie o ID = ContentPlaceHolder1.
Teraz gdy już mamy master page, każdą kolejną podstronę, którą tworzymy, wiążemy z nim, dzięki czemu mamy ładny szkielet strony z wymiennym tylko środkiem.
To wszystko na dziś. Następnym razem dodamy do projektu kilka wbudowanych kontrolek i stworzymy własną.
Przy okazji, zna ktoś jakąś sensowną wtyczkę do WordPress’a, dzięki której będzie można wstawiać kod c# do postu?

Pliki z dzisiejszej części możecie pobrać STĄD. Wystarczy gdzieś to wypakować a następnie w Visual Studio wybrać File->Open->WebSite i wskazać folder z plikami.

Zapraszam na następną część cyklu, która powinna pojawić się pod koniec tygodnia :)

ContentPlaceHolderID=”ContentPlaceHolder1″

Visual Studio 2010 Community Launch w Olsztynie i zapowiedź cyklu wpisów na blogu

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

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.

Od siebie mogę dodać, że nagrody są bardzo kuszące i sam miałem przyjemność na takich spotkaniach 2 razy coś wygrać :) No i fajnie sobie iść na darmową kolację, więc zapraszamy :)

Chciałbym jeszcze zapowiedzieć krótki cykl wpisów, który w niedługim czasie pojawi się na blogu. Kilka osób pytało mnie o podstawy ASP .NET. Jako, że aktualnie piszemy na ten temat na stronie Eastgroup (konkretnie materiały przygotowujące do certyfikatu 70-562), postanowiłem napisać krótki kurs/wprowadzenie do ASP .NET. Będzie to kurs dla bardzo początkujących, choć myślę, że pod koniec cyklu opiszę kilka ciekawszych zagadnień :)
Pierwszy z serii artykułów planuję opublikować w przyszłym tygodniu, więc serdecznie zapraszam:)

Konfiguracja Git i ProjectLocker

Ostatnio tyle słyszy się o gicie, że sam postanowiłem sprawdzić o co w tym chodzi, tym bardziej, że po ostatnim padzie SVN’a “troszkę” się zdenerwowałem :) . Swoje repozytorium postanowiłem założyć na portalu ProjectLocker. Początkowo myślałem o Git Hubie, lecz tam, za darmo, dostajemy publiczne repozytorium. Na Project Locker do dyspozycji mamy repozytorium prywatne, 500mb powierzchni oraz możliwość podłączenia do repo (czy może tego profilu) 5  użytkowników.
Git jest dla mnie nowością, dlatego miałem trochę problemów z konfiguracją. Zabrało mi to sporo czasu (i pewnie, gdyby nie pomocne artykuły i koledzy, zabrałoby sporo więcej), więc postanowiłem napisać mały tutorial , w którym opiszę podstawową konfigurację gita w połączeniu z ProjectLocker:). No to zaczynamy:).

Zacznijmy od zarejestrowania się na ProjectLocker. Podczas rejestracji będzie trzeba wpisać nazwę swojego projektu i wypełnić trochę niepotrzebnych danych:)

Po rejestracji zostaniemy przekierowani do naszego profilu, w którym będziemy mogli zarządzać projektami, osobami przydzielonymi do projektu itp.

Teraz, gdy już mamy konto na portalu, musimy ściągnąć albo samego git’a, albo (tak jak w moim przypadku) Git Extensions, dzięki któremu będziemy mogli zarządzać swoim repozytorium za pomocą okienek a nie konsoli.

Kiedy mamy już zainstalowane Git Extensions, wchodzimy do Git Bash i wpisujemy:

ssh-keygen –C user@example.com –t rsa

Wygeneruje nam to klucz ssh, za pomocą którego będziemy komunikować się ze zdalnym repozytorium. Przechodzimy do folderu, w którym wygenerował się klucz (w win 7/vista jest to C:\Users\UserName\.ssh\), edytujemy plik id_rsa.pub dowolnym edytorem tekstowym i kopiujemy klucz.

Kiedy mamy już klucz, przechodzimy z powrotem do naszego profilu na Project Locker, wybieramy po lewej stronie Manage Public Keys a następnie New Key. Naszym oczom ukaże się (a przynajmniej powinien) taki widok :)

W pole o nr 1 wstawiamy dowolną nazwę, w pole nr 2 wstawiamy mail, który wpisywaliśmy w momencie tworzenia klucza (jest on wyświetlony również na samym końcu klucza po znakach == ), w pole nr 3 wpisujemy oczywiście klucz :)

W tym momencie mamy skonfigurowane nasze repozytorium na Project Locker, ale tylko dla nas. A co, jeśli chcemy podpiąć do niego kogoś innego, nadając mu prawa admina? Tu męczyłem się chyba najdłużej, a sprawa okazała się banalna (po prostu kolega źle generował klucz i wstawialiśmy w złe miejsce). Aby dodać nowego użytkownika należy wybrać z menu po lewej stronie Add User, wypełnić wszystkie pola i zaznaczyć Account Admin.

Następnie przechodzimy do List Projects wybieramy nasz projekt i dodajemy użytkownika, który jest w polu Account Users not Assigned to this Project.

W tym momencie nasz nowy użytkownik jest dopisany do projektu, ale żeby mógł z niego korzystać musi wygenerować swój własny klucz, zalogować się na swoje konto i wkleić tam klucz (to właśnie tu nam się coś nie udawało :) ). Kiedy nasz użytkownik wejdzie na konto, zobaczy adres do repozytorium projektu, do którego właśnie go przypisaliśmy.
Teraz mamy przypisanych już dwóch użytkowników do projektu. Na tym koniec z ustawieniami na portalu.
Czas na podłączenie się z naszego komputera do repozytorium i wysłanie pierwszego “pusha” :)

Niestety nie wiem dlaczego, ale nie działa mi stworzenie repozytorium w trybie graficznym, więc opiszę tworzenie z konsoli, a następnie wczytamy je do trybu graficznego  i tam będziemy mogli już normalnie nim zarządzać. Wchodzimy więc do Git Bash. Na początek podajemy dwie komendy, które ustawią informację o nas:

git config --global user.name Your Name
git config --global user.email yourEmail

Następnie tworzymy sobie katalog, w którym będziemy trzymali lokalne repozytorium i wchodzimy do niego:

mkdir NazwaRepozytorium
cd NazwaRepozytorium

Teraz w katalogu należy zainicjować gita:

git init 

Teraz możemy już coś wrzucić do katalogu, który powstał w C:/users/UserName/NazwaRepozytorium (win7/vista), a następnie zrobić pierwszego lokalnego “commita” poleceniem:
git commit -m ‘pierwszy commit’

Przyszedł czas na określenie zdalnego repozytorium. Aby to zrobić, wchodzimy na portal i kopiujemy adres do repozytorium, który znajduje się na głównej stronie profilu:
Kopiujemy adres i wydajemy polecenie w konsoli:

git remote add JakasWlasnaNazwa AdresRepozytorium

W tym momencie określiliśmy zdalne repozytorium, więc czas na “pusha”. W “pushu” korzystamy z tej nazwy, którą wpisaliśmy przy określeniu zdalnego repozytorium:

git push JakasWlasnaNazwa master

I już! :) Mamy nasze dane w repozytorium na ProjectLocker. Teraz, żeby zarządzać tym za pomocą git extensions uruchamiamy go, w settings i w zakładce GlobalSettings wpisujemy te same UserName i User email, co wcześniej. Następnie otwieramy folder z naszym repozytorium i już możemy cieszyć się z obsługi okienkowej gita :)

Oczywiście druga osoba (i każda następna), która jest dopisana do naszego projektu, wystarczy, że zna jego adres (który sam zresztą wyświetla się u niej w profilu,  jeśli ma do niego prawa).

To tyle :) Jeśli coś przekręciłem albo źle napisałem, to proszę o poprawienie w komentarzach:) Jak mówiłem, jest to moje pierwsze starcie z git’em i nie wiem jeszcze wielu rzeczy, ale ta konfiguracja, którą przedstawiłem działa u mnie (póki co :) ) dobrze.

Jeszcze na sam koniec link do podobnego artykułu, który napisał Krzysiek Sopyła na Eastgrupie. Pokazuje również konfigurację gita tylko w połączeniu z Git Hubem: Link

Co nowego w nadchodzącym semestrze?

Koniec sesji, koniec ferii, czas rozpocząć nowy semestr. :)

Ostatnio pisałem o ASP MVC i o “projekcie”, który miałem pisać w wolnym czasie, w ramach nauki tej technologii. Niestety w tzw. międzyczasie doszło mi tyle zajęć, że z jednej części powyższego pomysłu musiałem zrezygnować. Ta jedna część to owy “projekt”. Zrezygnowałem z niego, ponieważ razem z Mateuszem Jaskółowskim zaczynamy nowy, tym razem sensowny:), projekt, o którym napiszę jak już coś się pojawi :)

Co dalej?

Oprócz projektu z Mateuszem, planuję zdać certyfikat, o którym niedawno pisałem. Swoją drogą, z wpisami na stronie Eastgroup wyszła bardzo fajna sprawa, bo napisał o nich MS na swojej stronie oraz na codeguru. W związku z dużym zainteresowaniem naszymi wpisami, postanowiliśmy napisać kolejny cykl artykułów. Tym razem akcja będzie trochę większa, ponieważ artykuły będzie pisało 5 osób. Ja, Dawid Tulski i Daniel Plawgo będziemy pisali artykuły przygotowujące do certyfikatu 70-562 Microsoft .NET Framework 3.5, ASP.NET Application Development, natomiast Kamil Lemański i Dawid Cieszyński Microsoft .NET Framework 3.5 – Windows Communication Foundation Application Development.

Kolejną rzeczą, która będzie mi zajmowała sporo czasu jest praca, którą rozpocząłem tydzień temu. Praca, na szczęście, na zlecenie dlatego mogę sam zarządzać sobie czasem, w którym pracuję. :)

Poza powyższymi zajęciami, jest jeszcze oczywiście szkoła, która w tym semestrze też nie odpuszcza. Cotygodniowe koła z PSI oraz roczny projekt również z PSI zajmują mój cenny czas :)

Zajęcia, o których pisałem sprawiają, że wolnego czasu zostaje naprawdę niewiele, jednak pomimo tego cieszę się, że cały czas coś się dzieje i są to ciekawe rzeczy. :)

Na dzisiaj to tyle. :) Już niedługo kolejny wpis. Myślę, że będzie dotyczył projektu, który rozpoczynamy z Mateuszem :) Do „usłyszenia”!

Nauka ASP MVC

Jako, że w sesji będę miał tylko jeden egzamin (mam nadzieję :) ) i chwilowo mam trochę wolnego czasu, postanowiłem, że zacznę uczyć się ASP MVC. Naukę tej technologii planowałem już dawno temu ale niestety zabrakło czasu.
Chciałbym również nauczyć się tworzyć testy jednostkowe, wykorzystywać w nich mocki (korzystając z Rhino Mocks) i ogólnie tworzyć aplikację tak, aby była łatwa w rozbudowie i testowaniu.
Żeby moja nauka nie polegała na czytaniu samych tekstów i robieniu “suchych” przykładów, postanowiłem, że w ramach ćwiczeń napisze własnego bloga. Pomysł raczej średni no ale na czymś trzeba ćwiczyć :)
Dodatkowo postaram się opisywać tu na blogu moje zmagania z tworzeniem “projektu”.
Powstawanie bloga można śledzić pod adresem:  http://dedloo.studentlive.pl.

Podejrzewam, że do środy coś jeszcze dopisze ale później będę musiał wrócić do Metod probabilistycznych, z którymi już niedługo będę musiał zmierzyć się na egzaminie.

Certyfikat 70-536

Trochę ostatnio zaniedbałem bloga ale niestety nawał pracy i zbliżająca się sesja robią swoje :)

Razem z Dawidem Tulskim i Kamilem Lemańskim przygotowujemy się, od początku roku akademickiego, do egzaminu 70-536: Microsoft .NET Framework – Application Development Foundation. Postanowiliśmy, że podczas uczenia będziemy robili “notatki” (w praktyce okazało się jednak, że praktycznie tłumaczymy Training Kit’a :D ) i wrzucali je na stronę grupy. Artykuły ukazują się w każdy poniedziałek, środę oraz piątek. W tej chwili do końca książki zostały już tylko 2 rozdziały.

Poniżej linki do wszystkich wpisów, które ukazały się do tej pory:

  1. Using Value Types
  2. Using Common Reference Types
  3. Constructing Classes
  4. Converting Between Types
  5. Working with the File System
  6. Reading and Writing Files and Streams
  7. Forming Regular Expressions
  8. Encoding and Decoding
  9. Collections and Dictionaries
  10. Generic Collections
  11. Serializing Objects
  12. XML Serialization
  13. Custom Serialization
  14. Drawing graphics
  15. Working with Images
  16. Formatting Text
  17. Starting Multiple Threads
  18. Managing Threads
  19. Creating Application Domains
  20. Configuring Application Domains
  21. Tworzenie Windows Services
  22. Configuring Applications
  23. Configuring the .NET Framework
  24. Installing Applications
  25. Logging Application State
  26. Working with Performance Counters
  27. Managing Computers
  28. Understanding CAS
  29. Using Declarative Security to Protect Assemblies
  30. Using Declarative and Imperative Security to Protect Methods
  31. Authenticating and Authorizing Users
  32. Using Access Control Lists
  33. Encrypting and Decrypting Data
  34. Using COM Components from the .NET Framework
  35. Using .NET Types from COM Applications
  36. Using Reflection
  37. Creating an E-mail Message
  38. Sending E-mail
  39. Globalization

Uff.. Trochę się tego uzbierało :) Teraz “wystarczy” to wszystko podsumować, nauczyć się, poćwiczyć, umówić egzamin no i zdać :) Proste prawda? :)

Mamy nadzieję, że nasze wypociny przydadzą się komuś. Zapraszam do lektury :)

—-Edit—

Dodałem ostatnie 4 artykuły. Teraz lista jest już zamknięta :)

Windows 7 Community Launch w Olsztynie

Już 15. grudnia 2009 na WMiI UWM w Olsztynie odbędzie się WCL. Wydarzenie organizowane przez grupy .net – zawodową OLMUG oraz akademicką Eastgroup.pl, ma na celu przybliżyć uczestnikom najnowszą wersję systemu operacyjnego firmy Microsoft – Windows 7.
Spotkanie będzie składało się z dwóch prezentacji:

Pierwszą sesję, która będzie dotyczyła nowości w Windows 7, poprowadzi Kamil Lemański oraz Daniel Plawgo. Druga prezentacja będzie bardziej ukierunkowana na programistów. Poprowadzi ją Bartłomiej Zass.

Zapraszamy już 15 Grudnia o godzinie 17.00. Spotkanie odbędzie się na Wydziale Matematyki i Informatyki UWM w sali 49. Adres wydziału to Żołnierska 14. Dla aktywnych uczestników przewidziane zostały nagrody :)

Ilość miejsc ograniczona, dlatego wymagana jest rejestracja

Zapraszamy :)

Gios.Word czyli zapisujemy dane do worda

Chciałbym pokazać dzisiaj bardzo fajną i darmową bibliotekę, która pozawala zapisywać nasze dane do worda.  Przykłady będą bardzo proste, pokazujące tylko że da się stworzyć własny wygląd generowanego dokumentu. Biblioteka nazywa się Gios.Word. Cały projekt, łącznie z kodami źródłowymi biblioteki można pobrać TUTAJ.

Na początek pokaże jak prosto zapisać tekst używając biblioteki. Aby kod zadziałał musimy oczywiście dodać referencję do pliku Gios.Word.dll no i dać using Gios.Word.

WordDocument wordDocument = new WordDocument(WordDocumentFormat.Letter_8_5x11);
wordDocument.Write("Jestem napisem");
wordDocument.SaveToFile("test.doc");

Na początku tworzymy nowy obiekt WordDocument i w parametrze podajemy ustawienia strony. Dalej widzimy już zwykłe zapisywanie do pliku. Oczywiście gdyby tylko tyle biblioteka potrafiła nie byłoby większego sensu jej używania :) Dlatego teraz ustawię jakieś parametry czcionki np. wielkość oraz rodzaj. Żeby to osiągnąć musimy najpierw dodać referencję do System.Drawing a dalej tak jak na przykładzie:

WordDocument wordDocument = new WordDocument(WordDocumentFormat.Letter_8_5x11);
Font bold = new Font("Arial", 14, FontStyle.Bold);
wordDocument.SetFont(bold);
wordDocument.Write("Jestem napisem");
wordDocument.SaveToFile("test.doc");

W tym momencie otrzymamy pogrubiony napis, z czcionką ustawioną na Arial wielkości 14.
Na koniec pokażę jeszcze tworzenie tabelki:

WordDocument wordDocument = new WordDocument(WordDocumentFormat.Letter_8_5x11);
Font bold = new Font("Arial", 12, FontStyle.Bold);
wordDocument.SetFont(bold);
Font regular = new Font("Arial", 12, FontStyle.Regular);</code>

WordTable rt = wordDocument.NewTable(regular,Color.Black,30,4,0);//1

rt.SetContentAlignment(ContentAlignment.TopLeft);
rt.SetFont(new Font("Arial", 13));
rt.SetColumnsWidth (new int[] { 50, 50});  //2

rt.Rows[0][0].Write("Wiersz1"); //3
rt.Rows[0][1].Write("Wiersz1");
rt.Rows[1][0].Write("Wiersz2");
rt.Rows[1][1].Write("Wiersz2");

rt.SaveToDocument(10000,0);  //4
wordDocument.SaveToFile("test.doc");

Będę omawiał ponumerowane wiersze:
1.Tworzymy obiekt WordTable i w konstruktorze podajemy parametry dotyczące tekstu, koloru obramowania,ilości    kolumn wierszy, położenie

2.Ustawiamy szerokość kolumn

3. Dodajemy napis do odpowiedniego wiersza i kolumny. W pierwszym indeksie mamy wiersz, w drugim kolumnę.

4.Na koniec dodajemy tabelkę do naszego dokumentu. Parametry to położenie.

No i tak mniej więcej wygląda korzystanie z gios worda. Oczywiście sama biblioteka ma większe możliwości :) Przepraszam za brzydkie wyświetlanie kodu, ale chyba zmienię wygląd bloga, żeby content był szerszy.
Do następnego razu :)

Lista własnego typu i GridView w WPF

Jakiś czas temu, pisząc prostą aplikację trafiłem kilka problemów. Pierwszy, to jak pobrać odpowiednie dane z bazy, a następnie zapisać je do listy własnego typu, a drugi, jak zrobić binding mojej listy do GridView w WPF’ie. Wszystko okazało się dosyć proste :) Aby stworzyć mój własny typ listy, stworzyłem klasę posiadającą właściwości, które reprezentują pola w mojej liście:

 public class FillListProperties
{
public int Id { get; set; }
public DateTime Date { get; set; }
public string WorkName { get; set; }
public string FirstName { get; set; }
public string Surname { get; set; }
public float Payment { get; set; }
}

Ok mamy klasę. Następnie stworzyłem sobie metodę, która zwracała uzupełnioną listę mojego typu. Będę wklejał fragmenty kodu, opisywał je a na koniec wrzucę całość:

public List FillListView()
{
//lista mojego typu do przechowywania wyciagnietych danych
var paymentList = new List();

Widzimy funkcję, o której wspominałem wyżej oraz zadeklarowaną listę mojego typu (czyli FillListProperties). Dalej musimy pobrać sobie odpowiednie pola z bazy danych (w moim przypadku za pomocą LINQ to SQL) oraz zapisać do listy. Wyciąganie w tym przypadku wygląda tak:

 //pobieranie pol
using (var db = new dbLinqDataContext())
{
var items = (from p in db.PaymentTables
select new
{
p.Id,
p.Date,
p.AddWorkerTable.Name,
p.RateTable.WorkName,
p.AddWorkerTable.Surname,
p.Payment
});

Wyciągnęliśmy sobie te same pola z bazy, które zadeklarowaliśmy we właściwościach, w naszej klasie. Teraz przypisanie do listy:

//dodawanie danych do listy
foreach (var item in items)
{
paymentList.Add(new FillListProperties
{
Id = item.Id,
Date = item.Date,
FirstName = item.Name,
Surname = item.Surname,
Payment = item.Payment,
WorkName = item.WorkName
});
}
}
return paymentList;
}

I już :) Wyciągnęliśmy odpowiednie dane, przypisaliśmy do listy własnego typu oraz całą listę zwróciliśmy. Prosta rzecz a jednak jak ktoś nie robił tego wcześniej (tak jak ja) to chwilkę trzeba się zastanowić :) .
Tak naprawdę moją listę tworzyłem po to aby móc wyciągnąć dane poprzez relacje i zapisać do GridView’a w wpfie. Poniżej pokażę jak to zrobić:
Najpierw w “code begind” naszego widoku określamy źródło danych dla GridViewa (GridView nazywa się u mnie PaymentList a instancja klasy, w której trzymam metodę wypełniającą liste: _addEditPayment)

PaymentList.ItemsSource = _addEditPayment.FillListView();

Teraz pozostało już nam już tylko wskazać jakie dane mają zostać przypisane do jakich pól:


Najważniejszą rzeczą z powyższego kodu jest oczywiście fragment DisplayMemberBinding=”{Binding Path=Id}” W tym miejscu wskazujemy jakie dane mają być wyświetlone w konkretnej komórce.

To wszystko na dzisiaj :) Mam nadzieję, że moje rozwiązanie komuś się przyda. Jeszcze na sam koniec pełny kod metody:

public List FillListView()
{
//lista mojego typu do przechowywania wyciagnietych danych
var paymentList = new List();
//pobieranie pol
using (var db = new dbLinqDataContext())
{
var items = (from p in db.PaymentTables
select new
{
p.Id,
p.Date,
p.AddWorkerTable.Name,
p.RateTable.WorkName,
p.AddWorkerTable.Surname,
p.Payment
});
//dodawanie danych do listy
foreach (var item in items)
{
paymentList.Add(new FillListProperties
{
Id = item.Id,
Date = item.Date,
FirstName = item.Name,
Surname = item.Surname,
Payment = item.Payment,
WorkName = item.WorkName
});
}
}
return paymentList;
}