Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00133 008076 20982604 na godz. na dobę w sumie
wyszukaj dokładnie | pobierz wtyczkę
Wstęp do programowania w języku C# - książka
Wstęp do programowania w języku C# - książka
Autor: Liczba stron: 392
Wydawca: Helion Język publikacji: polski
ISBN: 83-246-0523-1 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c# - programowanie
Porównaj ceny (książka, ebook, audiobook).
Czytaj online.
Komentuj

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 dla tych, 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.

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREœCI SPIS TREœCI KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOœCIACH O NOWOœCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE Wydawnictwo Helion ul. Koœciuszki 1c 44-100 Gliwice tel. 032 230 98 63 e-mail: helion@helion.pl Wstêp do programowania w jêzyku C# Autor: Adam Boduch ISBN: 83-246-0523-1 Format: B5, stron: 392 Przyk³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 dla tych, 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. (cid:129) Konstrukcja platformy .NET (cid:129) Sk³adnia C# (cid:129) Elementy jêzyka (cid:129) Programowanie obiektowe (cid:129) Obs³uga zdarzeñ (cid:129) Korzystanie z tablic i kolekcji (cid:129) Obs³uga wyj¹tków (cid:129) Biblioteka Windows Forms (cid:129) Stosowanie komponentów .NET (cid:129) Operacje na plikach i strumieniach (cid:129) Obs³uga formatu XML Spis treści Przedmowa ..................................................................................... 11 Rozdział 1. Wprowadzenie ................................................................................ 13 Czym jest programowanie ..............................................................................................13 Mnogość języków programowania ...........................................................................14 Edytory kodu ............................................................................................................15 Kompilatory ..............................................................................................................15 Mity związane z programowaniem ...........................................................................16 Języki programowania ....................................................................................................17 Asembler ..................................................................................................................18 Fortran ......................................................................................................................19 C ...............................................................................................................................19 C++ ...........................................................................................................................19 Perl ...........................................................................................................................20 PHP ...........................................................................................................................20 Turbo Pascal .............................................................................................................20 Java ...........................................................................................................................21 Język maszynowy ...........................................................................................................21 Działanie kompilatorów ..................................................................................................22 Tworzenie kodu źródłowego ....................................................................................22 Prekompilacja ...........................................................................................................23 Kompilacja do kodu Asemblera ...............................................................................23 Optymalizacja kodu ..................................................................................................23 Asemblacja ...............................................................................................................23 Konsolidacja .............................................................................................................24 Języki interpretowane .....................................................................................................24 Język C# .........................................................................................................................24 Instalacja środowiska ......................................................................................................24 Jak się uczyć ...................................................................................................................25 Nie ucz się na pamięć! ..............................................................................................25 Początkowe trudności ...............................................................................................25 Pomoc systemowa ....................................................................................................25 Praktyka ....................................................................................................................26 Pierwsza aplikacja ..........................................................................................................26 Kompilacja i uruchamianie .......................................................................................26 Komponenty .............................................................................................................28 Piszemy kod .............................................................................................................29 Zapisywanie projektu ...............................................................................................29 Podsumowanie ................................................................................................................30 S:\ Sylwia\pdf\Wstep do programownia w jezyku C#\_spis treści.doc 3 4 Wstęp do programowania w języku C# Rozdział 2. Podstawy platformy .NET ................................................................ 31 Interfejs programistyczny ...............................................................................................32 API systemu Windows .............................................................................................32 Wizja .NET .....................................................................................................................33 Składniki platformy .NET ........................................................................................34 Konkluzja .................................................................................................................37 C# a .NET .......................................................................................................................37 Rodzaje aplikacji ............................................................................................................38 Aplikacje konsolowe ................................................................................................38 Windows Forms ........................................................................................................38 Formularze Web Forms ............................................................................................38 Składniki .NET Framework ............................................................................................39 Usługi sieciowe ...............................................................................................................39 Niezależność .............................................................................................................40 Uniwersalność ..........................................................................................................40 Podsumowanie ................................................................................................................41 Rozdział 3. Podstawy języka C# ....................................................................... 43 Podstawowa składnia ......................................................................................................43 Najprostszy program .................................................................................................45 Jak kompilatory czytają kod .....................................................................................45 Wielkość znaków ......................................................................................................45 Program musi posiadać metodę Main .......................................................................46 Średnik kończy instrukcję .........................................................................................46 Program musi posiadać klasę ....................................................................................47 Wcięcia, odstępy ......................................................................................................47 Słowa kluczowe ........................................................................................................47 Symbole ....................................................................................................................47 Komentarze .....................................................................................................................48 Podzespoły, metody, klasy ..............................................................................................49 Funkcje .....................................................................................................................49 Metody .....................................................................................................................50 Klasy .........................................................................................................................50 Przestrzenie nazw .....................................................................................................51 Operator kropki ........................................................................................................51 Słowo kluczowe using ..............................................................................................52 Zmienne ..........................................................................................................................53 Deklarowanie zmiennych .........................................................................................53 Przydział danych ......................................................................................................54 Typy danych .............................................................................................................55 Restrykcje w nazewnictwie ......................................................................................55 Stałe ................................................................................................................................56 Operacje na konsoli ........................................................................................................57 Metody klasy Console ..............................................................................................58 Właściwości klasy Console ......................................................................................58 Operatory ........................................................................................................................59 Operatory porównania ..............................................................................................60 Operatory arytmetyczne ...........................................................................................60 Operator inkrementacji oraz dekrementacji ..............................................................61 Operatory logiczne ...................................................................................................62 Operatory bitowe ......................................................................................................62 Operatory przypisania ...............................................................................................63 Inne operatory ...........................................................................................................63 4 S:\ Sylwia\pdf\Wstep do programownia w jezyku C#\_spis treści.doc Spis treści 5 Instrukcje warunkowe .....................................................................................................63 Instrukcja if ...............................................................................................................64 Słowo kluczowe else ................................................................................................68 Instrukcja else if .......................................................................................................69 Instrukcja switch .......................................................................................................70 Pętle ................................................................................................................................73 Pętla while ................................................................................................................73 Pętla do-while ...........................................................................................................75 Pętla for ....................................................................................................................76 Instrukcja break ........................................................................................................77 Instrukcja continue ...................................................................................................78 Operator warunkowy ................................................................................................79 Konwersja danych ..........................................................................................................80 Rzutowanie .....................................................................................................................81 Przykładowa aplikacja ....................................................................................................81 Dyrektywy preprocesora .................................................................................................83 Deklarowanie symboli ..............................................................................................84 Instrukcje warunkowe ...............................................................................................84 Błędy i ostrzeżenia ...................................................................................................85 Podsumowanie ................................................................................................................86 Rozdział 4. Przegląd .NET Framework ............................................................... 87 Środowisko CLR ............................................................................................................87 Kod pośredni IL ........................................................................................................88 Kod zarządzany i niezarządzany ...............................................................................89 Moduł zarządzany ....................................................................................................89 Podzespoły ................................................................................................................90 Działanie CLR ..........................................................................................................90 System CTS ....................................................................................................................91 Specyfikacja CLS ...........................................................................................................92 Biblioteka klas ................................................................................................................93 Moduły, przestrzenie nazw .............................................................................................93 Wieloznaczność ........................................................................................................95 Główne przestrzenie nazw ........................................................................................96 Podsumowanie ................................................................................................................97 Rozdział 5. Programowanie obiektowe .............................................................. 99 Na czym polega programowanie obiektowe ...................................................................99 Podstawowy kod formularza WinForms .......................................................................101 Moduł Form1.Designer.cs ......................................................................................103 Generowanie kodu ..................................................................................................104 Ukrywanie kodu .....................................................................................................105 Programowanie zdarzeniowe ........................................................................................106 Generowanie zdarzeń .............................................................................................106 Obsługa zdarzeń .....................................................................................................110 Klasy .............................................................................................................................110 Składnia klasy .........................................................................................................110 Do czego służą klasy ..............................................................................................111 Instancja klasy ........................................................................................................112 Klasy zagnieżdżone ................................................................................................114 Pola ...............................................................................................................................114 S:\ Sylwia\pdf\Wstep do programownia w jezyku C#\_spis treści.doc 5 6 Wstęp do programowania w języku C# Metody ..........................................................................................................................115 Zwracana wartość ...................................................................................................116 Parametry metod .....................................................................................................116 Przeciążanie metod .................................................................................................118 Przekazywanie parametrów ....................................................................................119 Dziedziczenie ................................................................................................................122 Klasa domyślna ......................................................................................................123 Hermetyzacja ................................................................................................................123 Modyfikatory dostępu ...................................................................................................123 Sekcja private .........................................................................................................124 Sekcja public ..........................................................................................................125 Sekcja protected ......................................................................................................126 Sekcja internal ........................................................................................................127 Konstruktor ...................................................................................................................127 Pola tylko do odczytu .............................................................................................128 Destruktor .....................................................................................................................129 Właściwości ..................................................................................................................129 Modyfikatory dostępu .............................................................................................132 Elementy statyczne .......................................................................................................132 Metody statyczne ....................................................................................................133 Klasy statyczne .......................................................................................................134 Polimorfizm ..................................................................................................................135 Ukrywanie elementów klas .....................................................................................135 Słowo kluczowe base ..............................................................................................137 Metody wirtualne ....................................................................................................139 Przedefiniowanie metod .........................................................................................140 Elementy abstrakcyjne ............................................................................................141 Elementy zaplombowane ........................................................................................142 .NET Framework Class Library ....................................................................................142 Przestrzenie nazw ...................................................................................................143 Klasa System.Object ...............................................................................................143 Opakowywanie typów ..................................................................................................145 Interfejsy .......................................................................................................................146 Implementacja wielu interfejsów ............................................................................147 Typy wyliczeniowe .......................................................................................................148 Wartości elementów ...............................................................................................149 Struktury .......................................................................................................................150 Konstruktory struktur .............................................................................................152 Operatory is i as ............................................................................................................154 Przeładowanie operatorów ............................................................................................155 Słowo kluczowe operator .......................................................................................156 Dzielenie klas ................................................................................................................158 Podsumowanie ..............................................................................................................158 Rozdział 6. Delegaty i zdarzenia ...................................................................... 159 Delegaty ........................................................................................................................159 Tworzenie delegatów ..............................................................................................160 Użycie delegatów ...................................................................................................161 Funkcje zwrotne .....................................................................................................163 Delegaty złożone ....................................................................................................165 Metody anonimowe ................................................................................................165 Zdarzenia ......................................................................................................................166 Podsumowanie ..............................................................................................................169 6 S:\ Sylwia\pdf\Wstep do programownia w jezyku C#\_spis treści.doc Spis treści 7 Rozdział 7. Tablice i kolekcje ......................................................................... 171 Czym są tablice .............................................................................................................171 Deklarowanie tablic ......................................................................................................172 Indeks .....................................................................................................................172 Inicjalizacja danych ................................................................................................173 Tablice wielowymiarowe ..............................................................................................173 Pętla foreach .................................................................................................................174 Pętla foreach a tablice wielowymiarowe ................................................................176 Tablice tablic ................................................................................................................177 Tablice struktur .............................................................................................................177 Parametr args w metodzie Main() .................................................................................178 Klasa System.Array ......................................................................................................179 Metody klasy ..........................................................................................................180 Słowo kluczowe params .........................................................................................185 Przykład — gra kółko i krzyżyk ...................................................................................186 Zasady gry ..............................................................................................................186 Specyfikacja klasy ..................................................................................................186 Ustawienie symbolu na planszy ..............................................................................190 Sprawdzenie wygranej ............................................................................................191 Interfejs aplikacji ....................................................................................................196 Mechanizm indeksowania .............................................................................................201 Indeksy łańcuchowe ...............................................................................................203 Kolekcje ........................................................................................................................204 Interfejsy System.Collections .................................................................................204 Stosy .......................................................................................................................206 Kolejki ....................................................................................................................208 Klasa ArrayList ......................................................................................................209 Listy ..............................................................................................................................209 Typy generyczne ....................................................................................................210 Korzystanie z list ....................................................................................................212 Słowniki ........................................................................................................................214 Przykładowy program .............................................................................................215 Podsumowanie ..............................................................................................................217 Rozdział 8. Obsługa wyjątków ........................................................................ 219 Czym są wyjątki ...........................................................................................................220 Obsługa wyjątków ........................................................................................................220 Blok finally .............................................................................................................221 Zagnieżdżanie wyjątków ........................................................................................222 Klasa System.Exception ...............................................................................................223 Selektywna obsługa wyjątków ...............................................................................223 Wywoływanie wyjątków ........................................................................................224 Własne klasy wyjątków ................................................................................................224 Deklarowanie własnej klasy ...................................................................................225 Przykładowa aplikacja ............................................................................................226 Przepełnienia zmiennych ..............................................................................................229 Podsumowanie ..............................................................................................................230 Rozdział 9. Łańcuchy w C# ............................................................................. 231 Typ System.String ........................................................................................................231 Unicode w łańcuchach ............................................................................................232 Niezmienność łańcuchów .......................................................................................232 Konstruktory klasy .................................................................................................233 Operacje na łańcuchach ..........................................................................................234 S:\ Sylwia\pdf\Wstep do programownia w jezyku C#\_spis treści.doc 7 8 Wstęp do programowania w języku C# Łańcuchy w WinForms .................................................................................................239 Klasa StringBuilder ......................................................................................................241 Metody klasy StringBuilder ....................................................................................242 Zastosowanie klasy StringBuilder ..........................................................................242 Formatowanie łańcuchów .............................................................................................244 Specyfikatory formatów ...............................................................................................246 Własne specyfikatory formatowania .......................................................................248 Specyfikatory typów wyliczeniowych ....................................................................249 Typ System.Char ..........................................................................................................250 Podsumowanie ..............................................................................................................251 Rozdział 10. Biblioteka Windows Forms ............................................................ 253 Podzespół System.Windows.Forms ..............................................................................253 Okno Object Browser .............................................................................................254 Przestrzeń System.Windows.Forms ........................................................................254 Podstawowe klasy .........................................................................................................255 System.ComponentModel.Component ...................................................................256 System.Windows.Forms.Control ............................................................................256 System.Windows.Forms.Application .....................................................................256 Przykład działania .........................................................................................................261 Przygotowanie klasy ...............................................................................................261 Projektowanie interfejsu .........................................................................................261 Rozwiązania programistyczne ................................................................................262 Technika „przeciągnij i upuść” .....................................................................................266 Tworzenie menu ...........................................................................................................270 Właściwości menu ..................................................................................................271 Ikony dla menu .......................................................................................................271 Skróty klawiaturowe ...............................................................................................274 Menu podręczne .....................................................................................................274 Paski narzędziowe ........................................................................................................275 Pasek statusu .................................................................................................................276 Zakładki ........................................................................................................................276 Kontrolki tekstowe ........................................................................................................277 Komponent RichTextBox .......................................................................................280 Okna dialogowe ............................................................................................................281 Właściwości okien dialogowych ............................................................................282 Aplikacja — edytor tekstów ...................................................................................283 Tworzenie nowego formularza .....................................................................................284 Podsumowanie ..............................................................................................................285 Rozdział 11. Podzespoły .NET ........................................................................... 287 Czym jest COM ............................................................................................................287 Kontrolka w rozumieniu COM ...............................................................................288 Odrobinę historii .....................................................................................................288 ActiveX ..................................................................................................................288 DCOM ....................................................................................................................289 Podstawowy podzespół .................................................................................................289 Deasembler .NET ...................................................................................................289 Komponenty .NET ........................................................................................................291 Przygotowanie komponentu w Delphi ....................................................................291 Przygotowanie komponentu C# ..............................................................................293 Zalety stosowania podzespołów .............................................................................295 Budowa podzespołu ......................................................................................................296 Atrybuty podzespołu .....................................................................................................297 8 S:\ Sylwia\pdf\Wstep do programownia w jezyku C#\_spis treści.doc Spis treści 9 Mechanizm refleksji .....................................................................................................298 Funkcja GetType ....................................................................................................299 Klasa System.Type .................................................................................................300 Ładowanie podzespołu ...........................................................................................301 Przykład działania — program Reflection ..............................................................301 Własne atrybuty ......................................................................................................306 Aplikacje .NET Framework SDK .................................................................................311 Global Assembly Cache Tool .................................................................................311 WinCV ...................................................................................................................313 Narzędzie konfiguracji .NET Framework ...............................................................313 PEVerify — narzędzie weryfikacji .........................................................................314 .NET a COM .................................................................................................................314 PInvoke .........................................................................................................................316 Użycie funkcji Win32 API .....................................................................................316 Użycie atrybutu DLLImport ...................................................................................318 Podsumowanie ..............................................................................................................319 Rozdział 12. Pliki i obsługa strumieni ............................................................... 321 Czym są strumienie .......................................................................................................321 Klasy przestrzeni System.IO .........................................................................................322 Operacje na katalogach .................................................................................................322 Tworzenie i usuwanie katalogów ...........................................................................322 Kopiowanie i przenoszenie .....................................................................................323 Odczytywanie informacji o katalogu ......................................................................325 Obsługa plików .............................................................................................................326 Tworzenie i usuwanie plików .................................................................................327 Kopiowanie i przenoszenie plików .........................................................................328 Odczytywanie informacji o pliku ...........................................................................328 Strumienie .....................................................................................................................330 Obsługa plików tekstowych ....................................................................................330 Operacje na danych binarnych ................................................................................334 Serializacja ....................................................................................................................335 Formaty zapisu danych ...........................................................................................335 Przykład serializacji ................................................................................................336 Podsumowanie ..............................................................................................................337 Rozdział 13. Obsługa formatu XML ................................................................... 339 Niezależność XML .......................................................................................................340 XHTML ........................................................................................................................340 Budowa dokumentu ......................................................................................................340 Prolog .....................................................................................................................341 Znaczniki ................................................................................................................341 Atrybuty .................................................................................................................343 Podstawowa terminologia .......................................................................................344 Węzeł główny .........................................................................................................345 Komentarze ............................................................................................................345 Przestrzenie nazw ...................................................................................................345 Składnia przestrzeni nazw ......................................................................................346 Przestrzenie nazw i atrybuty ...................................................................................346 DTD ..............................................................................................................................347 Deklaracja elementu ...............................................................................................347 Deklaracja atrybutu ................................................................................................349 DTD w osobnym pliku ...........................................................................................350 Encje tekstowe ..............................................................................................................350 S:\ Sylwia\pdf\Wstep do programownia w jezyku C#\_spis treści.doc 9 10 Wstęp do programowania w języku C# XSD ..............................................................................................................................351 Nagłówek XSD .......................................................................................................352 Elementy XSD ........................................................................................................353 Typy danych ...........................................................................................................353 Typy proste .............................................................................................................353 XML a bazy danych ......................................................................................................356 XSL ...............................................................................................................................357 DOM .............................................................................................................................357 SAX ..............................................................................................................................358 Korzystanie z System.XML ..........................................................................................359 Ładowanie pliku XML ...........................................................................................359 Odczyt dowolnego elementu ..................................................................................360 Odczyt wartości atrybutów .....................................................................................362 Tworzenie pliku XML ............................................................................................364 Dokumentacja XML .....................................................................................................369 Podsumowanie ..............................................................................................................371 Skorowidz .................................................................................... 373 10 S:\ Sylwia\pdf\Wstep do programownia w jezyku C#\_spis treści.doc 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żnego elementu wielu języków programowania, a mianowicie obsługi tablic. Jest to bardzo wygodna funkcja języka programowania; przekonasz się o tym podczas pisania 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ą tablice Wyobraź sobie, że w swojej aplikacji musisz przechować wiele zmiennych tego samego typu. 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żej iloś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. S:\ Sylwia\pdf\Wstep do programownia w jezyku C#\07.doc (06-09-01) 171 172 Wstęp do programowania w języku C# Deklarowanie tablic Tablice deklaruje się podobnie jak zwykłe zmienne. Jedyną różnicą jest zastosowanie nawiasó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 typu int. Przed użyciem takiej tablicy należy zadeklarować, z ilu elementów ma się ona skł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ęciu elementó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 znanego z 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ęki któremu odwołujemy się do konkretnego elementu tablicy. Ów indeks ma postać liczby i wpisujemy go w nawiasach kwadratowych, tak jak to zaprezentowano w poprzednim przykł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 ; 172 (06-09-01) S:\ Sylwia\pdf\Wstep do programownia w jezyku C#\07.doc Rozdział 7. ♦ Tablice i kolekcje 173 Indeksy numerowane są od zera do N – 1, gdzie N to ilość elementów tablicy. Aby lepiej to zrozumieć, spójrz na tabelę 7.1. Tabela 7.1. Prezentacja zależności indeksów elementów Indeks Wartość 0 H 1 e 2 l 3 l 4 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 (poprzez indeks nr 5), kompilator C# nie zareaguje! Błąd zostanie wyświetlony dopiero po uruchomieniu 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 ma moż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 wielowymiarowe C# 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 kwadratowym wpisujemy znak przecinka (,), natomiast podczas inicjalizacji musimy podać wymiar tablicy (ilość elementów należy również rozdzielić znakiem średnika). Podczas przypi- sywania danych do elementów należy podać dokładny indeks: S:\ Sylwia\pdf\Wstep do programownia w jezyku C#\07.doc (06-09-01) 173 174 Wstęp do programowania w języku C# 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 naszej tablicy 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 znakiem przecinka. 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 foreach Podczas omawiania zagadnienia pętli nie wspomniałem o jednej ważnej pętli służącej do 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 ; 174 (06-09-01) S:\ Sylwia\pdf\Wstep do programownia w jezyku C#\07.doc Rozdział 7. ♦ Tablice i kolekcje 175 foreach (string Bar in Foo) { Console.WriteLine(Bar); } Uruchomienie takiej aplikacji spowoduje wyświetlenie, jeden pod drugim, kolejnych elementów tablicy. Po każdej iteracji kolejny element tablicy przypisywany jest do zmiennej Bar. Tutaj ważna uwaga. Zmienna Bar nie może być zadeklarowana lub użyta we 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 meaning to 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óra w końcu została stworzona po to, by operować na tablicach. Jednakże użycie pętli for ma 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 it is a foreach iteration variable . S:\ Sylwia\pdf\Wstep do programownia w jezyku C#\07.doc (06-09-01) 175 176 Wstęp do programowania w języku C# 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: Pon Mon Wt Tue ... 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]); } 176 (06-09-01) S:\ Sylwia\pdf\Wstep do programownia w jezyku C#\07.doc Rozdział 7. ♦ Tablice i kolekcje Tablice tablic 177 Mechanizm tablic jest w języku C# bardzo rozbudowany. Umożliwia nawet tworzenie tablic, 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ślonej jeszcze 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 1 Foo[0][25] = 100; // przypisanie wartości do elementu 1000. tablicy drugiej Foo[1][999] = 1; Sprawa inicjalizacji tablic prezentuje się podobnie, jak to zostało zaprezentowane w trakcie omawiania bardziej podstawowych elementów. Przypisanie wartości do elementó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 struktur O 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ży użyć wcześniej zadeklarowanej struktury: S:\ Sylwia\pdf\Wstep do programownia w jezyku C#\07.doc (06-09-01) 177 178 Wstęp do programowania w języku C# 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ów danych nie była wówczas poruszana. Parametr args typu tablicowego zawiera ewentu- alne parametry przekazane do naszej aplikacji z linii poleceń. Czyli uruchamiając program z poziomu linii komend, mogę napisać: MojaAplikacja.exe Parametr1 Parametr2 Zarówno Parametr1, jak i Parametr2 zostaną przekazane do aplikacji, każdy zostanie przypisany 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ńcucha string 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) { 178 (06-09-01) S:\ Sylwia\pdf\Wstep do programownia w jezyku C#\07.doc Rozdział 7. ♦ Tablice i kolekcje 179 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 nowo utworzonej tablicy ArrInt. Zwróć uwagę, że do konwersji danych ze string na int użyłem metody Parse() z klasy Int32. To również jest dopuszczalny sposób, równie dobrze 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ąpiony wartością zmiennej przekazanej w tej samej metodzie. Jest to czytelny i prosty sposó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.Array Chyba 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 do manipulacji 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 zostanie przeznaczonych na opisanie podstawowych elementów tej klasy. S:\ Sylwia\pdf\Wstep do programownia w jezyku C#\07.doc (06-09-01) 179 180 Wstęp do programowania w języku C# 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 danej tablicy: 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óre mogą 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, na której będzie ona operować. Drugim parametrem — szukany element. Oto przykład uż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żeli nic 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 bowiem wyczyścić określone elementy z tablicy. Poniższy przykład prezentuje czyszczenie cał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 nadal będzie ich miała tyle samo. Do elementów wyczyszczonej tablicy ponownie możemy przypisywać jakieś wartości. 180 (06-09-01) S:\ Sylwia\pdf\Wstep do programownia w jezyku C#\07.doc Rozdział 7. ♦ Tablice i kolekcje 181 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
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Wstęp do programowania w języku C#
Autor:
Sklep
Format
Cena
Helion.pl Helion.pl
książka
49,00 zł
Idź do sklepu »

Opinie na temat publikacji:

Inne popularne pozycje z tej kategorii:

Czytaj również:

Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: