Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00423 006040 14695088 na godz. na dobę w sumie
C# od podszewki. Wydanie II - książka
C# od podszewki. Wydanie II - książka
Autor: Liczba stron: 632
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-3921-2 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c# - programowanie
Porównaj ceny (książka, ebook, audiobook).

Poznaj najskrytsze zakamarki C#!

Obecnie szczególnie cenione są te języki programowania, które pozwalają na błyskawiczne osiągnięcie oczekiwanych efektów. Dodatkowo absolutnie niezbędne jest zachowanie możliwości uruchamiania raz napisanej aplikacji na różnych platformach bez konieczności jej przepisywania. Nikt nie ma na to czasu! C# to nowoczesny język, który zdobył uznanie programistów na całym świecie, ponieważ spełnia nawet najbardziej wyśrubowane wymagania!

Ten bezcenny podręcznik zaprowadzi Cię w najskrytsze zakątki języka C#. Autorzy założyli, że znasz jego podstawy - to pozwoliło im skupić uwagę na niuansach, ciekawostkach oraz subtelnych szczegółach. W trakcie lektury zrozumiesz, co się dzieje w czeluściach C#, a dzięki temu unikniesz ukrytych pułapek. Książka ta jest obowiązkową pozycją każdego programisty C#. Bez niej najciekawsze funkcje C# wciąż będą Ci obce!

Dowiedz się:

Fascynująca podróż w głąb C#!

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

Darmowy fragment publikacji:

