Kurs C#/ASP.NET. Obiekty

Obiekty

Obiekty to „byty programistyczne”, których typ opisują klasy. Skoro klasy opisują obiekty to każde wystąpienie obiektu jest instancją/wystąpieniem danej klasy. Idąc dalej, skoro obiekty są wystąpieniami klas (a pisałem już wcześniej, że klasy mogą coś opisywać, czyli przechowywać dane, lub coś robić, czyli zawierać jakiś kod wykonywalny) to analogicznie jak klasy obiekty mogą przechowywać dane (wartości) jak również wykonywać pewne akcje/operacje.

OK to po części teoretycznej część praktyczna.

Na początek stworzymy sobie klasę, która będzie nam opisywała obiekt typu pojazd.

public class Pojazd

{

int rocznik;

string marka;

string model;

string typNadwozia;

}

Spróbujmy teraz stworzyć obiekt o nazwie auto typu Pojazd. Następnie możemy zadeklarować referencję do naszego obiektu auto lub od razu utworzyć nasz obiekt.

Deklaracja obiektu (stworzenie referencji)

Pojazd auto;

Deklaracja obiektu oraz w drugim kroku utworzenie obiektu

Pojazd auto;

auto = new Pojazd();

 

Lub zawrzeć deklarację i utworzenie obiektu w jednym kroku.

Pojazd auto = new Pojazd();

Kurs C#/ASP.NET. Klasy

Klasy

Klasa to taka struktura w programie która spełnia dwie główne funkcje. Klasa może coś robić, czyli zawierać jakiś kod wykonywalny lub coś opisywać np. obiekt.

Przykładem klasy która coś robi (w naszym przypadku wyświetla tekst na ekranie) może być poniższy kod.

Listing. Klasa z kodem wykonywalnym.

static void Main(string[] args)

{

Console.WriteLine(„Witaj świecie, to ja :)”);

}

,a przykładem klasy która coś opisuje jest poniższy kod (klasa opisuje obiekt auto).

Listing. Klasa o nazwie auto opisujące właściwości samochodu.

public class auto

{

int rocznik;

string marka;

string nazwa;

string typNadwozia;

}

Tak jak określamy typ zmiennej, czyli mówimy jakiego rodzaju wartości może przyjmować ta zmienna, tak samo możemy określić typ obiektu. W powyższym przykładzie za pomocą klasy auto określiliśmy typ obiektu, który opisuje samochód. Innymi słowy określiliśmy jakiego rodzaju wartości może przyjmować obiekt typu auto.

Jak wspomniałem już wcześniej klasa może coś robić lub coś opisywać. Do składników klasy zaliczamy pola i metody. Pola to zmienne które przechowują wartości odpowiednich typów, odpowiedniego rodzaju, tak jak w przykładzie wyżej np. rocznik lub marka. Metody zawierają instrukcje wykonywalne, czyli opisują co program ma robić.

Kurs C#/ASP.NET. LINQ to XML

LINQ to XML

Aby wyjaśnić na czym polega technologia LINQ to XML na początku trzeba zgłębić trochę teorii na temat tego języka. LINQ to XML to kolejna technologia LINQ, która opiera się na odczycie i zapisie plików XML. XML z angielskiego Extensible Markup Language, czyli rozszerzalny język znaczników służy do prezentowania danych w uporządkowany sposób. Zaletą tego języka jest to, że jest on niezależny od platformy systemowej. Pliki które będziemy tworzyć za pomocą XML-a są plikami tekstowymi.

Zasada tworzenia treści plików w XML przypomina troszeczkę HTML. Języki te sa podobne z uwagi na wykorzystywanie znaczników w procesie tworzenie pliku. Jest jednak różnica. W HTML nazwy znaczników mamy z góry określone a w XML-u możemy tworzyć je sami. Znaczniki w dokumencie XML umieszczamy w sposób zagnieżdżony ale o tym za chwilkę przy omawianiu tworzenia dokumentów w XML-u. OK, zacznijmy tworzyć coś praktycznego. Poniżej przykład deklaracji pliku XML. W trakcie deklaracji dokumentu XML określamy takie jego właściwości jak wersję, kodowanie.

LINQ to XML
Listing 19.0 Deklaracja dokumentu XML.

Teraz możemy wprowadzać poszczególne elementy. Jak już wcześniej wspomniałem jest kilka zasad którymi powinniśmy się kierować przy tworzeniu dalszej struktury pliku XML.

  • nazwy elementów (znaczników) tworzymy sami,
  • elementy możemy zagnieżdżać w sobie,
  • każdy element musi posiadać znacznik otwierający i zamykający (dobrą praktyką jest, żeby od razu przy tworzeniu jakiegoś elementu tworzyć znacznik otwierający i zamykający wtedy unikniemy błędów i przy większym dokumencie szukania brakującego znacznika),

Poniżej przykład z kilkoma zagnieżdżonymi elementami.

LINQ to XML
Listing 19.1 Przykładowy plik XML.

Należy jeszcze wspomnieć, że dodatkowy przy naszych elementach możemy dodawać dodatkowe informacje. Takie dodatkowe informacje nazywamy atrybutami i dodajemy je w następujący sposób.

LINQ to XML. Deklaracja elementu.
LINQ to XML. Deklaracja elementu.

Przez niektórych niedoceniany ale moim zdaniem niemniej ważnym elementem pliku XML jest komentarz. Komentarze w XML-u dodajemy w poniższy sposób.

LINQ to XML. Dodawanie komentarzy do dokumentu XML.
LINQ to XML. Dodawanie komentarzy do dokumentu XML.

Kod z listingu 19.1 stanowi prosty przykład pliku XML. Moglibyśmy skopiować ten kod, otworzyć notatnik w systemie Windows, skopiować ten kod do naszego pliku i przy zapisywaniu pliku zmienić rozszerzenie pliku na XML i nasz pierwszy plik XML gotowy.

Możemy to także zrobić z poziomu kodu C# w Visual Studio. Aby to zrobić do przestrzeni nazw musimy dodać przestrzeń System.Xml.Linq;, dzięki której będziemy mogli za pomocą C# utworzyć plik XML.

Przy tworzeniu naszego pliku wykorzystamy poniższe instrukcje:

xDocument – deklarujemy nowy plik XML

XDeclaration – deklaracja właściwości naszego odkumentu (wersja, kodowanie itp.)

XElement – dodawanie nowego elementu

XAttribute – dodawanie atrybutu do elementu

XComment – dodawanie komentarza

Teraz spróbujemy utworzyć taką samą strukturę pliku XML jaką przedstawia listing 19.1. Jedyną trudnością jest zagnieżdżenie elementu w elemencie np. zagnieżdżenie elementu <opel> w elemencie <samochod>.

Poniżej pierwszy sposób tworzenia takiego pliku. Polega on na odpowiednim sposobie deklaracji poszczególnych argumentów konstruktora. Poniżej przedstawiam kod dzięki któremu stworzymy dokument XML zgodny z treścią z listingu 19.1. Wykorzystamy w nim instrukcje opisane powyżej.

Listing 19.2 Tworzymy nasz pierwszy plik XML.

Listing 19.2 Tworzymy nasz pierwszy plik XML.
Listing 19.2 Tworzymy nasz pierwszy plik XML.

Zobacz kod.

Pierwszą instrukcją jest konstruktor klasy XDocument, czyli rozpoczynamy tworzenie naszego dokumentu XML. Nasz konstruktor zawiera trzy argumenty, oznaczone różnymi kolorami (listing 19.2). Każdy parametr oddzielamy przecinkiem. Pierwszy parametr (instrukcja XDeclaration), oznaczony kolorem czerwonym, to deklaracja właściwości naszego dokumentu. Drugi argument (instrukcja XComment), oznaczony kolorem pomarańczowym, to komentarz dodany do treści naszego dokumentu. Trzeci argument (instrukcja XElement), oznaczony kolorem niebieskim, to deklaracja naszych elementów. Poleceniem xml.Save(); tworzymy nasz nowy dokument.

Teraz przejdźmy do części gdzie deklarujemy nasze elementy (część niebieska). Poniżej listing 19.3 pokazuje sposób zagnieżdżenia elementów w naszym dokumencie. Poszczególnymi kolorami zaznaczone zostały poszczególne poziomy zagnieżdżenia elementów. W przypadku każdego elementu pierwszym argumentem jest nazwa elementu np. „samochod”, „opel” i „astra”. Zwróćmy uwagę, że drugim parametrem elementu „samochod” jest element o nazwie „opel” a drugim parametrem elementu „opel” jest element „astra”. W ten właśnie sposób zagnieżdżamy elementy.

Listing 19.3 Deklaracja zagnieżdżonych elementów.
Listing 19.3 Deklaracja zagnieżdżonych elementów.

Aby utworzyć nasz nowy plik XML uruchamiamy nasz program. Plik który „zadeklarowaliśmy”, w naszym przypadku plik ma nazwę NaszPierwszyPlikXML.xml, zostanie utworzony w katalogu naszego projektu w podkatalogu bin/Debug. Możemy go wyedytować w notatniku, co obrazuje poniższy rysunek.

Rysunek 19.1 Zawartość pliku „NaszPierwszyPlikXML.xml”.

Rysunek 19.1 Zawartość pliku „NaszPierwszyPlikXML.xml”.
Rysunek 19.1 Zawartość pliku „NaszPierwszyPlikXML.xml”.

Drugim sposobem jest deklarowanie osobno poszczególnych elementów dokumentu XML a dopiero później za pomocą metody Add odpowiednie ich łączenie i zagnieżdżanie. Poniżej przykład takiego podejścia do tworzenia dokumentu XML.

Listing 19.4 Drugi sposób tworzenia dokumentów XML.
Listing 19.4 Drugi sposób tworzenia dokumentów XML.

Zobacz cały kod.

Po uruchomieniu programu (F5) w katalogu naszej aplikacji w podkatalogu bin/Debug, zostanie utworzony plik o nazwie „NaszDrugiPlikXML.xml”. Po otworzeniu naszego pliku w dowolnym edytorze tekstowym np. w notatniku zobaczymy znajomą strukturę naszego pliku XML, co obrazuje poniższy rysunek.

Rysunek 19.2 Zawartość pliku „NaszDrugiPlikXML.xml”.
Rysunek 19.2 Zawartość pliku „NaszDrugiPlikXML.xml”.

Kurs C#/ASP.NET. LINQ to Objects

LINQ to Objects

Jak już wspomniałem dla technologii LINQ źródłem danych może być np. kolekcja, czyli obiekt. Aby pokazać zastosowanie tej technologii prześledźmy sobie poniższy przykład.

Dla potrzeb naszego przykładu stworzymy sobie klasę „Produkt”, która będzie przechowywała model naszego obiektu. W naszym przypadku będą to perfumy.

Listing 18.1 Stworzenie klasy Produkt – modelu danych.

class Produkt
        {
            public int id;
            public string marka, nazwa, 
                  typ,dlaKogo;
            public int pojemnosc, cena;
        }

Określiliśmy model, to teraz stworzymy kolekcję 5 produktów.

Listing 18.2 Tworzymy kolekcję obiektów o typie Produkt.

static List listaProduktow = new List 
{
new Produkt 
{
id=1 , 
marka = "Calvin Klein" , 
nazwa = "Eternity" , 
typ = "woda perfumowana" , 
dlaKogo = "kobiet" , 
pojemnosc = 100 , 
cena = 82
},

new Produkt 
{
id=2 , 
marka = "Calvin Klein" , 
nazwa = "Euphoria" , 
typ ="woda perfumowana" , 
dlaKogo = "kobiet" , 
pojemnosc = 50 , 
cena = 114
},

new Produkt 
{
id=3 , 
marka = "Versace" , 
nazwa = "Bright Crystal" , 
typ ="woda toaletowa" , 
dlaKogo = "kobiet" , 
pojemnosc = 90 , 
cena = 140
},

new Produkt 
{
id=4 , 
marka = "Calvin Klein" , 
nazwa = "Beauty" , 
typ ="woda perfumowana" , 
dlaKogo = "kobiet" , 
pojemnosc = 100 , 
cena = 106
},

new Produkt 
{
id=5 , 
marka = "Dolce & Gabbana" , 
nazwa = "Light Blue" , 
typ ="woda toaletowa" , 
dlaKogo = "kobiet" , 
pojemnosc = 100 , 
cena = 152
}
};

I tutaj dochodzimy do stworzenia zapytania w technologii LINQ do naszego źródła danych, w naszym przypadku jest to kolekcja „listaProduktow”.Na początku stworzymy sobie listę wszystkich obiektów z kolekcji.

Listing 18.3 Tworzymy zapytanie LINQ do kolekcji listaProdutkow.

// tworzenie zapytanie LINQ to Objects
var listaWszystkichProduktow = 
from produkt in listaProduktow
//sortujemy wg marki i ceny
orderby produkt.marka, produkt.cena 
select produkt;
// od razu wyprowadźmy sobie wynik tego 
//zapytania na ekran za pomocą pętli foreach
foreach (var produkt in listaWszystkichProduktow)
 Console.WriteLine(produkt.marka + " " + produkt.nazwa + " " + produkt.cena + " zł");

Łączymy wszystko, co zrobiliśmy do tej pory.

Zobacz cały kod.

Poniżej zrzut ekranu po uruchomieniu programu.

LIKQ to Objects
Rysunek 1. Wynik uruchomienia programu.

Operator JOIN

 

Za pomocą technologii LINQ to Objects możemy łączyć zbiory/kolekcje które nie posiadają takiej samej struktury. Do takiej operacji wykorzystujemy operator JOIN. Dla naszych potrzeb z kolekcji listaProdutków stworzymy sobie dwie kolekcje. Pierwsza będzie zawierała id, markę, nazwę i typ, a druga będzie zawierała id, dlaKogo, pojemność i cenę.

Tworzymy pierwszą kolekcję o nazwie perfumy_dane_podstawowe.

Listing 18.5 Tworzymy kolekcję perfumy_dane_podstawowe.

var perfumy_dane_podstawowe = 
from perfumyDP in listaProduktow
       select new { 
                perfumyDP.id , 
                perfumyDP.marka , 
                perfumyDP.nazwa , 
                perfumyDP.typ 
       };

a następnie tworzymy drugą kolekcję perfumy_dane_dodatkowe

Listing 18.6 Tworzymy kolekcję perfumy_dane_dodatkowe.

var perfumy_dane_dodatkwoe = 
from perfumyDD in listaProduktow
       select new { 
         perfumyDD.id, 
         perfumyDD.dlaKogo , 
         perfumyDD.pojemnosc , 
         perfumyDD.cena
       };

Mamy więc dwie kolekcje dotyczące tych samych perfum ale zawierające różne dane. Do prawidłowego połączenia obu kolekcji potrzebujemy jakiegoś klucza, bo chcemy aby dane z pól: dlaKogo, pojemność i cena były przyporządkowane do odpowiednich nazw perfum. Aby móc to zrobić w obu kolekcjach powinno znajdować się pole wg którego będzie możliwe wiązanie i w naszym przypadku tym polem (kluczem) jest pole id. Teraz za pomocą tego klucza (pole Id) wykorzystując operator JOIN będę mógł połączyć obie kolekcje w jedną, co prezentuje poniższy listing.

Listing 18.7 Łączenie dwóch kolekcje z wykorzystaniem operatora JOIN.

var perfumy_wszystkie_dane = 
from perfumy_DP in perfumy_dane_podstawowe
join perfumy_DD in perfumy_dane_dodatkowe
on perfumy_DP.id equals perfumy_DD.id
       select new
{
       perfumy_DP.id,
       perfumy_DP.marka,
       perfumy_DP.nazwa,
       perfumy_DD.pojemnosc,
       perfumy_DD.cena
};

Słówko wyjaśnienia do powyższego kodu. Po słówku FROM określamy pierwszą kolekcję które będzie podlegała łączeniu. Następnie musimy wskazać kolekcję z którą będziemy chcieli łączyć tą pierwszą ale żeby kompilator nas zrozumiał dodajemy słówko JOIN i po nim określamy drugą kolekcję do łączenia. Jak już wcześniej wspomniałem obie kolekcje łączymy po kluczu którym w naszym przypadku jest pole id i to musimy wpisać w kolejnym kroku. Po słówku ON wskazujemy pole id w pierwszej kolumnie, następnie wpisujemy słówko equals (określające, że oba pola id w obu kolekcjach musza być równe) i wskazujemy pole id w drugiej kolekcji. Po słówku SELECT NEW wypisujemy pola jakie chcemy uwzględnić w nowej kolekcji.

