Wstęp do programowania w języku C#

Wydawnictwo Helionul. Koœciuszki 1c44-100 Gliwicetel. 032 230 98 63e-mail: [email protected]

PRZYK£ADOWY ROZDZIA£PRZYK£ADOWY ROZDZIA£

IDZ DOIDZ DO

ZAMÓW DRUKOWANY KATALOGZAMÓW DRUKOWANY KATALOG

KATALOG KSI¥¯EKKATALOG KSI¥¯EK

TWÓJ KOSZYKTWÓJ KOSZYK

CENNIK I INFORMACJECENNIK I INFORMACJE

ZAMÓW INFORMACJEO NOWOœCIACH

ZAMÓW INFORMACJEO NOWOœCIACH

ZAMÓW CENNIKZAMÓW CENNIK

CZYTELNIACZYTELNIAFRAGMENTY KSI¥¯EK ONLINEFRAGMENTY KSI¥¯EK ONLINE

SPIS TREœCISPIS TREœCI

DODAJ DO KOSZYKADODAJ DO KOSZYKA

KATALOG ONLINEKATALOG ONLINE

Wstêp do programowaniaw jêzyku C#

Autor: Adam BoduchISBN: 83-246-0523-1Format: B5, stron: 392Przyk³ady na ftp: 1421 kB

Zostañ profesjonalnym programist¹ C#

C# jest uwa¿any przez wielu programistów za najlepszy jêzyk stosowany do tworzenia aplikacji dla platformy .NET. Jêzyk ten, opracowany w firmie Microsoft, ³¹czy w sobie najbardziej wartoœciowe cechy C++ i Javy, œcis³¹ integracjê z komponentami .NET, wysoki poziom bezpieczeñstwa i ogromne mo¿liwoœci. œwietnie nadaje siê do tworzenia aplikacji sieciowych i bazodanowych przeznaczonych zarówno dla systemu Windows, jak i dla urz¹dzeñ przenoœnych, takich jak PocketPC. Popularnoœæ C# stale roœnie,a nieodp³atne udostêpnienie przez firmê Microsoft œrodowiska programistycznego Visual C# Express Edition sprawi³o, ¿e coraz wiêcej twórców oprogramowania wykorzystuje je w swojej pracy.

Ksi¹¿ka „Wstêp do programowania w jêzyku C#” to podrêcznik przeznaczony dlatych, którzy chc¹ poznaæ ten jêzyk od podstaw. Czytaj¹c j¹, poznasz mo¿liwoœci C#i platformy .NET. Nauczysz siê tworzyæ w³asne aplikacje, korzystaj¹c ze œrodowiska Visual C# Express Edition. W ksi¹¿ce znajdziesz omówienie sk³adni i elementów jêzyka C#, wyjaœnienie zasad programowania obiektowego i sposobów realizacji ró¿nych zadañ programistycznych. Napiszesz aplikacje dla Windows wykorzystuj¹ce biblioteki klas .NET i obs³uguj¹ce pliki w formacie XML.

• Konstrukcja platformy .NET• Sk³adnia C#• Elementy jêzyka• Programowanie obiektowe• Obs³uga zdarzeñ• Korzystanie z tablic i kolekcji• Obs³uga wyj¹tków• Biblioteka Windows Forms• Stosowanie komponentów .NET• Operacje na plikach i strumieniach• Obs³uga formatu XML

http://helion.pl/view/2547w



http://helion.pl/add/2547w/wstpch




mailto:[email protected]

http://helion.pl/view/2547w/wstpch.htm

ftp://ftp.helion.pl/przyklady/wstpch.zip

S:\ Sylwia\pdf\Wstep do programownia w jezyku C#\_spis treści.doc 3

Spis treściPrzedmowa ..................................................................................... 11

Rozdział 1. Wprowadzenie ................................................................................ 13Czym jest programowanie ..............................................................................................13

Mnogość języków programowania ...........................................................................14Edytory kodu ............................................................................................................15Kompilatory ..............................................................................................................15Mity związane z programowaniem ...........................................................................16

Języki programowania ....................................................................................................17Asembler ..................................................................................................................18Fortran ......................................................................................................................19C ...............................................................................................................................19C++ ...........................................................................................................................19Perl ...........................................................................................................................20PHP ...........................................................................................................................20Turbo Pascal .............................................................................................................20Java ...........................................................................................................................21

Język maszynowy ...........................................................................................................21Działanie kompilatorów ..................................................................................................22

Tworzenie kodu źródłowego ....................................................................................22Prekompilacja ...........................................................................................................23Kompilacja do kodu Asemblera ...............................................................................23Optymalizacja kodu ..................................................................................................23Asemblacja ...............................................................................................................23Konsolidacja .............................................................................................................24

Języki interpretowane .....................................................................................................24Język C# .........................................................................................................................24Instalacja środowiska ......................................................................................................24Jak się uczyć ...................................................................................................................25

Nie ucz się na pamięć! ..............................................................................................25Początkowe trudności ...............................................................................................25Pomoc systemowa ....................................................................................................25Praktyka ....................................................................................................................26

Pierwsza aplikacja ..........................................................................................................26Kompilacja i uruchamianie .......................................................................................26Komponenty .............................................................................................................28Piszemy kod .............................................................................................................29Zapisywanie projektu ...............................................................................................29

Podsumowanie ................................................................................................................30

4 Wstęp do programowania w języku C#

4 S:\ Sylwia\pdf\Wstep do programownia w jezyku C#\_spis treści.doc

Rozdział 2. Podstawy platformy .NET ................................................................ 31Interfejs programistyczny ...............................................................................................32

API systemu Windows .............................................................................................32Wizja .NET .....................................................................................................................33

Składniki platformy .NET ........................................................................................34Konkluzja .................................................................................................................37

C# a .NET .......................................................................................................................37Rodzaje aplikacji ............................................................................................................38

Aplikacje konsolowe ................................................................................................38Windows Forms ........................................................................................................38Formularze Web Forms ............................................................................................38