Tytuł oryginału: C# in Depth, Second Edition Tłumaczenie: Janusz Grabis Projekt okładki: Studio Gravite / Olsztyn Obarek, Pokoński, Pazdrijowski, Zaprucki ISBN: 978-83-246-3921-2 Original edition copyright © 2011 by Manning Publications Co. All rights reserved. Polish edition copyright © 2012 by HELION SA. All rights reserved. All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording or by any information storage retrieval system, without permission from the Publisher. Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie praw autorskich niniejszej publikacji. Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli. Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Wydawnictwo HELION nie ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Wydawnictwo HELION ul. Kościuszki 1c, 44-100 GLIWICE tel. 32 231 22 19, 32 230 98 63 e-mail: helion@helion.pl WWW: http://helion.pl (księgarnia internetowa, katalog książek) Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/cshop2 Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis treĂci 7 Spis treĂci 17 19 21 23 Przedmowa WstÚp PodziÚkowania O ksiÈĝce CzÚĂÊ I 1. NieustajÈca metamorfoza C# Przygotowanie do wyprawy 31 33 1.1. Na poczÈtek prosty typ danych ................................................................................................... 34 1.1.1. Typ Product w C# 1 ....................................................................................................... 35 1.1.2. Kolekcje o mocnym typie w C# 2 ................................................................................. 36 1.1.3. WïaĂciwoĂci implementowane automatycznie w C# 3 ................................................ 37 1.1.4. Argumenty nazwane w C# 4 ......................................................................................... 38 1.2. Sortowanie i filtrowanie .............................................................................................................. 39 1.2.1. Sortowanie produktów po nazwie .................................................................................. 40 1.2.2. Wyszukiwanie elementów w kolekcjach ....................................................................... 43 1.3. Obsïuga braku danych ................................................................................................................. 44 1.3.1. Reprezentacja nieznanej ceny ........................................................................................ 45 1.3.2. Parametry opcjonalne i wartoĂci domyĂlne ................................................................... 46 1.4. Wprowadzenie do LINQ ............................................................................................................. 46 1.4.1. Wyraĝenia kwerendowe i zapytania wewnÈtrzprocesowe ........................................... 47 1.4.2. Wykonywanie zapytañ na XML-u ................................................................................. 48 1.4.3. LINQ dla SQL-a ............................................................................................................. 49 8 SPIS TREĝCI 2. Rdzeñ systemu — C# 1 1.7. 1.5. COM i typy dynamiczne .............................................................................................................. 50 1.5.1. Uproszczenie wspóïpracy z COM ................................................................................. 50 1.5.2. Wspóïpraca z jÚzykiem dynamicznym ........................................................................... 51 1.6. Analiza zawartoĂci Ărodowiska .NET ......................................................................................... 52 1.6.1. JÚzyk C# ......................................................................................................................... 53 1.6.2. ¥rodowisko wykonania ................................................................................................... 53 1.6.3. Biblioteki Ărodowiska ...................................................................................................... 54 Jak zmieniÊ Twój kod w kod doskonaïy? ................................................................................... 54 1.7.1. Prezentacja peïnych programów w formie fragmentów kodu ...................................... 55 1.7.2. Kod dydaktyczny nie jest kodem produkcyjnym .......................................................... 56 1.7.3. Twój nowy najlepszy przyjaciel — specyfikacja jÚzyka ................................................ 56 1.8. Podsumowanie .............................................................................................................................. 57 59 2.1. Delegaty ........................................................................................................................................ 60 2.1.1. Przepis na prosty delegat ................................................................................................ 61 2.1.2. ’Èczenie i usuwanie delegatów ..................................................................................... 66 2.1.3. Dygresja na temat zdarzeñ ............................................................................................. 67 2.1.4. Podsumowanie delegatów .............................................................................................. 68 2.2. Charakterystyka systemu typów ................................................................................................. 69 2.2.1. Miejsce C# w Ăwiecie systemów typów ........................................................................ 69 2.2.2. Kiedy system typów C# 1 jest niedostatecznie bogaty? .............................................. 73 2.2.3. Podsumowanie charakterystyki systemu typów ............................................................ 75 2.3. Typy wartoĂciowe i referencyjne ............................................................................................... 76 2.3.1. WartoĂci i referencje w rzeczywistym Ăwiecie .............................................................. 76 2.3.2. Podstawy typów referencyjnych i wartoĂciowych ........................................................ 77 2.3.3. Obalanie mitów ............................................................................................................... 79 2.3.4. Opakowywanie i odpakowywanie .................................................................................. 81 2.3.5. Podsumowanie typów wartoĂciowych i referencyjnych ............................................... 82 2.4. WiÚcej niĝ C# 1 — nowe cechy na solidnym fundamencie .................................................... 83 2.4.1. Cechy zwiÈzane z delegatami ........................................................................................ 83 2.4.2. Cechy zwiÈzane z systemem typów ............................................................................... 85 2.4.3. Cechy zwiÈzane z typami wartoĂciowymi ..................................................................... 87 2.5. Podsumowanie .............................................................................................................................. 88 CzÚĂÊ II C# 2 — rozwiÈzanie problemów C# 1 3. 89 Parametryzowanie typów i metod 91 3.1. Czemu potrzebne sÈ typy generyczne? ...................................................................................... 92 3.2. Proste typy generyczne do codziennego uĝycia ........................................................................ 94 3.2.1. Nauka przez przykïad — sïownik typu generycznego ................................................. 94 3.2.2. Typy generyczne i parametry typów ............................................................................. 96 3.2.3. Metody generyczne i czytanie deklaracji generycznych ............................................ 100 3.3. Wkraczamy gïÚbiej .................................................................................................................... 103 3.3.1. Ograniczenia typów ...................................................................................................... 104 3.3.2. Interfejs argumentów typu dla metod generycznych ................................................. 109 Implementowanie typów generycznych ...................................................................... 110 3.3.3. 3.4. Zaawansowane elementy typów generycznych ....................................................................... 116 3.4.1. Pola i konstruktory statyczne ....................................................................................... 117 3.4.2. Jak kompilator JIT traktuje typy generyczne .............................................................. 119 Spis treĂci 9 4. Wyraĝanie „niczego” przy uĝyciu typów nullowalnych 3.4.3. Iteracja przy uĝyciu typów generycznych ................................................................... 121 3.4.4. Refleksja i typy generyczne .......................................................................................... 123 3.5. Ograniczenia typów generycznych C# i innych jÚzyków ...................................................... 128 3.5.1. Brak wariancji typów generycznych ............................................................................ 128 3.5.2. Brak ograniczeñ operatorów lub ograniczeñ „numerycznych” .................................. 133 3.5.3. Brak generycznych wïaĂciwoĂci, indekserów i innych elementów typu ................... 135 3.5.4. Porównanie z C++ ...................................................................................................... 136 3.5.5. Porównanie z typami generycznymi Javy .................................................................... 137 3.6. Podsumowanie ............................................................................................................................ 139 141 4.1. Co robisz, kiedy zwyczajnie nie masz wartoĂci? ..................................................................... 142 4.1.1. Czemu zmienne typu wartoĂciowego nie mogÈ zawieraÊ null? ................................. 142 4.1.2. Metody reprezentacji wartoĂci null w C# 1 ............................................................... 143 4.2. System.Nullable T i System.Nullable ................................................................................. 145 4.2.1. Wprowadzenie Nullable T ..................................................................................... 146 4.2.2. Opakowywanie i odpakowywanie Nullable T ....................................................... 149 4.2.3. RównoĂÊ instancji Nullable T ................................................................................. 150 4.2.4. Wsparcie ze strony niegenerycznej klasy Nullable .................................................... 151 4.3. Skïadnia C# 2 dla typów nullowalnych ................................................................................... 152 4.3.1. Modyfikator ? ................................................................................................................ 152 4.3.2. Przypisania i porównania z null ................................................................................... 154 4.3.3. Konwersje i operatory nullowalne ............................................................................... 156 4.3.4. Logika typów nullowalnych ......................................................................................... 159 4.3.5. Stosowanie operatora as z typami nullowalnymi ........................................................ 161 4.3.6. Nullowy operator koalescencyjny ................................................................................ 161 4.4. Nowatorskie zastosowania typów nullowalnych ..................................................................... 164 4.4.1. Testowanie operacji bez parametrów zwrotnych ........................................................ 165 4.4.2. Bezbolesne porównania przy uĝyciu nullowalnego operatora koalescencyjnego ..... 167 4.5. Podsumowanie ............................................................................................................................ 169 Przyspieszone delegaty 171 5.1. Poĝegnanie z dziwacznÈ skïadniÈ delegatów .......................................................................... 173 5.2. Konwersja grupy metod ............................................................................................................ 174 5.3. Kowariancja i kontrawariancja ................................................................................................ 176 5.3.1. Kontrawariancja parametrów delegatów ..................................................................... 176 5.3.2. Kowariancja typu zwracanego delegata ....................................................................... 178 5.3.3. Maïe ryzyko niekompatybilnoĂci ................................................................................. 179 5.4. Akcje delegatów tworzone w miejscu przy uĝyciu metod anonimowych ............................. 180 5.4.1. Rozpoczynamy prosto — operujÈc na parametrach ................................................... 181 5.4.2. Zwracanie wartoĂci z metod anonimowych ................................................................. 183 Ignorowanie parametrów typu ..................................................................................... 185 5.4.3. 5.5. Przechwytywanie zmiennych w metodach anonimowych ..................................................... 186 5.5.1. Definicja domkniÚcia i róĝnych typów zmiennych ..................................................... 187 5.5.2. Analiza zachowania zmiennych przechwyconych ....................................................... 188 5.5.3. Jaki cel majÈ zmienne przechwycone? ........................................................................ 189 5.5.4. Przedïuĝone ĝycie zmiennych przechwyconych ......................................................... 190 5.5.5. Instancje zmiennej lokalnej .......................................................................................... 192 5.5.6. Mieszanka zmiennych wspóïdzielonych i odrÚbnych ................................................. 194 5.5.7. Wskazówki odnoĂnie do zmiennych przechwyconych i podsumowanie ................... 196 5.6. Podsumowanie ............................................................................................................................ 197 5. 10 6. 7. SPIS TREĝCI Implementowanie iteratorów w prosty sposób 199 6.1. C# 1 — udrÚka rÚcznego pisania iteratorów ......................................................................... 201 6.2. C# 2 — proste iteratory z wyraĝeniami yield ........................................................................ 204 6.2.1. Wprowadzenie do uproszczeñ iteratorów i wyraĝenia yield return .......................... 204 6.2.2. Wizualizacja toku wykonania iteratora ........................................................................ 206 6.2.3. Zaawansowany tok wykonania iteratora ...................................................................... 208 6.2.4. Dziwactwa w implementacji ........................................................................................ 211 6.3. Przykïady z ĝycia ........................................................................................................................ 213 Iterowanie po datach w harmonogramie ..................................................................... 213 6.3.1. 6.3.2. Iterowanie po wierszach pliku ..................................................................................... 214 6.3.3. Leniwe filtrowanie elementów z uĝyciem uproszczenia iteratora i predykatu ......... 217 6.4. Pseudosynchroniczny kod z uĝyciem biblioteki CCR ............................................................ 219 6.5. Podsumowanie ............................................................................................................................ 222 Pozostaïe cechy C# 2 225 7.1. Typy czÚĂciowe ........................................................................................................................... 227 7.1.1. Tworzenie typu skïadajÈcego siÚ z kilku plików ......................................................... 227 7.1.2. Uĝycie typów czÚĂciowych ........................................................................................... 229 7.1.3. Metody czÚĂciowe — tylko w C# 3 ............................................................................. 231 7.2. Klasy statyczne ........................................................................................................................... 233 7.3. Niezaleĝny poziom dostÚpu do getterów i setterów wïaĂciwoĂci .......................................... 235 7.4. Aliasy przestrzeni nazw ............................................................................................................. 237 7.4.1. Kwalifikowanie aliasów przestrzeni nazw ................................................................... 238 7.4.2. Aliasy globalnej przestrzeni nazw ................................................................................ 239 7.4.3. Aliasy zewnÚtrzne ......................................................................................................... 240 7.5. Dyrektywy pragma ..................................................................................................................... 241 7.5.1. Pragmy ostrzeĝeñ .......................................................................................................... 242 7.5.2. Pragmy sum kontrolnych .............................................................................................. 243 7.6. Bufory o staïym rozmiarze w kodzie niezarzÈdzanym ........................................................... 243 7.7. UdostÚpnianie wybranych elementów innym moduïom ........................................................ 245 7.7.1. Zaprzyjaěnione moduïy w prostym przypadku ........................................................... 246 7.7.2. Do czego warto uĝywaÊ InternalsVisibleTo? .............................................................. 247 InternalsVisibleTo i moduïy podpisane ....................................................................... 247 7.7.3. 7.8. Podsumowanie ............................................................................................................................ 248 CzÚĂÊ III C# 3 — rewolucja w metodzie programowania 8. Redukcja nadmiarowoĂci przez zmyĂlny kompilator 251 253 8.1. WïaĂciwoĂci implementowane automatycznie ........................................................................ 255 8.2. Zmienne lokalne o typie niejawnym ........................................................................................ 257 8.2.1. Zastosowanie var do deklarowania zmiennych lokalnych .......................................... 257 8.2.2. Ograniczenia w typach niejawnych ............................................................................. 259 8.2.3. Zalety i wady typów niejawnych .................................................................................. 260 8.2.4. Zalecenia ....................................................................................................................... 261 8.3. Uproszczona inicjalizacja .......................................................................................................... 262 8.3.1. Definicja prostych typów ............................................................................................. 262 8.3.2. Ustawianie prostych wïaĂciwoĂci ................................................................................. 263 8.3.3. Ustawianie wïaĂciwoĂci obiektów zagnieĝdĝonych .................................................... 265 8.3.4. Inicjalizatory kolekcji .................................................................................................... 266 8.3.5. Zastosowanie inicjalizatorów ........................................................................................ 269 Spis treĂci 11 9. Wyraĝenia lambda i drzewa wyraĝeñ 8.4. Tablice o typie niejawnym ........................................................................................................ 270 8.5. Typy anonimowe ........................................................................................................................ 272 8.5.1. Pierwsze spotkania z gatunkiem anonimowym ........................................................... 272 8.5.2. CzÚĂci skïadowe typów anonimowych ......................................................................... 274 8.5.3. Inicjalizatory odwzorowujÈce ...................................................................................... 275 Jaki to ma sens? ............................................................................................................. 276 8.5.4. 8.6. Podsumowanie ............................................................................................................................ 277 279 9.1. Wyraĝenia lambda i delegaty ................................................................................................... 281 9.1.1. Przygotowanie — wprowadzenie delegatów typu Func ... .................................. 281 9.1.2. Pierwsze przeksztaïcenie na wyraĝenie lambda ......................................................... 282 9.1.3. Uĝywanie pojedynczego wyraĝenia jako ciaïa ............................................................. 283 9.1.4. Lista parametrów o typie niejawnym .......................................................................... 284 9.1.5. Skrót dla pojedynczego parametru .............................................................................. 284 9.2. Proste przykïady uĝycia List T i zdarzeñ ........................................................................... 286 9.2.1. Filtrowanie, sortowanie i operacje na listach .............................................................. 286 9.2.2. Logowanie w metodach obsïugi zdarzeñ ..................................................................... 288 9.3. Drzewa wyraĝeñ ......................................................................................................................... 289 9.3.1. Budowanie drzew wyraĝeñ w sposób programistyczny ............................................. 289 9.3.2. Kompilowanie drzew wyraĝeñ do postaci delegatów ................................................. 291 9.3.3. Konwersja wyraĝeñ lambda C# na drzewa wyraĝeñ .................................................. 292 9.3.4. Drzewa wyraĝeñ w sercu LINQ .................................................................................. 296 9.3.5. Drzewa wyraĝeñ poza LINQ ....................................................................................... 297 9.4. Zmiany we wnioskowaniu typów i rozwiÈzywaniu przeciÈĝeñ ............................................. 299 9.4.1. Powód do zmiany — usprawnienie wywoïañ metod generycznych .......................... 300 9.4.2. Wnioskowanie typu zwracanego funkcji anonimowych ............................................. 301 9.4.3. Dwufazowe wnioskowanie typu ................................................................................... 302 9.4.4. Wybieranie odpowiedniego przeciÈĝenia metody ...................................................... 306 9.4.5. Podsumowanie wnioskowania typów i rozwiÈzywania przeciÈĝeñ ............................ 308 9.5. Podsumowanie ............................................................................................................................ 308 311 10.1. ¿ycie przed metodami rozszerzajÈcymi .................................................................................. 312 10.2. Skïadnia metod rozszerzajÈcych .............................................................................................. 315 10.2.1. Deklarowanie metod rozszerzajÈcych ......................................................................... 315 10.2.2. Wywoïywanie metod rozszerzajÈcych ......................................................................... 316 10.2.3. Wykrywanie metod rozszerzajÈcych ............................................................................ 318 10.2.4. Wywoïanie metody na pustej referencji ...................................................................... 319 10.3. Metody rozszerzajÈce w .NET 3.5 ............................................................................................ 321 10.3.1. Pierwsze kroki z Enumerable ...................................................................................... 321 10.3.2. Filtrowanie z uĝyciem Where i spinania wywoïañ metod ......................................... 323 10.3.3. Antrakt: czy metody Where nie widzieliĂmy juĝ wczeĂniej? ..................................... 325 10.3.4. Projekcja przy uĝyciu metody Select i typów anonimowych ..................................... 326 10.3.5. Sortowanie przy uĝyciu OrderBy ................................................................................. 327 10.3.6. Przykïady logiki biznesowej z uĝyciem ïañcuchowania ............................................. 328 10.4. Wskazówki i uwagi odnoĂnie do uĝycia ................................................................................... 330 10.4.1. „Rozszerzanie Ăwiata” i wzbogacanie interfejsów ....................................................... 330 10.4.2. Pïynne interfejsy ........................................................................................................... 331 10.4.3. Rozwaĝne uĝycie metod rozszerzajÈcych .................................................................... 332 10.5. Podsumowanie ............................................................................................................................ 334 10. Metody rozszerzajÈce 12 SPIS TREĝCI 11. Wyraĝenia kwerendowe i LINQ dla Obiektów 335 11.1. Wprowadzenie do LINQ ........................................................................................................... 336 11.1.1. Podstawowe koncepcje w LINQ ................................................................................. 336 11.1.2. Definiowanie przykïadowego modelu danych ............................................................ 341 11.2. Prosty poczÈtek — wybieranie elementów .............................................................................. 343 11.2.1. Rozpoczynanie od ěródïa i koñczenie na selekcji ....................................................... 343 11.2.2. Translacja kompilatora jako podstawa wyraĝeñ kwerendowych ................................ 344 11.2.3. Zmienne zakresu i projekcje nietrywialne .................................................................. 347 11.2.4. Cast, OfType i zmienne zakresu o typie jawnym ........................................................ 349 11.3. Filtrowanie i porzÈdkowanie sekwencji .................................................................................. 351 11.3.1. Filtrowanie przy uĝyciu klauzuli where ...................................................................... 351 11.3.2. Zdegenerowane wyraĝenia kwerendowe .................................................................... 352 11.3.3. PorzÈdkowanie przy uĝyciu klauzuli orderby ............................................................. 353 11.4. Klauzule let i identyfikatory przezroczyste ............................................................................. 356 11.4.1. Wprowadzenie do wykonania poĂredniego z uĝyciem let .......................................... 356 11.4.2. Identyfikatory przezroczyste ........................................................................................ 357 11.5. ZïÈczenia ..................................................................................................................................... 359 11.5.1. ZïÈczenia wewnÚtrzne korzystajÈce z klauzul join ...................................................... 359 11.5.2. ZïÈczenia grupowe z uĝyciem klauzul join … into ..................................................... 363 11.5.3. ZïÈczenia krzyĝowe i spïaszczanie sekwencji 12. LINQ — nie tylko kolekcje przy uĝyciu wielokrotnych klauzul from ..................................................................... 366 11.6. Grupowania i kontynuacje ........................................................................................................ 369 11.6.1. Grupowanie przy uĝyciu klauzuli group ... by ............................................................ 369 11.6.2. Kontynuacje zapytañ .................................................................................................... 373 11.7. Wybór pomiÚdzy wyraĝeniami kwerendowymi a notacjÈ kropkowÈ ................................... 375 11.7.1. Operacje wymagajÈce notacji kropkowej .................................................................... 376 11.7.2. Wyraĝenia kwerendowe, dla których prostszym rozwiÈzaniem moĝe siÚ okazaÊ notacja kropkowa ............................................................................... 377 11.7.3. Gdzie wyraĝenia kwerendowe lĂniÈ? ........................................................................... 377 11.8. Podsumowanie ............................................................................................................................ 379 381 12.1. Odpytywanie bazy danych przez LINQ dla SQL-a ................................................................ 382 12.1.1. Zaczynamy od bazy danych i modelu .......................................................................... 383 12.1.2. Zapytania wstÚpne ........................................................................................................ 385 12.1.3. Zapytania wymagajÈce zïÈczeñ .................................................................................... 388 12.2. Translacje przy uĝyciu IQueryable i IQueryProvider ........................................................... 390 12.2.1. Wprowadzenie do IQueryable T i zwiÈzanych z nim interfejsów ....................... 391 12.2.2. Prototyp — implementacja interfejsów wykonujÈca wpisy w dzienniku .................. 393 12.2.3. Spajanie wszystkiego razem — metody rozszerzajÈce typu Queryable .................... 395 12.2.4. Udawany dostawca w dziaïaniu ................................................................................... 397 12.2.5. Podsumowanie IQueryable .......................................................................................... 398 12.3. Interfejsy zaprzyjaěnione z LINQ i LINQ dla XML-a .......................................................... 399 12.3.1. Rdzenne typy LINQ dla XML-a .................................................................................. 399 12.3.2. Konstrukcja deklaratywna ............................................................................................ 401 12.3.3. Zapytania na pojedynczych wÚzïach ............................................................................ 404 12.3.4. Operatory zapytañ spïaszczonych ................................................................................ 406 12.3.5. Praca w harmonii z LINQ ............................................................................................ 407 Spis treĂci 13 12.4. ZastÈpienie LINQ dla Obiektów Równolegïym LINQ .......................................................... 408 12.4.1. KreĂlenie zbioru Mandelbrota przez pojedynczy wÈtek ............................................ 409 12.4.2. Wprowadzenie ParallelEnumerable, ParallelQuery i AsParallel ............................... 410 12.4.3. PodkrÚcanie zapytañ równolegïych ............................................................................. 411 12.5. Odwrócenie modelu zapytania przy uĝyciu LINQ dla Rx ..................................................... 413 12.5.1. IObservable T i IObserver T ............................................................................ 414 12.5.2. Zaczynamy (ponownie) ïagodnie .................................................................................. 416 12.5.3. Odpytywanie obiektów obserwowalnych .................................................................... 417 12.5.4. Jaki to wszystko ma sens? ............................................................................................. 419 12.6. Rozszerzanie LINQ dla Obiektów ........................................................................................... 420 12.6.1. Wytyczne odnoĂnie do projektu i implementacji ....................................................... 421 12.6.2. Proste rozszerzenie — wybieranie losowego elementu ............................................. 422 12.7. Podsumowanie ............................................................................................................................ 424 CzÚĂÊ IV C# 4 — dobra wspóïpraca z innymi interfejsami 13. Maïe zmiany dla uproszczenia kodu 427 429 13.1. Parametry opcjonalne i argumenty nazwane .......................................................................... 430 13.1.1. Parametry opcjonalne ................................................................................................... 430 13.1.2. Argumenty nazwane ..................................................................................................... 437 13.1.3. Zïoĝenie dwóch cech w caïoĂÊ ..................................................................................... 441 13.2. Usprawnienia we wspóïpracy z COM ...................................................................................... 446 13.2.1. Horror automatyzacji Worda przed C# 4 ................................................................... 446 13.2.2. Zemsta parametrów opcjonalnych i argumentów nazwanych .................................... 447 13.2.3. Kiedy parametr ref nie jest parametrem ref? .............................................................. 448 13.2.4. Wywoïywanie indekserów nazwanych ........................................................................ 449 13.2.5. ’Èczenie gïównych bibliotek COM-owych ................................................................. 451 13.3. Wariancja typów generycznych dla interfejsów i delegatów ................................................ 453 13.3.1. Typy wariancji: kowariancja i kontrawariancja ........................................................... 454 13.3.2. Uĝycie wariancji w interfejsach ................................................................................... 455 13.3.3. Zastosowanie wariancji w delegatach .......................................................................... 458 13.3.4. Zïoĝone sytuacje ............................................................................................................ 459 13.3.5. Restrykcje i uwagi ......................................................................................................... 461 13.4. Mikroskopijne zmiany w blokadach i zdarzeniach w formie pól .......................................... 465 13.4.1. Solidne blokowanie ....................................................................................................... 465 13.4.2. Zmiany w zdarzeniach w formie pól ............................................................................ 467 13.5. Podsumowanie ............................................................................................................................ 467 469 14.1. Co? Kiedy? Dlaczego? Jak? ....................................................................................................... 471 14.1.1. Czym sÈ typy dynamiczne? .......................................................................................... 471 14.1.2. Kiedy typy dynamiczne sÈ uĝyteczne i dlaczego? ....................................................... 472 14.1.3. W jaki sposób C# zapewnia typy dynamiczne? ......................................................... 474 14.2. PiÚciominutowy przewodnik po typie dynamic ...................................................................... 474 14.3. Przykïady uĝycia typów dynamicznych ................................................................................... 477 14.3.1. COM w ogólnoĂci i Microsoft Office w szczególnoĂci ............................................... 477 14.3.2. JÚzyki dynamiczne, takie jak IronPython .................................................................... 479 14.3.3. Typy dynamiczne w kodzie caïkowicie zarzÈdzanym ................................................. 484 14.4. ZaglÈdamy pod maskÚ ............................................................................................................... 490 14.4.1. Wprowadzenie do DLR ............................................................................................... 491 14.4.2. Fundamentalne koncepcje DLR .................................................................................. 493 14. Dynamiczne wiÈzanie w jÚzyku statycznym 14 SPIS TREĝCI 15. JaĂniejsze wyraĝanie kodu przy uĝyciu kontraktów kodu 14.4.3. Jak kompilator C# obsïuguje sïowo dynamic? ........................................................... 496 14.4.4. Kompilator C# staje siÚ jeszcze sprytniejszy ............................................................. 500 14.4.5. Ograniczenia kodu dynamicznego ............................................................................... 503 14.5. Implementacja zachowania dynamicznego ............................................................................. 506 14.5.1. Uĝycie klasy ExpandoObject ....................................................................................... 506 14.5.2. Uĝycie klasy DynamicObject ....................................................................................... 511 14.5.3. Implementacja IDynamicMetaObjectProvider .......................................................... 518 14.6. Podsumowanie ............................................................................................................................ 522 523 15.1. ¿ycie przed kontraktami kodu .................................................................................................. 525 15.2. Wprowadzenie do kontraktów kodu ........................................................................................ 527 15.2.1. Warunki wstÚpne .......................................................................................................... 529 15.2.2. Warunki koñcowe ......................................................................................................... 530 15.2.3. Inwarianty ..................................................................................................................... 531 15.2.4. Asercje i zaïoĝenia ........................................................................................................ 533 15.2.5. Kontrakty legacyjne ...................................................................................................... 534 15.3. Przepisywanie kodu binarnego przez ccrewrite i ccrefgen ................................................... 536 15.3.1. Proste przepisywanie .................................................................................................... 536 15.3.2. Dziedziczenie kontraktów ............................................................................................ 538 15.3.3. Referencyjne moduïy kontraktów ................................................................................ 541 15.3.4. Zachowanie w przypadku poraĝki ................................................................................ 543 15.4. Sprawdzanie statyczne .............................................................................................................. 545 15.4.1. Wprowadzenie do analizy statycznej ........................................................................... 545 15.4.2. ZobowiÈzania niejawne ................................................................................................ 548 15.4.3. Selektywne wïÈczanie opcji .......................................................................................... 551 15.5. Dokumentowanie kodu przy uĝyciu ccdocgen ........................................................................ 554 15.6. Kontrakty w praktyce ................................................................................................................ 556 15.6.1. Filozofia — czym jest kontrakt? ................................................................................... 557 15.6.2. Jak mam zaczÈÊ? ........................................................................................................... 558 15.6.3. Opcje, wszÚdzie opcje .................................................................................................. 559 15.7. Podsumowanie ............................................................................................................................ 562 565 16.1. C# — poïÈczenie tradycji z nowoczesnoĂciÈ .......................................................................... 566 16.2. Spotkanie .NET z informatykÈ ................................................................................................. 567 16.3. ¥wiat informatyki ....................................................................................................................... 568 16.4. Poĝegnanie .................................................................................................................................. 569 571 573 A.1. Agregacja .................................................................................................................................... 574 A.2. Konkatenacja .............................................................................................................................. 575 A.3. Konwersja ................................................................................................................................... 575 A.4. Operatory jednoelementowe .................................................................................................... 577 A.5. RównoĂÊ ...................................................................................................................................... 578 A.6. Generacja .................................................................................................................................... 579 A.7. Grupowanie ................................................................................................................................ 580 A.8. ZïÈczenia ..................................................................................................................................... 580 A.9. Partycjonowanie ......................................................................................................................... 582 Dodatki A Standardowe operatory kwerendowe LINQ 16. DokÈd teraz? Spis treĂci 15 B Kolekcje generyczne w .NET A.10. Projekcja ..................................................................................................................................... 582 A.11. Kwantyfikatory ........................................................................................................................... 583 A.12. Filtrowanie .................................................................................................................................. 584 A.13. Operatory bazujÈce na zbiorach .............................................................................................. 584 A.14. Sortowanie .................................................................................................................................. 585 587 B.1. Interfejsy ..................................................................................................................................... 588 B.2. Listy ............................................................................................................................................. 590 B.2.1. List T ........................................................................................................................ 590 B.2.2. Tablice ........................................................................................................................... 591 B.2.3. LinkedList T ............................................................................................................ 592 B.2.4. Collection T , BindingList T , ObservableCollection T C Podsumowanie wersji Ărodowisk .NET i KeyedCollection TKey, TItem ............................................................................. 593 B.2.5. ReadOnlyCollection T i ReadOnlyObservableCollection T ........................... 594 B.3. Sïowniki ....................................................................................................................................... 594 B.3.1. Dictionary TKey, TValue ........................................................................................ 594 B.3.2. SortedList TKey, TValue i SortedDictionary TKey, TValue .......................... 595 B.4. Zbiory .......................................................................................................................................... 596 B.4.1. HashSet T ................................................................................................................ 597 B.4.2. SortedSet T (.NET 4) .............................................................................................. 597 B.5. Queue T i Stack T ........................................................................................................... 598 B.5.1. Queue T ................................................................................................................... 598 B.5.2. Stack T ..................................................................................................................... 598 B.6. Kolekcje konkurencyjne (.NET 4) ............................................................................................ 598 B.6.1. IProducerConsumerCollection T i BlockingCollection T .............................. 599 B.6.2. ConcurrentBag T , ConcurrentQueue T , ConcurrentStack T ................... 600 B.6.3. ConcurrentDictionary TKey, TValue .................................................................... 600 B.7. Podsumowanie ............................................................................................................................ 600 603 C.1. Gïówne wersje dystrybucyjne Ărodowiska typu desktop ....................................................... 604 C.2. Cechy jÚzyka C# ........................................................................................................................ 605 C.2.1. C# 2.0 ............................................................................................................................ 605 C.2.2. C# 3 ............................................................................................................................... 605 C.2.3. C# 4.0 ............................................................................................................................ 606 C.3. Biblioteki Ărodowiska ................................................................................................................. 606 .NET 2.0 ........................................................................................................................ 606 .NET 3.0 ........................................................................................................................ 606 .NET 3.5 ........................................................................................................................ 607 .NET 4 ........................................................................................................................... 607 C.4. Cechy Ărodowiska uruchomieniowego (CLR) ......................................................................... 608 C.4.1. CLR 2.0 ......................................................................................................................... 608 C.4.2. CLR 4.0 ......................................................................................................................... 609 C.5. Inne rodzaje Ărodowiska uruchomieniowego .......................................................................... 609 C.5.1. Compact Framework .................................................................................................... 609 C.5.2. Silverlight ...................................................................................................................... 610 C.5.3. Micro Framework ......................................................................................................... 611 C.6. Podsumowanie ............................................................................................................................ 611 613 C.3.1. C.3.2. C.3.3. C.3.4. Skorowidz 16 SPIS TREĝCI Parametryzowanie typów i metod Ten rozdziaá omawia: i typy i metody generyczne, i interfejs typów dla metod generycznych, i ograniczenia typów, i refleksjĊ i typy generyczne, i zachowanie Ğrodowiska CLR, i ograniczenia typów generycznych, i porównanie z innymi jĊzykami. 92 ROZDZIAà 3 Parametryzowanie typów i metod Oto prawdziwa historia1: pewnego dnia ja i moja ĝona robiliĂmy cotygodniowe zakupy. Tuĝ przed naszym wyjazdem usïyszaïem pytanie, czy mam listÚ. Potwierdziïem, ĝe mam listÚ, i pojechaliĂmy. Dopiero kiedy byliĂmy juĝ w sklepie, na jaw wyszïa nasza pomyïka. Moja ĝona pytaïa o listÚ zakupów, podczas gdy ja wziÈïem ze sobÈ listÚ zmyĂlnych cech C# 2. Sprzedawca byï trochÚ zdziwiony, kiedy zapytaliĂmy go, czy nie ma przypad- kiem do sprzedania trochÚ metod anonimowych. GdybyĂmy tylko mogli wyraziÊ siÚ trochÚ jaĂniej! Gdyby tylko moja ĝona mogïa w jakiĂ sposób przekazaÊ mi, ĝe chce, abym wziÈï ze sobÈ listÚ rzeczy, które chcemy kupiÊ! GdybyĂmy tylko mieli typy generyczne... Dla wiÚkszoĂci programistów typy generyczne stanowiÈ najwaĝniejszÈ nowÈ cechÚ C# 2. PoprawiajÈ wydajnoĂÊ, sprawiajÈ, ĝe kod jest bardziej ekspresyjny, oraz prze- noszÈ sporÈ dawkÚ zabezpieczeñ z czasu wykonania do czasu kompilacji. W najwiÚk- szym skrócie typy generyczne pozwalajÈ na parametryzowanie typów i metod. Tak jak zwyczajne wywoïania metod posiadajÈ parametry wyraĝajÈce wartoĂci przekazywane do Ărodka, tak typy generyczne posiadajÈ parametry okreĂlajÈce, jakich typów uĝyÊ do ich konstrukcji. Brzmi to trochÚ mgliĂcie — jeĂli do tej pory nie miaïeĂ do czynienia z typami generycznymi, byÊ moĝe bÚdziesz siÚ musiaï dïuĝej zatrzymaÊ przy tym tema- cie. MogÚ siÚ jednak zaïoĝyÊ, ĝe kiedy zrozumiesz podstawowÈ ideÚ, pokochasz typy generyczne. W tym rozdziale zajmiemy siÚ uĝyciem typów i metod generycznych oferowanych przez Ărodowisko lub biblioteki innych dostawców, a takĝe omówimy, jak napisaÊ wïasne. Po drodze dowiemy siÚ, jak typy generyczne wspóïdziaïajÈ z wywoïaniami refleksyjnymi interfejsu programistycznego, oraz poznamy kilka detali odnoĂnie do sposobu obsïugi typów generycznych przez Ărodowisko wykonawcze. Na koniec rozdziaïu wspomnÚ o kilku najczÚĂciej spotykanych ograniczeniach typów generycznych z moĝliwymi obejĂciami oraz porównam typy generyczne C# z podobnymi mechanizmami w innych jÚzykach programowania. Na poczÈtku musimy jednak zrozumieÊ problemy, jakie staïy siÚ podstawÈ do opra- cowania typów generycznych. 3.1. Czemu potrzebne są typy generyczne? Jeĝeli posiadasz w swoich zasobach kod napisany przy uĝyciu C# 1, przyjrzyj mu siÚ i policz rzutowania — szczególnie w kodzie, który intensywnie korzysta z kolekcji. Nie zapominaj, ĝe pod niemal kaĝdÈ pÚtlÈ foreach kryje siÚ niejawne rzutowanie. Kiedy uĝywasz typów zaprojektowanych do pracy z wieloma róĝnymi typami danych, nieunik- nionÈ konsekwencjÈ jest duĝa liczba rzutowañ — cichego sposobu informowania kom- pilatora, aby siÚ nie przejmowaï, zaïoĝyï, ĝe wszystko jest w najlepszym porzÈdku, i potraktowaï napotkane wyraĝenie tak, jakby miaïo ten szczególny typ danych. Wyko- rzystanie dowolnego interfejsu programistycznego, który uĝywa typu object do przeka- zywania parametrów wejĂciowych lub zwracania wyniku, prÚdzej czy póěniej bÚdzie 1 PrawdÚ mówiÈc, jest to „historia na potrzeby wprowadzenia do rozdziaïu” — niekoniecznie caïkowicie prawdziwa. 3.1. Czemu potrzebne sÈ typy generyczne? 93 wymagaÊ rzutowania. Pewnym uïatwieniem jest wprowadzenie hierarchii klas bazujÈcej na typie object. Podstawowy problem pozostanie ten sam — typ object jest zupeïnie prosty, a wiÚc ĝeby móc wykonaÊ jakÈkolwiek uĝytecznÈ pracÚ, trzeba w pierwszej kolejnoĂci dokonaÊ jego rzutowania. Czy rzutowanie nie jest „be”? Nie, nie naleĝy rozumieÊ, ĝe nigdy nie powinno siÚ tego robiÊ (rzutowanie przydaje siÚ do pracy ze strukturami mutowalnymi i publicz- nymi polami klas), ale trzeba je traktowaÊ jako zïo konieczne. Rzutowanie wskazuje, ĝe jesteĂ zmuszony do przekazania kompilatorowi dodatkowej wiedzy i wskazania, aby ten zaufaï Ci w czasie kompilacji i przeniósï sprawdzenie poprawnoĂci zaïoĝeñ do czasu wykonania. JeĂli musisz daÊ do zrozumienia, ĝe masz wiÚcej wiedzy niĝ kompilator i dlatego chcesz dokonaÊ rzutowania, takiej samej wiedzy bÚdzie potrzebowaÊ osoba czytajÈca Twój kod. Moĝesz pozostawiÊ komentarz w miejscu rzutowania, ale nie bÚdzie to szcze- gólnie uĝyteczne. Znacznie lepszym miejscem na takÈ informacjÚ jest deklaracja metody lub zmiennej. Jest to szczególnie waĝne, jeĂli dostarczasz typ lub metodÚ, z której inni uĝytkownicy bÚdÈ korzystaÊ bez dostÚpu do Twojego kodu. Typy generyczne umoĝli- wiajÈ dostawcom bibliotek zablokowanie wywoïañ z wnÚtrza bibliotek z uĝyciem nie- prawidïowych parametrów. W C# 1 musieliĂmy polegaÊ na rÚcznie napisanej doku- mentacji, która (jak kaĝda zduplikowana informacja) szybko staje siÚ niekompletna i nieaktualna. Kiedy moĝemy takÈ informacjÚ zawrzeÊ bezpoĂrednio w kodzie jako czÚĂÊ deklaracji metody lub typu, praca wszystkich stron staje siÚ bardziej produk- tywna. Kompilator moĝe dokonaÊ wiÚcej sprawdzeñ, Ărodowisko IDE moĝe zaoferowaÊ dodatkowe informacje poprzez mechanizm IntelliSense (na przykïad podczas prze- glÈdania elementów listy ïañcuchów moĝe pokazaÊ pola i metody typu string), uĝyt- kownicy metod bÚdÈ pewniejsi co do poprawnoĂci swojego kodu pod wzglÚdem prze- kazanych argumentów i zwróconych wartoĂci, a czytelnicy Twojego kodu bÚdÈ mogli lepiej zrozumieÊ, co miaïeĂ na myĂli, kiedy pisaïeĂ dany fragment. CZY TYPY GENERYCZNE ZREDUKUJk LICZB} TWOICH B’}DÓW? Wszystkie opisy typów generycznych, jakie czytaïem (wïÈczajÈc w to moje wïasne), podkreĂlajÈ znaczenie przeniesienia sprawdzenia poprawnoĂci typów z czasu wykonania na czas kompilacji. PowierzÚ Ci maïy sekret: nie przypominam sobie, abym kiedykolwiek musiaï poprawiaÊ bïÈd w wypuszczonym kodzie spowodowany brakiem sprawdzenia typu. Inaczej mówiÈc, rzutowania, które umieszczaliĂmy w C# 1, zawsze dziaïaïy. Umieszczenie rzutowania w kodzie dziaïa trochÚ jak znak ostrzegawczy, dziÚki czemu zwracamy wiÚkszÈ uwagÚ na poprawnoĂÊ typów. Typy generyczne byÊ moĝe nie zmniejszÈ radykalnie bïÚdów zwiÈzanych z bez- pieczeñstwem typów, ale wprowadzona przez nie czytelnoĂÊ kodu wpïynie pozytywnie na redukcjÚ bïÚdów zwiÈzanych z uĝyciem kodu przez jego odbiorców. Prosty kod ma wiÚkszÈ szansÚ byÊ dobrze zrozumiany. O wiele ïatwiej jest napisaÊ dobry kod, który musi byÊ odporny na nieprzemyĂlane zachowania pro- gramistów, kiedy odpowiednie gwarancje co do typu argumentów zapewnia sam system typów. To, co do tej pory powiedzieliĂmy o typach generycznych, przemawia wystarczajÈco na ich korzyĂÊ, ale sÈ teĝ jeszcze korzyĂci pod wzglÚdem wydajnoĂciowym. Po pierw- sze, skoro kompilator moĝe wykonaÊ wiÚcej sprawdzeñ na etapie kompilacji, pozostaje 94 ROZDZIAà 3 Parametryzowanie typów i metod mniej rzeczy do weryfikacji w czasie wykonania. Po drugie, kompilator JIT moĝe trak- towaÊ typy wartoĂciowe w sprytniejszy sposób, dziÚki czemu w wielu sytuacjach udaje siÚ uniknÈÊ opakowywania i odpakowywania wartoĂci. W pewnych przypadkach moĝe to zdecydowanie wpïynÈÊ zarówno na wydajnoĂÊ, jak i zuĝycie pamiÚci. Wiele z korzyĂci, jakie dajÈ typy generyczne, moĝe do zïudzenia przypominaÊ te pïynÈce z przewagi statycznego systemu typów nad systemem dynamicznym. Mowa tu o lepszej weryfikacji typów na poziomie kompilacji, wiÚkszej liczbie informacji zawar- tych bezpoĂrednio w kodzie, lepszym wsparciu ze strony Ărodowiska IDE i lepszej wydajnoĂci. Powód jest prosty: kiedy korzystasz z ogólnego interfejsu programistycz- nego (na przykïad z klasy ArrayList), który nie jest w stanie wykryÊ róĝnic pomiÚdzy róĝnymi typami, znajdujesz siÚ — jeĂli chodzi o dostÚp do tego interfejsu — w sytuacji dynamicznego systemu typów. Warto przy okazji wspomnieÊ, ĝe sytuacja odwrotna — przewaga dynamicznego systemu typów nad systemem statycznym — ma miejsce w nie- licznych przypadkach (korzyĂci pïynÈce z zastosowania dynamicznych jÚzyków rzadko sÈ bowiem zwiÈzane z koniecznoĂciÈ dokonania wyboru pomiÚdzy interfejsem gene- rycznym i niegenerycznym). Kiedy moĝesz skorzystaÊ z typów generycznych, decyzja o ich uĝyciu jest oczywista. To wszystko czeka na nas w C# 2 — teraz przyszïa pora na rzeczywiste wykorzy- stanie typów generycznych. 3.2. Proste typy generyczne do codziennego uĪycia Jeĝeli chcesz wiedzieÊ wszystko o typach generycznych, musisz mieÊ ĂwiadomoĂÊ, ĝe majÈ one wiele skomplikowanych elementów. Specyfikacja jÚzyka C# przedstawia caïy szereg szczegóïowych informacji, aby opisaÊ zachowanie w niemal kaĝdej moĝliwej sytuacji. My nie musimy jednak znaÊ wszystkich przypadków szczególnych, aby wyko- rzystaÊ typy generyczne w sposób produktywny. (W rzeczywistoĂci ta sama zasada obowiÈzuje dla dowolnego obszaru jÚzyka. Dla przykïadu nie musisz znaÊ wszystkich zasad rzÈdzÈcych przypisaniami, wystarczy, ĝe bÚdziesz umiaï naprawiÊ kod w przypadku bïÚdu kompilacji). W tym podrozdziale opiszemy wszystko, co powinieneĂ wiedzieÊ o typach gene- rycznych, aby móc zastosowaÊ je w codziennej pracy — zarówno w sensie uĝytkownika interfejsu stworzonego przez innych programistów, jak i producenta wïasnych inter- fejsów. Jeĝeli utkniesz na tym etapie, proponujÚ, abyĂ siÚ skoncentrowaï na wiedzy potrzebnej do korzystania z typów i metod generycznych zawartych w Ărodowisku i innych bibliotekach. Ta wiedza jest przydatna o wiele czÚĂciej niĝ umiejÚtnoĂÊ samo- dzielnego tworzenia typów i metod generycznych. Zaczniemy od przyjrzenia siÚ jednej z klas kolekcji wprowadzonych w .NET 2.0 — Dictionary TKey, TValue . 3.2.1. Nauka przez przykáad — sáownik typu generycznego Uĝycie typów generycznych jest proste, o ile nie napotkasz przypadkiem jakiegoĂ ograniczenia i nie zaczniesz siÚ zastanawiaÊ, czemu Twoje rozwiÈzanie nie chce dziaïaÊ. Bez jakiejkolwiek wiedzy teoretycznej moĝesz z ïatwoĂciÈ przewidzieÊ zachowanie 3.2. Proste typy generyczne do codziennego uĝycia 95 kodu, po prostu go analizujÈc. KorzystajÈc z metody prób i bïÚdów, bÚdziesz w stanie napisaÊ wïasny dziaïajÈcy kod. (Jednym z udogodnieñ typów generycznych jest to, ĝe spora czÚĂÊ weryfikacji kodu odbywa siÚ w czasie kompilacji, jest zatem spora szansa, ĝe Twój kod bÚdzie dziaïaï, kiedy doprowadzisz do pomyĂlnej kompilacji — takie zacho- wanie jeszcze bardziej upraszcza eksperymentowanie z kodem). OczywiĂcie, celem tego rozdziaïu jest wyposaĝenie CiÚ w wiedzÚ, dziÚki której nie bÚdziesz musiaï zga- dywaÊ — bÚdziesz dokïadnie wiedziaï, co siÚ dzieje na kaĝdym kroku. Teraz przyjrzyjmy siÚ fragmentowi kodu, który wyglÈda w miarÚ prosto, nawet jeĂli skïadnia jest nieznajoma. Listing 3.1 uĝywa typu Dictionary TKey, TValue (w przy- bliĝeniu generycznego odpowiednika niegenerycznej klasy Hashtable) do zliczenia czÚ- stotliwoĂci wystÚpowania sïów w zadanym tekĂcie. Listing 3.1. UĪycie Dictionary TKey, TValue do zliczenia sáów w tekĞcie static Dictionary string, int CountWords(string text) { Dictionary string, int frequencies; frequencies = new Dictionary string, int (); string[] words = Regex.Split(text, @ W+ ); Utworzenie nowego sáownika „sáowo – liczba wystąpieĔ” Utworzenie nowego sáownika „sáowo – liczba wystąpieĔ” foreach (string word in words) { if (frequencies.ContainsKey(word)) { frequencies[word]++; } else { frequencies[word] = 1; } } return frequencies; } ... string text = @ Chodzi lisek kođo drogi, Cichuteēko stawia nogi, Cichuteēko siú zakrada, Nic nikomu nie powiada. ; Dodanie do sáownika lub jego uaktualnienie Dictionary string, int frequencies = CountWords(text); foreach (KeyValuePair string, int entry in frequencies) { string word = entry.Key; int frequency = entry.Value; Console.WriteLine( {0}: {1} , word, frequency); } Utworzenie komórki widoku tabeli Metoda CountWords tworzy pusty sïownik dla par ïañcuch (string) – liczba (int) ( ). Jej zadaniem bÚdzie zliczanie wystÈpieñ kaĝdego sïowa w zadanym tekĂcie. NastÚpnie ) do podzielenia tekstu na sïowa. Wyraĝenie nie jest uĝywamy wyraĝenia regularnego ( szczególnie wyszukane — ze wzglÚdu na kropkÚ na koñcu zdania wĂród sïów pojawia siÚ pusty ïañcuch, a te same sïowa pisane wielkÈ i maïÈ literÈ sÈ traktowane jako róĝne. 96 ROZDZIAà 3 Parametryzowanie typów i metod Problemy te moĝna ïatwo rozwiÈzaÊ — nie zrobiïem tego tylko dlatego, aby uzyskaÊ jak najprostszy kod dla tego przykïadu. Sprawdzamy, czy dane sïowo jest juĝ w naszym sïowniku. JeĂli jest, zwiÚkszamy licznik, w przeciwnym razie tworzymy wartoĂÊ poczÈt- ). ZwróÊ uwagÚ, ĝe kod dokonujÈcy inkrementacji nie musi wykony- kowÈ licznika ( waÊ rzutowania na typ int. Wiemy, ĝe otrzymana wartoĂÊ jest typu int juĝ na etapie kompilacji. Krok wykonujÈcy inkrementacjÚ tak naprawdÚ pobiera indekser sïownika, zwiÚksza wartoĂÊ, a nastÚpnie ustawia indekser z powrotem. Niektórzy programiĂci wolÈ wykonaÊ ten krok w sposób jawny, uĝywajÈc wyraĝenia frequencies[word] = frequen ´cies[word] + 1;. Ostatnia czÚĂÊ listingu wyglÈda znajomo: enumeracja przez instancjÚ typu Hashtable daje podobnÈ (niegenerycznÈ) parÚ DictionaryEntry z wïaĂciwoĂciami Key i Value dla ). Róĝnica polega na tym, ĝe w C# 1 klucz i wartoĂÊ zosta- kaĝdego elementu kolekcji ( ïyby zwr
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

C# od podszewki. Wydanie II
Autor:

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