Kurs C#/ASP.NET. LINQ

LINQ

LINQ (ang. Language Integrated Query) w tłumaczeniu na polski znaczy zapytania zbieżne z językiem programowania lub krócej zintegrowany język zapytań.

W dzisiejszym „informatycznym świecie” przeważająca większość aplikacji korzysta z relacyjnych baz danych, są one w zasadzie standardem a co za tym idzie obecność języka SQL. LINQ to nowe podejście do kwestii łączenia ze źródłami danych. Jego funkcjonalność jest znacznie rozszerzona i umożliwia odpytywanie obiektów, jako źródeł danych. Składnia zapytań LINQ przypomina budowanie zapytań w języku SQL ale jednocześnie uniezależnia aplikację od konkretnego źródła danych. Najważniejsze technologie LINQ to LINQ to Objects, LINQ to XML i LINQ to SQL i właśnie na tych zagadnieniach skupimy się w niniejszym kursie.

Poniżej standardowe (niektóre, najczęściej używane) operatory LINQ.

Nazwa operatora Wyjaśnienie działania operatora
Select Operator jest wykorzystywany do pobrania odpowiednich (wybranych przez nas) danych ze źródła danych.
SelectMany Obieranie danych w przypadki relacji jeden-do-wielu np. gdy obiekt który pobieramy z kolekcji posiada inną kolekcję.
Where Operator służy do określenia warunków filtrowania. Jeżeli obiekt ze źródła danych nie pasuje do zadanych reguł filtrowania nie będzie pobrany w zapytaniu.
Count Operator służy do zliczenia elementów kolekcji.
Max Operator służy do otrzymania wartości maksymalnej (np. znalezienie najstarszego pracownika w firmie).
Min Operator służy do otrzymania wartości minimalnej (np. znalezienie najmniej zarabiającego pracownika w firmie).
Sum Operator służy do otrzymania sumy wybranych wartości (np. suma pensji wszystkich pracowników w dziale).
OrderBy Operator służy do sortowania wyników zapytania według zadanego kryterium (np. sortowanie listy pracowników po nazwisku lub po wielkości pensji itp).
First Operator służy do zwrócenia pierwszego elementu kolekcji.
FirstOrDefault Operator służy do zwrócenia pierwszego elementu kolekcji bądź NULL, jeżeli kolekcja jest pusta.
Last Operator służy do zwrócenia ostatniego elementu kolekcji.
LastOrDefault Operator służy do zwrócenia ostatniego elementu kolekcji bądź NULL, jeżeli kolekcja jest pusta.
Single Operator służy do zwrócenia pojedynczego elementu kolekcji (wg zadanych kryteriów).
GroupBy Operator służy do grupowania elementów w zapytaniu.
Join Operator służy do łączenia dwóch zbiorów danych niekoniecznie o takiej samej strukturze encji.
Skip Operator służy do pomijania elementów.
All Operator służy do sprawdzenia czy wszystkie elementy kolekcji spełniają zadany warunek.
Any Operator służy do sprawdzenia czy którykolwiek element kolekcji spełnia zadany warunek.
Contains Operator służy do sprawdzenia czy w wyniku zapytania znajduje się konkretny obiekt.
Concat Operator wykorzystujemy do operacji na zbiorach. Służy do łączenia np. dwóch kolekcji (nowy zbiór zawiera wszystkie elementy jednego i drugiego zbioru; gdy w obu zbiorach istnieją takie same elementy nowy zbiór także będzie zawierał duplikaty).
Distinct Operator służy do usuwania duplikatów (zdublowanych elementów).
Except Operator wykorzystujemy do operacji na zbiorach. Służy do
Union Operator wykorzystujemy do operacji na zbiorach. Służy do łączenia np. dwóch kolekcji z wyłączeniem duplikatów.

Kurs C#/ASP.NET. Instrukcja switch.

Instrukcja switch.

Instrukcja switch pomaga nam w porównaniu wartości jakiejś zmiennej i w zależności od jej wartości wykonaniu odpowiednich poleceń. Poniżej ogólna definicja instrukcji switch.

switch (x)
{
              case 1: instrukcja 1;
                    break;
              case 2: instrukcja 2;
                    break;
              …
              case 5: instrukcja 5;
                    break;
              default: instrukcja 10;
                    break;
       }

W powyższym przykładzie chodzi o wykonanie odpowiednich instrukcji w zależności od wartości jaką przyjmuje zmienna „x”. Przeanalizujmy pierwszy przypadek, czyli „case 1: instrukcja 1;”. Wytłumaczę to w ten sposób. Jeśli zmienna „x” jest równa „1” (wartość po słówku case) to wykonaj instrukcję 1. W przykładzie mamy pojedynczą instrukcję, ale możemy zastosować ich kilka stosując nawiasy klamrowe {}. W takim przypadku nasz przypadek wyglądałby tak jak poniżej.

case 1: { instrukcja 1; instrukcja 1a;}

Zauważmy, że po każdym przypadku (case) występuje instrukcja break; która mówi kompilatorowi, że ma zakończyć działanie instrukcji switch. Działa to w ten sposób, że kompilator idzie od początku i analizuje wszystkie przypadki. Jeżeli natrafi na jakiś, który jest prawdziwy, wykonuje instrukcję przy tym przypadku i kończy działanie instrukcji switch. Do omówienia została jeszcze jedna kwestia. Co oznacza przypadek default. Oznacz tyle, że jeśli kompilator nie natrafi na żaden przypadek wcześniej który jest prawdziwy, wykona instrukcję z przypadku default. Inaczej, przypadek default zawiera w sobie wszystkie inne przypadki niż określone przed nim.

Poniżej przykład ilustrujący zastosowanie instrukcji switch.

Instrukcja switch
Rysunek 16.1 zastosowanie instrukcji switch

Listing z rysunku 16.1

Kurs C#. Zmienne domniemane.

Zmienne domniemane.

Zmienne domniemane to zmienne, przy których nie musimy podawać typu. Chodzi o to, że kompilator sam przyporządkowuje typ do zmiennej w momencie jej inicjalizacji na podstawie danych, jakie chcemy do tej zmiennej przypisać. Deklaracja i inicjalizacja zmiennej musi nastąpić w jednym kroku, bo bez tego kompilator nie będzie mógł określić typu zmiennej. Przy deklaracji zmiennych domniemanych używamy słówka var.

Deklaracja i inicjalizacja zmiennych w sposób standardowy.

   int x = 10;
   string y = „Ala ma kota”;

Poniżej deklaracja i inicjalizacja zmiennych z poprzedniego przykładu w sposób „domniemany”.

   var x = 10;
   var y = „Ala ma kota”;

Kurs C#/ASP.NET. Instrukcja warunkowa if else.

Instrukcja warunkowa if else.

Instrukcja warunkowa if else działa tak samo jak instrukcja if z tą różnicą, że tutaj określany także co ma się stać w sytuacji nie spełnienia warunku. Ogólna definicja instrukcji if else przedstawiona jest poniżej.

   if (warunek) 
         instrukcja_gdy_warunek_spełniony;
   else
         instrukcja_gdy_warunek_nie_spełniony;

W przypadki potrzeby wykonania kilku instrukcji przy spełnionym lub nie spełnionym warunku definicja może przyjąć postać, jak poniżej.

   if (warunek) 
{
// blok instrukcji, gdy warunek spełniony
Instrukcja 1;
Instrukcja 2;
}
   else
{
// blok instrukcji, gdy warunek nie spełniony
Instrukcja 1;
Instrukcja 2;
}
instrukcja warunkowa if else
Rysunek 14.1 Przykład zastosowania instrukcji warunkowej if else.

Listing z rysunku 14.1

Instrukcje if else możemy wykorzystać także do obsłużenia więcej niż dwóch warunków. Możemy zagnieżdżać je w sobie. Poniżej przykład takiego zastosowania instrukcji if else.

instrukcja warunkowa if else
Rysunek 14.2 Przykład zastosowania instrukcji warunkowej if else, zagnieżdżanie.

Listing z rysunku 14.2

Kurs C#/ASP.NET. Instrukcja warunkowa if.

Instrukcja warunkowa if.

 