Składniki .NET Framework ............................................................................................39Usługi sieciowe ...............................................................................................................39

Niezależność .............................................................................................................40Uniwersalność ..........................................................................................................40

Podsumowanie ................................................................................................................41

Rozdział 3. Podstawy języka C# ....................................................................... 43Podstawowa składnia ......................................................................................................43

Najprostszy program .................................................................................................45Jak kompilatory czytają kod .....................................................................................45Wielkość znaków ......................................................................................................45Program musi posiadać metodę Main .......................................................................46Średnik kończy instrukcję .........................................................................................46Program musi posiadać klasę ....................................................................................47Wcięcia, odstępy ......................................................................................................47Słowa kluczowe ........................................................................................................47Symbole ....................................................................................................................47

Komentarze .....................................................................................................................48Podzespoły, metody, klasy ..............................................................................................49

Funkcje .....................................................................................................................49Metody .....................................................................................................................50Klasy .........................................................................................................................50Przestrzenie nazw .....................................................................................................51Operator kropki ........................................................................................................51Słowo kluczowe using ..............................................................................................52

Zmienne ..........................................................................................................................53Deklarowanie zmiennych .........................................................................................53Przydział danych ......................................................................................................54Typy danych .............................................................................................................55Restrykcje w nazewnictwie ......................................................................................55

Stałe ................................................................................................................................56Operacje na konsoli ........................................................................................................57

Metody klasy Console ..............................................................................................58Właściwości klasy Console ......................................................................................58

Operatory ........................................................................................................................59Operatory porównania ..............................................................................................60Operatory arytmetyczne ...........................................................................................60Operator inkrementacji oraz dekrementacji ..............................................................61Operatory logiczne ...................................................................................................62Operatory bitowe ......................................................................................................62Operatory przypisania ...............................................................................................63Inne operatory ...........................................................................................................63

Spis treści 5


Instrukcje warunkowe .....................................................................................................63Instrukcja if ...............................................................................................................64Słowo kluczowe else ................................................................................................68Instrukcja else if .......................................................................................................69Instrukcja switch .......................................................................................................70

Pętle ................................................................................................................................73Pętla while ................................................................................................................73Pętla do-while ...........................................................................................................75Pętla for ....................................................................................................................76Instrukcja break ........................................................................................................77Instrukcja continue ...................................................................................................78Operator warunkowy ................................................................................................79

Konwersja danych ..........................................................................................................80Rzutowanie .....................................................................................................................81Przykładowa aplikacja ....................................................................................................81Dyrektywy preprocesora .................................................................................................83

Deklarowanie symboli ..............................................................................................84Instrukcje warunkowe ...............................................................................................84Błędy i ostrzeżenia ...................................................................................................85

Podsumowanie ................................................................................................................86

Rozdział 4. Przegląd .NET Framework ............................................................... 87Środowisko CLR ............................................................................................................87

Kod pośredni IL ........................................................................................................88Kod zarządzany i niezarządzany ...............................................................................89Moduł zarządzany ....................................................................................................89Podzespoły ................................................................................................................90Działanie CLR ..........................................................................................................90

System CTS ....................................................................................................................91Specyfikacja CLS ...........................................................................................................92Biblioteka klas ................................................................................................................93Moduły, przestrzenie nazw .............................................................................................93

Wieloznaczność ........................................................................................................95Główne przestrzenie nazw ........................................................................................96

Podsumowanie ................................................................................................................97

Rozdział 5. Programowanie obiektowe .............................................................. 99Na czym polega programowanie obiektowe ...................................................................99Podstawowy kod formularza WinForms .......................................................................101

Moduł Form1.Designer.cs ......................................................................................103Generowanie kodu ..................................................................................................104Ukrywanie kodu .....................................................................................................105

Programowanie zdarzeniowe ........................................................................................106Generowanie zdarzeń .............................................................................................106Obsługa zdarzeń .....................................................................................................110

Klasy .............................................................................................................................110Składnia klasy .........................................................................................................110Do czego służą klasy ..............................................................................................111Instancja klasy ........................................................................................................112Klasy zagnieżdżone ................................................................................................114

Pola ...............................................................................................................................114



Metody ..........................................................................................................................115Zwracana wartość ...................................................................................................116Parametry metod .....................................................................................................116Przeciążanie metod .................................................................................................118Przekazywanie parametrów ....................................................................................119

Dziedziczenie ................................................................................................................122Klasa domyślna ......................................................................................................123

Hermetyzacja ................................................................................................................123Modyfikatory dostępu ...................................................................................................123

Sekcja private .........................................................................................................124Sekcja public ..........................................................................................................125Sekcja protected ......................................................................................................126Sekcja internal ........................................................................................................127

Konstruktor ...................................................................................................................127Pola tylko do odczytu .............................................................................................128

Destruktor .....................................................................................................................129Właściwości ..................................................................................................................129

Modyfikatory dostępu .............................................................................................132Elementy statyczne .......................................................................................................132

Metody statyczne ....................................................................................................133Klasy statyczne .......................................................................................................134

Polimorfizm ..................................................................................................................135Ukrywanie elementów klas .....................................................................................135Słowo kluczowe base ..............................................................................................137Metody wirtualne ....................................................................................................139Przedefiniowanie metod .........................................................................................140Elementy abstrakcyjne ............................................................................................141Elementy zaplombowane ........................................................................................142

.NET Framework Class Library ....................................................................................142Przestrzenie nazw ...................................................................................................143Klasa System.Object ...............................................................................................143

Opakowywanie typów ..................................................................................................145Interfejsy .......................................................................................................................146

Implementacja wielu interfejsów ............................................................................147Typy wyliczeniowe .......................................................................................................148

Wartości elementów ...............................................................................................149Struktury .......................................................................................................................150

Konstruktory struktur .............................................................................................152Operatory is i as ............................................................................................................154Przeładowanie operatorów ............................................................................................155

Słowo kluczowe operator .......................................................................................156Dzielenie klas ................................................................................................................ 158Podsumowanie ..............................................................................................................158

Rozdział 6. Delegaty i zdarzenia ...................................................................... 159Delegaty ........................................................................................................................159

Tworzenie delegatów ..............................................................................................160Użycie delegatów ...................................................................................................161Funkcje zwrotne .....................................................................................................163Delegaty złożone ....................................................................................................165Metody anonimowe ................................................................................................165

Zdarzenia ......................................................................................................................166Podsumowanie ..............................................................................................................169

Spis treści 7


Rozdział 7. Tablice i kolekcje ......................................................................... 171Czym są tablice .............................................................................................................171Deklarowanie tablic ......................................................................................................172

Indeks .....................................................................................................................172Inicjalizacja danych ................................................................................................173

Tablice wielowymiarowe ..............................................................................................173Pętla foreach .................................................................................................................174

Pętla foreach a tablice wielowymiarowe ................................................................176Tablice tablic ................................................................................................................ 177Tablice struktur .............................................................................................................177Parametr args w metodzie Main() .................................................................................178Klasa System.Array ......................................................................................................179

Metody klasy ..........................................................................................................180Słowo kluczowe params .........................................................................................185

Przykład — gra kółko i krzyżyk ...................................................................................186Zasady gry ..............................................................................................................186Specyfikacja klasy ..................................................................................................186Ustawienie symbolu na planszy ..............................................................................190Sprawdzenie wygranej ............................................................................................191Interfejs aplikacji ....................................................................................................196

Mechanizm indeksowania .............................................................................................201Indeksy łańcuchowe ...............................................................................................203

Kolekcje ........................................................................................................................204Interfejsy System.Collections .................................................................................204Stosy .......................................................................................................................206Kolejki ....................................................................................................................208Klasa ArrayList ......................................................................................................209

Listy ..............................................................................................................................209Typy generyczne ....................................................................................................210Korzystanie z list ....................................................................................................212

Słowniki ........................................................................................................................214Przykładowy program .............................................................................................215

Podsumowanie ..............................................................................................................217

Rozdział 8. Obsługa wyjątków ........................................................................ 219Czym są wyjątki ...........................................................................................................220Obsługa wyjątków ........................................................................................................220

Blok finally .............................................................................................................221Zagnieżdżanie wyjątków ........................................................................................222

Klasa System.Exception ...............................................................................................223Selektywna obsługa wyjątków ...............................................................................223Wywoływanie wyjątków ........................................................................................224

Własne klasy wyjątków ................................................................................................224Deklarowanie własnej klasy ...................................................................................225Przykładowa aplikacja ............................................................................................226

Przepełnienia zmiennych ..............................................................................................229Podsumowanie ..............................................................................................................230

Rozdział 9. Łańcuchy w C# ............................................................................. 231Typ System.String ........................................................................................................231

Unicode w łańcuchach ............................................................................................232Niezmienność łańcuchów .......................................................................................232Konstruktory klasy .................................................................................................233Operacje na łańcuchach ..........................................................................................234



Łańcuchy w WinForms .................................................................................................239Klasa StringBuilder ......................................................................................................241

Metody klasy StringBuilder ....................................................................................242Zastosowanie klasy StringBuilder ..........................................................................242

Formatowanie łańcuchów .............................................................................................244Specyfikatory formatów ...............................................................................................246

Własne specyfikatory formatowania .......................................................................248Specyfikatory typów wyliczeniowych ....................................................................249

Typ System.Char ..........................................................................................................250Podsumowanie ..............................................................................................................251

Rozdział 10. Biblioteka Windows Forms ............................................................ 253Podzespół System.Windows.Forms ..............................................................................253

Okno Object Browser .............................................................................................254Przestrzeń System.Windows.Forms ........................................................................254

Podstawowe klasy .........................................................................................................255System.ComponentModel.Component ...................................................................256System.Windows.Forms.Control ............................................................................256System.Windows.Forms.Application .....................................................................256

Przykład działania .........................................................................................................261Przygotowanie klasy ...............................................................................................261Projektowanie interfejsu .........................................................................................261Rozwiązania programistyczne ................................................................................262

Technika „przeciągnij i upuść” .....................................................................................266Tworzenie menu ...........................................................................................................270

Właściwości menu ..................................................................................................271Ikony dla menu .......................................................................................................271Skróty klawiaturowe ...............................................................................................274Menu podręczne .....................................................................................................274

Paski narzędziowe ........................................................................................................275Pasek statusu .................................................................................................................276Zakładki ........................................................................................................................276Kontrolki tekstowe ........................................................................................................277

Komponent RichTextBox .......................................................................................280Okna dialogowe ............................................................................................................281

Właściwości okien dialogowych ............................................................................282Aplikacja — edytor tekstów ...................................................................................283

Tworzenie nowego formularza .....................................................................................284Podsumowanie ..............................................................................................................285

Rozdział 11. Podzespoły .NET ........................................................................... 287Czym jest COM ............................................................................................................287

Kontrolka w rozumieniu COM ...............................................................................288Odrobinę historii .....................................................................................................288ActiveX ..................................................................................................................288DCOM ....................................................................................................................289

Podstawowy podzespół .................................................................................................289Deasembler .NET ...................................................................................................289

Komponenty .NET ........................................................................................................291Przygotowanie komponentu w Delphi ....................................................................291Przygotowanie komponentu C# ..............................................................................293Zalety stosowania podzespołów .............................................................................295

Budowa podzespołu ......................................................................................................296Atrybuty podzespołu .....................................................................................................297

Spis treści 9


Mechanizm refleksji .....................................................................................................298Funkcja GetType ....................................................................................................299Klasa System.Type .................................................................................................300Ładowanie podzespołu ...........................................................................................301Przykład działania — program Reflection ..............................................................301Własne atrybuty ......................................................................................................306

Aplikacje .NET Framework SDK .................................................................................311Global Assembly Cache Tool .................................................................................311WinCV ...................................................................................................................313Narzędzie konfiguracji .NET Framework ...............................................................313PEVerify — narzędzie weryfikacji .........................................................................314

.NET a COM .................................................................................................................314PInvoke .........................................................................................................................316

Użycie funkcji Win32 API .....................................................................................316Użycie atrybutu DLLImport ...................................................................................318

Podsumowanie ..............................................................................................................319

Rozdział 12. Pliki i obsługa strumieni ............................................................... 321Czym są strumienie .......................................................................................................321Klasy przestrzeni System.IO .........................................................................................322Operacje na katalogach .................................................................................................322

Tworzenie i usuwanie katalogów ...........................................................................322Kopiowanie i przenoszenie .....................................................................................323Odczytywanie informacji o katalogu ......................................................................325

Obsługa plików .............................................................................................................326Tworzenie i usuwanie plików .................................................................................327Kopiowanie i przenoszenie plików .........................................................................328Odczytywanie informacji o pliku ...........................................................................328

Strumienie .....................................................................................................................330Obsługa plików tekstowych ....................................................................................330Operacje na danych binarnych ................................................................................334

Serializacja ....................................................................................................................335Formaty zapisu danych ...........................................................................................335Przykład serializacji ................................................................................................336

Podsumowanie ..............................................................................................................337

Rozdział 13. Obsługa formatu XML ................................................................... 339Niezależność XML .......................................................................................................340XHTML ........................................................................................................................340Budowa dokumentu ......................................................................................................340

Prolog .....................................................................................................................341Znaczniki ................................................................................................................341Atrybuty .................................................................................................................343Podstawowa terminologia .......................................................................................344Węzeł główny .........................................................................................................345Komentarze ............................................................................................................345Przestrzenie nazw ...................................................................................................345Składnia przestrzeni nazw ......................................................................................346Przestrzenie nazw i atrybuty ...................................................................................346

DTD ..............................................................................................................................347Deklaracja elementu ...............................................................................................347Deklaracja atrybutu ................................................................................................349DTD w osobnym pliku ...........................................................................................350

Encje tekstowe ..............................................................................................................350



XSD ..............................................................................................................................351Nagłówek XSD .......................................................................................................352Elementy XSD ........................................................................................................353Typy danych ...........................................................................................................353Typy proste .............................................................................................................353

XML a bazy danych ......................................................................................................356XSL ...............................................................................................................................357DOM .............................................................................................................................357SAX ..............................................................................................................................358Korzystanie z System.XML ..........................................................................................359

Ładowanie pliku XML ...........................................................................................359Odczyt dowolnego elementu ..................................................................................360Odczyt wartości atrybutów .....................................................................................362Tworzenie pliku XML ............................................................................................364

Dokumentacja XML .....................................................................................................369Podsumowanie ..............................................................................................................371

Skorowidz .................................................................................... 373

S:\ Sylwia\pdf\Wstep do programownia w jezyku C#\07.doc (06-09-01) 171

Rozdział 7.

Tablice i kolekcje

Omówiliśmy już sporą część tego, co oferuje język C#. Powiedzieliśmy sobie o naj-ważniejszym — programowaniu obiektowym, które może przysporzyć najwięcej kło-potów początkującemu programiście. Nie zaprezentowałem do tej pory bardzo ważnegoelementu wielu języków programowania, a mianowicie obsługi tablic.

Jest to bardzo wygodna funkcja języka programowania; przekonasz się o tym podczaspisania przykładowej aplikacji podsumowującej dotychczasową wiedzę o języku C#.Będzie to znana i lubiana gra — kółko i krzyżyk. O tym jednak pod koniec tego roz-działu. Nie przedłużając, spieszę z wyjaśnieniem, czym są tablice…

Czym są tabliceWyobraź sobie, że w swojej aplikacji musisz przechować wiele zmiennych tego samegotypu. Dla przykładu, niech będą to dni tygodnia typu string. Proste? Owszem, wystar-czy zadeklarować siedem zmiennych typu string:

string pon, wt, śr, czw, pt, so, nd;

Teraz do tych zmiennych należy przypisać wartość:pon = "Poniedziałek";wt = "Wtorek";// itd

Teraz wyobraź sobie sytuację, w której musisz zadeklarować 12 zmiennych oznacza-jących nazwy miesięcy. Nieco uciążliwe? Owszem. Do tego celu najlepiej użyć tablic,które służą do grupowania wielu elementów tego samego typu. Osobiście z tablic ko-rzystam bardzo często, jest to znakomity, czytelny sposób na przechowywanie dużejilości danych.

Przejdźmy jednak do rzeczy. W C# istnieje możliwość deklaracji zmiennej, która prze-chowywać będzie wiele danych. Tak w skrócie i uproszczeniu możemy powiedziećo tablicach.


172 (06-09-01) S:\ Sylwia\pdf\Wstep do programownia w jezyku C#\07.doc

Deklarowanie tablicTablice deklaruje się podobnie jak zwykłe zmienne. Jedyną różnicą jest zastosowanienawiasów kwadratowych:

typ[] Nazwa;

W miejsce typ należy podać typ danych elementów tablicowych (np. int, string),a w miejsce nazwa — nazwę zmiennej tablicowej. Przykładowo:

int[] Foo;

W tym miejscu zadeklarowaliśmy tablicę Foo, która może przechowywać elementy typuint. Przed użyciem takiej tablicy należy zadeklarować, z ilu elementów ma się onaskładać. W tym celu korzystamy ze znanego nam operatora new:

Foo = new int[5];

Taka konstrukcja oznacza zadeklarowanie w pamięci komputera miejsca dla pięciuelementów tablicy Foo. Przypisywanie danych do poszczególnych elementów odbywa sięrównież przy pomocy symboli nawiasów kwadratowych:

int[] Foo;Foo = new int[5];

Foo[0] = 100;Foo[1] = 1000;Foo[2] = 10000;Foo[3] = 100000;Foo[4] = 1000000;

Console.WriteLine(Foo[4]);

Możliwy jest również skrótowy zapis deklaracji tablic, podobny do tego znanegoz tworzenia obiektów:

int[] Foo = new int[5];