Instrukcja warunkowa if jest wykorzystywana w kodzie w sytuacji kiedy np. mamy sprawdzić jakiś warunek. Jeżeli warunek jest spełniony to wykonujemy jakąś instrukcję lub blok instrukcji. IPoniżej ogólna deklaracja instrukcji warunkowej if.

if (warunek) instrukcja

Jeżeli warunek zawarty w nawiasach okrągłych jest spełniony to wykonywana jest instrukcja po nawiasie, co obrazuje rysunek poniżej.

instrukcja warunkowa if
Rysunek 13.1 Przykład instrukcji warunkowej if.

Wyjaśnię co po kolei dzieje się w naszym krótkim programie. Na początku deklarujemy zmianną x i przypisujemy do niej wartość 5. Później przy wykorzystaniu instrukcji warunkowej if sprawdzamy zmienną x czy jest równa 5. Jeżeli tak, a w naszym przypadku właśnie tak jest, to wykonywana jest instrukcja po nawiasie okrągłym czyli wyświetlenie na ekranie treści w „x=5”. Zwróć uwagę, że w nawiasie okrągłym gdzie sprawdzamy warunek korzystamy z operatora porównania „==”. Dzięki poleceniu Console.ReadKey(); program czeka na wciśnięcie jakiegokolwiek klawisza z klawiatury.

Co jednak jeżeli chcielibyśmy wykonać kilka instrukcji w sytuacji kiedy warunek jest spełniony. Wtedy blok instrukcji do wykonania umieszczamy w nawiasach klamrowych, co obrazuje poniższy przykład.

if (warunek) 
   { 
      instrukcja 1;
      instrukcja 2;
      …
      instrukcja 10;
   }

Poniższy przykład przedstawia właśnie taką sytuację.

instrukcja warunkowa if
Rysunek 13.2 Przykład instrukcji warunkowej if z blokiem instrukcji.

Kurs C#. Tablica wielowymiarowa.

Tablica wielowymiarowa.

Żeby nie było tak prosto oprócz tablic jednowymiarowych, opisanych w poprzednim podrozdziale, istnieją także tablice wielowymiarowe. W takiej tablicy jedno pole (jeden element) jest reprezentowany przez dwa index-y. Do naszej tabeli z poprzedniego rozdziału (przechowującej polskie nazwy miesięcy) chcemy dopisać angielskie nazwy miesięcy. Poniżej wizualizacja takiej tabeli wielowymiarowej.

12.1 Wizualizacja tabeli dwu wymiarowej.
12.1 Wizualizacja tabeli dwu wymiarowej.

Poniżej przykład deklaracji tablicy wielowymiarowej.

// deklaracja tablicy wielowymiarowej
            string[,] nazwyMiesiecy;

Zwróć uwagę, że w nawiasie kwadratowym jest przecinek sugerujący, że jest to tablica wielowymiarowa (jeden przecinek sugeruje, że jest to tablica dwu wymiarowa).

Następnie musimy naszą tablicę zainicjalizować.

//inicjalizacja tablicy wielowymiarowej [2-wiersze,12-kolumn]
            nazwyMiesiecy = new string[2, 12];

Teraz pozostaje nam wprowadzić do odpowiednich pól wartości naszej tablicy, co prezentuje poniższy kod.

Listing 12.1 Wprowadzanie wartości do tablicy dwu wymiarowej komórka po komórce.

//przypisanie wartości do poszczególnych pól tablicy wielowymiarowej
            nazwyMiesiecy[0, 0] = "Styczeń";
            nazwyMiesiecy[1, 0] = "January";
            nazwyMiesiecy[0, 1] = "Luty";
            nazwyMiesiecy[1, 1] = "February";
            nazwyMiesiecy[0, 2] = "Marzec";
            nazwyMiesiecy[1, 2] = "March";
            nazwyMiesiecy[0, 3] = "Kwiecień";
            nazwyMiesiecy[1, 3] = "April";
            nazwyMiesiecy[0, 4] = "Maj";
            nazwyMiesiecy[1, 4] = "May";
            nazwyMiesiecy[0, 5] = "Czerwiec";
            nazwyMiesiecy[1, 5] = "June";
            nazwyMiesiecy[0, 6] = "Lipiec";
            nazwyMiesiecy[1, 6] = "July";
            nazwyMiesiecy[0, 7] = "Sierpień";
            nazwyMiesiecy[1, 7] = "August";
            nazwyMiesiecy[0, 8] = "Wrzesień";
            nazwyMiesiecy[1, 8] = "September";
            nazwyMiesiecy[0, 9] = "Październik";
            nazwyMiesiecy[1, 9] = "Oktober";
            nazwyMiesiecy[0, 10] = "Listopad";
            nazwyMiesiecy[1, 10] = "November";
            nazwyMiesiecy[0, 11] = "Grudzień";
            nazwyMiesiecy[1, 11] = "December";

 