Indeks

Tablica składa się z elementów. Każdemu z nich przypisany jest tzw. indeks, dziękiktóremu odwołujemy się do konkretnego elementu tablicy. Ów indeks ma postać liczbyi wpisujemy go w nawiasach kwadratowych, tak jak to zaprezentowano w poprzednimprzykładzie. Spójrz na kolejny przykład:

char[] Foo = new char[5];

Foo[0] = 'H';Foo[1] = 'e';Foo[2] = 'l';Foo[3] = 'l';Foo[4] = 'o';

Rozdział 7. ♦ Tablice i kolekcje 173


Indeksy numerowane są od zera do N – 1, gdzie N to ilość elementów tablicy. Aby lepiejto zrozumieć, spójrz na tabelę 7.1.

Tabela 7.1. Prezentacja zależności indeksów elementów

Indeks 0 1 2 3 4

Wartość H e l l o

Należy uważać, aby nie odwołać się do elementu, który nie istnieje! Jeżeli zade-klarowaliśmy tablicę 5-elementową i odwołujemy się do szóstego elementu (poprzezindeks nr 5), kompilator C# nie zareaguje! Błąd zostanie wyświetlony dopiero pouruchomieniu programu.

Inicjalizacja danych

Po utworzeniu tablicy każdemu elementowi przypisywana jest domyślna wartość. Np.w przypadku typu int jest to cyfra 0. Programista po zadeklarowaniu takiej tablicy mamożliwość przypisania wartości dla konkretnego elementu.

Istnieje możliwość przypisania wartości dla konkretnego elementu już przy deklarowa-niu tablicy. Należy wówczas wypisać wartości w klamrach:

char[] Foo = new char[5] {'H', 'e', 'l', 'l', 'o'};

Console.WriteLine(Foo[4]);

Język C# dopuszcza uproszczony zapis takiego kodu — wystarczy pominąć ilośćelementów tablicy:

char[] Foo = {'H', 'e', 'l', 'l', 'o'};

Kompilator oblicza rozmiar takiej tablicy po ilości elementów uporządkowanych po-między klamrami.

Tablice wielowymiaroweC# umożliwia także deklarowanie tzw. tablic wielowymiarowych. Przykładowo, poniż-szy kod tworzy tablicę 7×2 (7 kolumn i 2 wiersze):

string[,] Foo = new string[7, 2];

Zasada deklarowania tablic wielowymiarowych jest prosta. W nawiasie kwadratowymwpisujemy znak przecinka (,), natomiast podczas inicjalizacji musimy podać wymiartablicy (ilość elementów należy również rozdzielić znakiem średnika). Podczas przypi-sywania danych do elementów należy podać dokładny indeks:



Foo[0, 0] = "Pn";Foo[1, 0] = "Wt";Foo[2, 0] = "Śr";Foo[3, 0] = "Czw";Foo[4, 0] = "Pt";Foo[5, 0] = "So";Foo[6, 0] = "Nd";

Foo[0, 1] = "Mon";Foo[1, 1] = "Tue";Foo[2, 1] = "Wed";Foo[3, 1] = "Thu";Foo[4, 1] = "Fri";Foo[5, 1] = "Sat";Foo[6, 1] = "Sun";

Język C# nie ogranicza nas w ilości wymiarów. Możemy więc wprowadzić do naszejtablicy kolejny wymiar. Poniższy fragment prezentuje deklarację tablicy 2×4×2:

string[, ,] Foo = new string[2, 4, 2];

Inicjalizacja danych tablicy wielowymiarowej jest analogiczna do standardowej tablicy:int[,] Foo = new int[3, 3] { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };

Zauważ jednak, że poszczególne elementy zawarte w klamrach są rozdzielone znakiemprzecinka. Oczywiście istnieje możliwość skrótowego zapisu:

int[,] Foo = new int[,] { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };

lub:int[,] Foo = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };

Pętla foreachPodczas omawiania zagadnienia pętli nie wspomniałem o jednej ważnej pętli służącejdo operowania na tablicach. Ponieważ tematyka tablic w rozdziale 3. nie była omawia-nia, pragnę wspomnieć o tej pętli właśnie tutaj.

Pętla ta, znana programistom PHP, Perl czy też Delphi, dla .NET jako parametru wy-maga tablicy. Spójrz na poniższy fragment kodu:

string[] Foo = new string[7];

Foo[0] = "Pn";Foo[1] = "Wt";Foo[2] = "Śr";Foo[3] = "Czw";Foo[4] = "Pt";Foo[5] = "So";Foo[6] = "Nd";



foreach (string Bar in Foo){ Console.WriteLine(Bar);}

Uruchomienie takiej aplikacji spowoduje wyświetlenie, jeden pod drugim, kolejnychelementów tablicy. Po każdej iteracji kolejny element tablicy przypisywany jest dozmiennej Bar. Tutaj ważna uwaga. Zmienna Bar nie może być zadeklarowana lub użytawe wcześniejszych fragmentach kodu. Np. poniższa konstrukcja jest błędna:

string Bar = "Test";foreach (string Bar in Foo){ Console.WriteLine(Bar);}

Przy próbie kompilacji wyświetlony zostanie błąd: A local variable named 'Bar'cannot be declared in this scope because it would give a different meaningto 'Bar', which is already used in a 'parent or current' scope to denote some-thing else.

Identyczny rezultat jak ten pokazany przed chwilą można osiągnąć, stosując pętlę for:for (int i = 0; i < Foo.Length; i++){ Console.WriteLine(Foo[i]);}

Konstrukcja Foo.Length zwraca rozmiar tablicy.

Zasadniczo wygodniejszym i czytelniejszym sposobem jest użycie pętli foreach, któraw końcu została stworzona po to, by operować na tablicach. Jednakże użycie pętli forma jedną przewagę nad foreach — można w niej modyfikować wartości elementów.Spójrz na poniższy przykład:

for (int i = 0; i < Foo.Length; i++){ Foo[i] = "Foo"; Console.WriteLine(Foo[i]);}

Identycznego efektu nie uzyskamy, stosując pętlę foreach:foreach (string Bar in Foo){ Bar = "Foo";}

W tym momencie kompilator zasygnalizuje błąd: Cannot assign to 'Bar' because itis a 'foreach iteration variable'.



Pętla foreach a tablice wielowymiarowe

Pętla foreach z powodzeniem działa na tablicach wielowymiarowych. W takim wy-padku kolejność iteracji jest następująca: najpierw przekazana zostanie wartość elementu[0, 1], następnie [0, 2] itd. Krótki kod prezentujący takie działanie:

string[,] Foo = new string[7, 2];

Foo[0, 0] = "Pn";Foo[1, 0] = "Wt";Foo[2, 0] = "Śr";Foo[3, 0] = "Czw";Foo[4, 0] = "Pt";Foo[5, 0] = "So";Foo[6, 0] = "Nd";

Foo[0, 1] = "Mon";Foo[1, 1] = "Tue";Foo[2, 1] = "Wed";Foo[3, 1] = "Thu";Foo[4, 1] = "Fri";Foo[5, 1] = "Sat";Foo[6, 1] = "Sun";

foreach (string Bar in Foo){ Console.WriteLine(Bar);}

Kolejność wyświetlania danych na konsoli będzie następująca:

PonMonWtTue...

W przypadku tablic wielowymiarowych konstrukcja Tablica.Length zwraca licz-bę wszystkich elementów w tablicy. W prezentowanym przykładzie będzie to 7×2,czyli 14.

Działanie pętli for na tablicach wielowymiarowych jest nieco inne. Przykładowo,poniższa pętla spowoduje wyświetlenie jedynie polskich dni tygodnia:

for (int i = 0; i < Foo.Length / 2; i++){ Console.WriteLine(Foo[i, 0]);}



Tablice tablicMechanizm tablic jest w języku C# bardzo rozbudowany. Umożliwia nawet tworzenietablic, które zawierają kolejne tablice. Poniższy kod prezentuje deklarację takiej tablicy:

int[][] Foo = new int[2][];

Ten zapis oznacza, iż tablica Foo zawierać będzie kolejne dwie tablice o nieokreślonejjeszcze liczbie elementów. Te dwie kolejne tablice również muszą zostać utworzone:

Foo[0] = new int[50];Foo[1] = new int[1000];

Przypisywanie danych do takich tablic wygląda podobnie jak w przypadku tablic wielo-wymiarowych:

// przypisanie wartości do elementu 26. tablicy nr 1Foo[0][25] = 100;// przypisanie wartości do elementu 1000. tablicy drugiejFoo[1][999] = 1;

Sprawa inicjalizacji tablic prezentuje się podobnie, jak to zostało zaprezentowanew trakcie omawiania bardziej podstawowych elementów. Przypisanie wartości doelementów w tablicach tego typu charakteryzuje się dość specyficzną składnią:

int[][] Foo = new int[][]{ new int[] {1, 2}, // zwróć uwagę na brak średnika! new int[] {1, 2, 3}}; // zwróć uwagę na obecność średnika!

Console.WriteLine(Foo[0][1]);

Moim zdaniem przejrzystszy jest skrótowy zapis powyższego kodu, również akcep-towany przez kompilator C#:

int[][] Foo ={ new int[] {1, 2}, new int[] {1, 2, 3}};

Tablice strukturO strukturach i wyliczeniach powiedzieliśmy sobie w rozdziale 5. W niektórych przy-padkach przydatna okazuje się możliwość deklarowania tablic struktur lub typów wy-liczeniowych. Jest to sprawa dość prosta, jeżeli znasz już podstawy użycia tablic,bowiem zamiast typu dotychczas używanego (czyli int, string, char itp.) należyużyć wcześniej zadeklarowanej struktury:



public struct Bar{ public string Name; public byte Age;}

class Program{ static void Main(string[] args) { Bar[] BarArr = new Bar[2];

BarArr[0].Name = "Janusz Kowalski"; BarArr[0].Age = 52;

BarArr[1].Name = "Piotr Nowak"; BarArr[1].Age = 18; }}

Parametr args w metodzie Main()Gdy w rozdziale trzecim omawiałem podstawowe elementy programu C#, wspomnia-łem oczywiście o metodzie Main(), lecz pominąłem znaczenie parametru args. Zro-biłem to celowo, aby nie wprowadzać zamętu, gdyż tematyka tablic czy nawet typówdanych nie była wówczas poruszana. Parametr args typu tablicowego zawiera ewentu-alne parametry przekazane do naszej aplikacji z linii poleceń. Czyli uruchamiającprogram z poziomu linii komend, mogę napisać:

MojaAplikacja.exe Parametr1 Parametr2

Zarówno Parametr1, jak i Parametr2 zostaną przekazane do aplikacji, każdy zostanieprzypisany do odrębnego elementu tablicy. Napiszmy dla treningu prosty program.Jego zadanie będzie banalne: sortowanie argumentów przekazanych do programu.

Właściwie najtrudniejszą rzeczą w programie jest sama konwersja danych z łańcuchastring na wartość całkowitą int. Samo sortowanie tablicy realizuje metoda Sort()klasy Array. Całość programu prezentuje listing 7.1.

Listing 7.1. Pobieranie i sortowanie argumentów programu

using System;

namespace FooConsole{ class Program { static void Main(string[] args) {



if (args.Length == 0) { Console.WriteLine("Brak argumentów programu!"); return; } int[] ArrInt = new int[args.Length]; int count = 0;

foreach (string element in args) { ArrInt[count] = Int32.Parse(element); ++count; }

Array.Sort(ArrInt);

for (int i = 0; i < ArrInt.Length; i++) { Console.WriteLine("{0} ", ArrInt[i]); } } }}

Argumenty przekazane do aplikacji konwertujemy, a następnie zapisujemy w nowoutworzonej tablicy ArrInt. Zwróć uwagę, że do konwersji danych ze string na intużyłem metody Parse() z klasy Int32. To również jest dopuszczalny sposób, równiedobrze mogłem także użyć klasy Convert.

Posortowaną tablicę prezentuję na konsoli, wyświetlając w pętli kolejne jej elementy.

Element {0} wykorzystany w łańcuchu w metodzie WriteLine() zostanie zastąpionywartością zmiennej przekazanej w tej samej metodzie. Jest to czytelny i prostysposób formatowania łańcuchów — np.:

string sName = "Adam";string sLocation = "Wrocławiu";Console.WriteLine("Mam na imię {0} i mieszkam we {1}", sName, sLocation);

Klasa System.ArrayChyba oswoiłeś się już z myślą, że całe środowisko .NET oparte jest na klasach, struk-turach i wyliczeniach? Nie inaczej jest w przypadku tablic. Każda tablica w języku C#dziedziczy po klasie System.Array, która dostarcza podstawowych mechanizmów domanipulacji na elementach tablicy. To dzięki metodom tej klasy możemy pobrać ilośćelementów w tablicy, posortować ją czy przeszukać. Kilka najbliższych stron zostanieprzeznaczonych na opisanie podstawowych elementów tej klasy.



Jeżeli chodzi o właściwości klasy, to najważniejszą jest Length, która zwraca aktualnąliczbę elementów tablicy. Ta sama klasa udostępnia również właściwość LongLength,która zwraca 64-bitową wartość określającą rozmiar wszystkich elementów w przy-padku tablic wielowymiarowych.

Warto również wspomnieć o właściwości Rank, która zwraca liczbę wymiarów danejtablicy:

int[,] Foo = new int[3, 2] { { 1, 2 }, { 1, 2 }, { 1, 2 } };

Console.WriteLine(Foo.Rank); // tablica dwuwymiarowa (wyświetli 2)

Metody klasy

W trakcie omawiania klasy System.Array należy wspomnieć o paru metodach, któremogą Ci się przydać przy okazji operowania na tablicach.

BinarySearch()

Używając algorytmu przeszukiwania binarnego, przeglądam elementy tablicy, aby zna-leźć żądaną wartość. Pierwszym parametrem tej metody musi być nazwa tablicy, naktórej będzie ona operować. Drugim parametrem — szukany element. Oto przykładużycia tej metody:

string[] Foo = new string[] { "Pn", "Wt", "Śr", "Czw", "Pt" };

Console.WriteLine(Array.BinarySearch(Foo, "Śr"));

Metoda zwraca numer indeksu, pod jakim znajduje się szukany element, lub –1, jeżelinic nie zostało znalezione. W zaprezentowanym przykładzie metoda zwróci wartość 2.

Clear()

Metoda umożliwia wyczyszczenie tablicy. W rzeczywistości ustawia każdemu elemen-towi wartość 0 lub null w zależności od jego typu. Metoda przyjmuje trzy parametry.Pierwszym jest nazwa tablicy, drugim — numer indeksu, od którego ma rozpocząćczyszczenie, a trzecim — zasięg tego procesu. Dzięki metodzie Clear() można bowiemwyczyścić określone elementy z tablicy. Poniższy przykład prezentuje czyszczeniecałej zawartości:

Array.Clear(Foo, 0, Foo.Length);

Metoda Clear() nie zmienia rozmiaru czyszczonej tablicy. Jeżeli czyścimy tablicę,która ma — powiedzmy — 5 elementów, to po przeprowadzeniu tej operacji nadalbędzie ich miała tyle samo.

Do elementów wyczyszczonej tablicy ponownie możemy przypisywać jakieś wartości.



Słowo kluczowe null w języku C# oznacza wartość pustą.

Clone()

Metoda Clone() zwraca kopię tablicy, z której została wywołana — np.:

Bar = Foo.Clone();

Od tej pory Bar będzie posiadała takie same elementy co Foo. Ponieważ metoda Clone()zwraca dane w postaci typu object, należy dokonać rzutowania na właściwy typ. Tzn.jeżeli mamy tablicę typu string, należy na niego dokonać odpowiedniego rzutowania,co prezentuje poniższy przykład:

string[] Foo = new string[] { "Pn", "Wt", "Śr", "Czw", "Pt" };// tworzenie kopiistring[] Bar = (string[])Foo.Clone();

foreach (string element in Bar){ Console.WriteLine(element);}

Copy()

Być może lepszym sposobem na utworzenie kopii tablicy będzie zastosowanie metodyCopy(). Umożliwia ona dodatkowo określenie rozmiarów kopiowania, tj. ile elementówzostanie skopiowanych. Oto przykład:

string[] Foo = new string[] { "Pn", "Wt", "Śr", "Czw", "Pt" };string[] Bar = new string[Foo.Length];// tworzenie kopiiArray.Copy(Foo, Bar, Foo.Length);

Pierwszym parametrem tej metody musi być tablica źródłowa (kopiowana), drugim— tablica, do której skopiowane zostaną elementy. Trzeci parametr to oczywiścieilość kopiowanych elementów.

Find()

Metoda umożliwia przeszukanie całej tablicy w celu znalezienia danego elementu. Kwa-lifikacja danego elementu jako znaleziony lub też nie odbywa się przy pomocy zewnętrz-nej metody. Oto przykładowy program:

{ Point[] points = { new Point(10, 20), new Point(100, 200), new Point(400, 500) };



Point first = Array.Find(points, pointFind);

Console.WriteLine("Found: {0}, {1}", first.X, first.Y); Console.Read();}

private static bool pointFind(Point point){ if (point.X % 2 == 0) { return true; } else { return false; }}

Na samym początku zadeklarowałem tablicę struktur Point, które będą przeszukiwa-ne. Program wyszukuje elementów tablicy, w której element X struktury Point jestliczbą parzystą. Po znalezieniu pierwszego metoda pointFind() zwraca true i kończyswe działanie.

Struktura Point zadeklarowana jest w przestrzeni nazw System.Drawing. Nie za-pomnij zadeklarować jej użycia przy pomocy słowa using oraz dołączyć odpowiedniegopodzespołu (System.Drawing.dll).

FindAll()

Jak sama nazwa wskazuje, metoda FindAll() wyszukuje wszystkie elementy, którespełniają dane kryteria poszukiwań. Oto jak powinien wyglądać program z poprzedniegolistingu, jeśli ma wyszukiwać wszystkie elementy:

static void Main(string[] args){ Point[] points = { new Point(10, 20), new Point(100, 200), new Point(400, 500) };

Point[] find = Array.FindAll(points, pointFind);

foreach (Point element in find) { Console.WriteLine("Found: {0}, {1}", element.X, element.Y); } Console.Read();}



private static bool pointFind(Point point){ if (point.X % 2 == 0) { return true; } else { return false; }}

FindLast()

Metoda ta działa podobnie jak Find(). Jedyna różnica jest taka, że FindLast() szukaostatniego wystąpienia danego elementu; nie kończy pracy, gdy znajdzie pierwszyelement pasujący do kryteriów.

GetLength()

Zwraca ilość elementów w tablicy. Umożliwia działanie na tablicach wielowymiarowych.W parametrze tej metody należy podać numer wymiaru, którego ilość elementów mabyć pobrana. Jeżeli mamy do czynienia z tablicą jednowymiarową, w parametrze wypi-sujemy cyfrę 0.

Klasa System.Array udostępnia również metodę GetLongLength(), która działa ana-logicznie do GetLength(), z tą różnicą, iż zwraca dane w postaci liczby typu long.

GetLowerBund(), GetUpperBund()

Metoda GetLowerBund() zwraca numer najmniejszego indeksu w tablicy. W przeważa-jącej części przypadków będzie to po prostu cyfra 0. Metoda GetUpperBund() zwracanatomiast największy indeks danej tablicy. Obie metody mogą działać na tablicachwielowymiarowych; wówczas należy w parametrze podać indeks wymiaru. Przykła-dowe użycie:

int[] Foo = { 1, 2, 3, 4, 5, 6 };

Console.WriteLine("Najmniejszy indeks: {0}, największy: {1}", Foo.GetLowerBound(0), Foo.GetUpperBound(0));

GetValue()

Prawdopodobnie nie będziesz zmuszony do częstego korzystania z tej metody, zwracaona bowiem wartość danego elementu tablicy. W parametrze tej metody musisz podaćindeks elementu, tak więc jej działanie jest równoznaczne z konstrukcją:

Tablica[1]; // zwraca element znajdujący się pod indeksem 1



Chcąc wykorzystać tę metodę, kod możemy zapisać następująco:

int[] Foo = { 1, 2, 3, 4, 5, 6 };

Console.WriteLine(Foo.GetValue(1));

Initialize()

We wcześniejszych fragmentach tego rozdziału pisałem o inicjalizacji tablicy. MetodaInitialize() może to ułatwić. Jej użycie powoduje przypisanie każdemu elementowipustej wartości (czyli może to być cyfra 0 lub np. wartość null). Jej użycie jest bardzoproste, nie wymaga podawania żadnych argumentów:

Foo.Initialize();

IndexOf()

Przydatna metoda. Zwraca numer indeksu na podstawie podanej wartości elementu.Przykład użycia:

string[] Foo = { "Pn", "Wt", "Śr", "Czw", "Pt", "So", "Nd" };

Console.WriteLine(Array.IndexOf(Foo, "Pt"));

W powyższym przykładzie na konsoli zostanie wyświetlona cyfra 4, gdyż pod tym nu-merem kryje się element Pt.

Resize()

Metoda Resize() przydaje się wówczas, gdy musimy zmienić rozmiar danej tablicy.W pierwszym jej parametrze musimy podać nazwę tablicy poprzedzoną słowem kluczo-wym ref oznaczającym referencję. Drugim parametrem musi być nowy rozmiar tablicy:

string[] Foo = { "Pn", "Wt", "Śr", "Czw", "Pt", "So", "Nd" };Array.Resize(ref Foo, Foo.Length + 5);

SetValue()

Metoda SetValue() umożliwia nadanie wartości dla danego elementu tablicy. Prawdo-podobnie nie będziesz korzystał z niej zbyt często, gdyż to samo działanie można zre-alizować przy pomocy operatora przypisania. Gdybyś jednak miał wątpliwości, co dojej użycia, poniżej prezentuję przykład:

Foo.SetValue("Weekend", 9);

Taki zapis oznacza przypisanie wartości Weekend pod indeks nr 9.



Słowo kluczowe params

Mechanizm tablic języka C# nie umożliwia tworzenia tablic dynamicznych, tj. o zmien-nym rozmiarze. Zmiana rozmiaru tablic (ilości elementów) jest nieco problematyczna,podobnie jak usuwanie elementów. Warto jednak wspomnieć o słowie kluczowym pa-rams, używanym w połączeniu z tablicami. Konkretnie z tablicowymi parametrami metod:

static void Foo(params string[] args){}

Słowo params, które poprzedza właściwą deklarację parametru, mówi o tym, iż liczbaelementów przekazywanych do metody będzie zmienna. Oto przykład takiego programu:

using System;

namespace FooApp{ class Program { static void Foo(params string[] args) { for (int i = 0; i < args.Length; i++) { Console.Write(args[i] + " "); } Console.WriteLine(); } static void Main(string[] args) { Foo("Adam", "Paulina");

Foo("Adam", "Paulina", "Marta");

Console.Read(); } }}

Jak widzisz, możliwe jest przekazanie dowolnej liczby parametrów do metody Foo().Każdy parametr będzie kolejnym elementem tablicy i jest to przydatna cecha języka C#.

Możliwe jest przekazywanie parametrów różnego typu. Nagłówek metody musi wy-glądać wówczas tak:

static void Foo(params object[] args)

Taką metodę można wywołać np. tak:

Foo("Adam", 10, 12.2);

Wstęp do programowania w języku C#

Documents

Transcript of Wstęp do programowania w języku C#