Zwróćcie uwagę, że indeksy w pionie (wierszy) także zaczynają się od wartości „0”. Żeby odwołać się do konkretnej wartości należy wskazać index wiersza i po przecinku index kolumny np. jeżeli chcemy odwołać się do wartości „November” wpiszemy poniższy kod.

// wyświetlenie na ekranie wartości "November" z tablicy
            Console.WriteLine(nazwyMiesiecy[1,10]);

Dokładnie tak samo jak przy tablicach jednowymiarowych istnieje możliwość zapisu w jednym kroku deklaracji, inicjalizacji i przypisania wartości do pól tablicy wielowymiarowej. Poniższy kod prezentuje jeden ze sposobów przypisania wartości do tablicy dwu wymiarowej.

Listing 12.2 Wprowadzanie wartości do tablicy dwu wymiarowej w jednym kroku – sposób 1.

// deklaracja,inicjalizacja i przypisanie wartości do tablicy dwu wymiarowej w jednym kroku
            string[,] nazwyMiesiecy = new string[,]
                  {
                     {"Styczeń","January"},
                     {"Luty","February"},
                     {"Marzec","March"},
                     {"Kwiecień","April"},
                     {"Maj","May"},
                     {"Czeriec","June"},
                     {"Lipiec","July"},
                     {"Sierpień","August"},
                     {"Wrzesień","September"},
                     {"Październik","October"},
                     {"Listopad","November"},
                     {"Grudzień","December"}
                  };

Poniżej wizualizacja tablicy dwu wymiarowej z powyższego listingu.

Tabela 12.2 Wizualizacja tablicy dwu wymiarowej z listingu 12.2

12.2 Wizualizacja tablicy dwu wymiarowej z listingu 12.2.
Rysunek 12.2 Wizualizacja tablicy dwu wymiarowej z listingu 12.2.

Zwróćcie uwagę, że teraz polskie nazwy miesięcy tworzą pierwszą kolumnę a angielskie nazwy tworzą drugą kolumnę. Odwołanie się np. do wartości „November” będzie wyglądało następująco.

// wyświetlenie na ekranie wartości "November" z tablicy
            Console.WriteLine(nazwyMiesiecy1[10, 1]);

Przypisania takich samych wartości do tablicy dwu wymiarowej możemy zrealizować także w inny sposób.

Listing 12.3 Wprowadzanie wartości do tablicy dwu wymiarowej w jednym kroku – sposób 2.

// deklaracja, inicjalizacja i przypisanie wartości do tablicy dwu wymiarowej w jednym kroku
            string[,] nazwyMiesiecy = new string[,]
                 {
                      {"Styczeń","Luty","Marzec","Kwiecień","Maj","Czerwiec","Lipiec","Sierpień","Wrzesień","Październik","Listopac","Grudzień"},
                      {"January","February","March","April","May","June","July","August","September","October","November","December"}
                 };

Natomiast w sposobie drugim polskie nazwy tworzą pierwszy ale wiersz a nazwy angielskie są umieszczone w drugim wierszy (inaczej niż w przykładnie z listingu 12.2). Wizualizacja tablicy dwu wymiarowej z listingu 12.3 prezentuje się następująco.

Tabela 12.2 Wizualizacja tabeli dwu wymiarowej z listingu 12.3.

12.1 Wizualizacja tabeli dwu wymiarowej.
Rysunek 12.1 Wizualizacja tabeli dwu wymiarowej z listingu 12.3.

I gdybyśmy tutaj chcieli się odwołać także do wartości „November” musielibyśmy wpisać.

// wyświetlenie na ekranie wartości z tablicy
            Console.WriteLine(nazwyMiesiecy2[1, 10]);