Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00107 007795 10476342 na godz. na dobę w sumie
.NET Framework 2.0. Zaawansowane programowanie - książka
.NET Framework 2.0. Zaawansowane programowanie - książka
Autor: Liczba stron: 672
Wydawca: Helion Język publikacji: polski
ISBN: 83-246-0654-8 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> .net - programowanie
Porównaj ceny (książka, ebook, audiobook).

Przegląd funkcji i możliwości .NET Framework 2.0
oraz środowiska CLR 2.0 dla zaawansowanych

Wraz z coraz bardziej rozbudowaną funkcjonalnością .NET Framework rośnie także jej popularność. Możliwość błyskawicznego tworzenia zaawansowanych aplikacji dla systemu Windows na bazie tej platformy oraz wspólnego środowiska uruchomieniowego CLR sprawia, że coraz większa rzesza programistów pragnie poznać te technologie i wykorzystać je do zwiększenia swej produktywności. Wersja 2.0 .NET Framework udostępnia większą liczbę wbudowanych kontrolek, nowe funkcje obsługi baz danych za pomocą ADO.NET, rozbudowane narzędzia do tworzenia witryn internetowych przy użyciu ASP.NET i wiele innych usprawnień znacznie ułatwiających programowanie.

'.NET Framework 2.0. Zaawansowane programowanie' to podręcznik dla programistów, którzy chcą szybko rozpocząć pracę z tą platformą. Dzięki tej książce poznasz mechanizmy działania .NET Framework i środowiska CLR, a także funkcje licznych bibliotek, zarówno tych podstawowych, jak i bardziej wyspecjalizowanych. Dowiesz się, jak przy użyciu tych technologii łatwo zapewniać bezpieczeństwo kodu, debugować oprogramowanie, obsługiwać transakcje, zapewniać współdziałanie aplikacji z kodem niezarządzanym i wykonywać wiele innych potrzebnych operacji.

Zacznij korzystać z możliwości .NET Framework 2.0
i już dziś zwiększ swą produktywność.

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

Darmowy fragment publikacji:

.NET Framework 2.0. Zaawansowane programowanie Autor: Joe Duffy T³umaczenie: Pawe³ Dudziak, Bogdan Kamiñski, Grzegorz Werner ISBN: 978-83-246-0654-2 Tytu³ orygina³u: Professional .NET Framework 2.0 Format: B5, stron: 672 oprawa twarda Przyk³ady na ftp: 78 kB Przegl¹d funkcji i mo¿liwoœci .NET Framework 2.0 oraz œrodowiska CLR 2.0 dla zaawansowanych • Jakie mo¿liwoœci oferuje platforma .NET Framework 2.0 i œrodowisko CLR 2.0? • Jak szybko i ³atwo pisaæ aplikacje dla systemu Windows? • Jak zwiêkszyæ sw¹ produktywnoœæ? Wraz z coraz bardziej rozbudowan¹ funkcjonalnoœci¹ .NET Framework roœnie tak¿e jej popularnoœæ. Mo¿liwoœæ b³yskawicznego tworzenia zaawansowanych aplikacji dla systemu Windows na bazie tej platformy oraz wspólnego œrodowiska uruchomieniowego CLR sprawia, ¿e coraz wiêksza rzesza programistów pragnie poznaæ te technologie i wykorzystaæ je do zwiêkszenia swej produktywnoœci. Wersja 2.0 .NET Framework udostêpnia wiêksz¹ liczbê wbudowanych kontrolek, nowe funkcje obs³ugi baz danych za pomoc¹ ADO.NET, rozbudowane narzêdzia do tworzenia witryn internetowych przy u¿yciu ASP.NET i wiele innych usprawnieñ znacznie u³atwiaj¹cych programowanie. „.NET Framework 2.0. Zaawansowane programowanie” to podrêcznik dla programistów, którzy chc¹ szybko rozpocz¹æ pracê z t¹ platform¹. Dziêki tej ksi¹¿ce poznasz mechanizmy dzia³ania .NET Framework i œrodowiska CLR, a tak¿e funkcje licznych bibliotek, zarówno tych podstawowych, jak i bardziej wyspecjalizowanych. Dowiesz siê, jak przy u¿yciu tych technologii ³atwo zapewniaæ bezpieczeñstwo kodu, debugowaæ oprogramowanie, obs³ugiwaæ transakcje, zapewniaæ wspó³dzia³anie aplikacji z kodem niezarz¹dzanym i wykonywaæ wiele innych potrzebnych operacji. • Funkcjonowanie œrodowiska CLR • Struktura i mechanizmy wspólnego systemu typów (CTS) • Dzia³anie jêzyka poœredniego (IL) i kompilacji JIT • Obs³uga operacji wejœcia-wyjœcia • Tworzenie aplikacji miêdzynarodowych • Zapewnianie bezpieczeñstwa kodu • Programowanie wspó³bie¿ne przy u¿yciu w¹tków, domen i procesów • Umo¿liwianie wspó³dzia³ania z kodem niezarz¹dzanym • Debugowanie oprogramowania • Stosowanie wyra¿eñ regularnych • Programowanie dynamiczne z zastosowaniem metadanych i refleksji • Obs³uga transakcji Zacznij korzystaæ z mo¿liwoœci .NET Framework 2.0 i ju¿ dziœ zwiêksz sw¹ produktywnoœæ Wydawnictwo Helion ul. Koœciuszki 1c 44-100 Gliwice tel. 032 230 98 63 e-mail: helion@helion.pl O autorze .................................................................................................................................................... 11 Przedmowa ............................................................................................................................................... 13 Część I Podstawowe informacje o CLR 21 Rozdział 1. Wprowadzenie .......................................................................................................................23 Historia platformy ........................................................................................................ 23 Nadejście platformy .NET Framework ....................................................................... 24 Przegląd technologii .NET Framework ............................................................................ 25 Kluczowe udoskonalenia w wersji 2.0 ...................................................................... 26 Rozdział 2. Wspólny system typów ........................................................................................................29 Wprowadzenie do systemów typów ............................................................................... 30 Znaczenie bezpieczeństwa typologicznego ................................................................ 31 Statyczna i dynamiczna kontrola typów .................................................................... 33 Typy i obiekty .............................................................................................................. 37 Unifikacja typów ..................................................................................................... 37 Typy referencyjne i wartościowe ............................................................................... 39 Dostępność i widoczność ........................................................................................ 47 Składowe typów ..................................................................................................... 48 Podklasy i polimorfizm ............................................................................................ 73 Przestrzenie nazw: organizowanie typów ................................................................... 82 Typy specjalne ....................................................................................................... 84 Generyki ..................................................................................................................... 94 Podstawy i terminologia .......................................................................................... 94 Ograniczenia ........................................................................................................ 102 Lektura uzupełniająca ................................................................................................ 104 Książki poświęcone .NET Framework i CLR ............................................................. 104 Systemy typów i języki .......................................................................................... 104 Generyki i pokrewne technologie ........................................................................... 105 Konkretne języki ................................................................................................... 105 6 .NET Framework 2.0. Zaawansowane programowanie Rozdział 3. Wewnątrz CLR .................................................................................................................... 107 Intermediate Language (IL) ......................................................................................... 108 Przykład kodu IL: „Witaj, świecie!” ......................................................................... 108 Asemblacja i dezasemblacja IL .............................................................................. 110 Abstrakcyjna maszyna stosowa ............................................................................. 110 Zestaw instrukcji .................................................................................................. 113 Wyjątki ..................................................................................................................... 127 Podstawy wyjątków ............................................................................................... 128 Szybkie zamknięcie .............................................................................................. 140 Wyjątki dwuprzebiegowe ....................................................................................... 140 Wydajność ........................................................................................................... 142 Automatyczne zarządzanie pamięcią ........................................................................... 144 Alokacja .............................................................................................................. 144 Odśmiecanie ....................................................................................................... 150 Finalizacja ........................................................................................................... 153 Kompilacja just-in-time (JIT) ........................................................................................ 155 Przegląd procesu kompilacji .................................................................................. 155 Wywoływanie metod ............................................................................................. 156 Obsługa architektury 64-bitowej ............................................................................ 162 Lektura uzupełniająca ................................................................................................ 162 Rozdział 4. Podzespoły, wczytywanie i wdrażanie ............................................................................. 165 Jednostki wdrażania, wykonywania i wielokrotnego użytku ............................................. 166 Metadane podzespołu .......................................................................................... 168 Podzespoły współdzielone (Global Assembly Cache) ............................................... 177 Podzespoły zaprzyjaźnione .................................................................................... 178 Wczytywanie podzespołów .......................................................................................... 179 Proces wiązania, mapowania i wczytywania ............................................................ 179 Wczytywanie CLR ................................................................................................. 188 Statyczne wczytywanie podzespołów ...................................................................... 189 Dynamiczne wczytywanie podzespołów ................................................................... 191 Przekazywanie typów ............................................................................................ 195 Generowanie obrazów natywnych (NGen) ..................................................................... 197 Zarządzanie buforem (ngen.exe) ............................................................................ 198 Adresy bazowe i poprawki ..................................................................................... 198 Wady i zalety ....................................................................................................... 201 Lektura uzupełniająca ................................................................................................ 202 Część II Podstawowe biblioteki .NET Framework 203 Rozdział 5. Najważniejsze typy .NET .................................................................................................... 205 Typy podstawowe ...................................................................................................... 205 Object ................................................................................................................. 207 Liczby ................................................................................................................. 214 Wartości logiczne ................................................................................................. 219 Łańcuchy ............................................................................................................. 219 IntPtr .................................................................................................................. 227 Daty i czas .......................................................................................................... 227 Pomocnicze klasy BCL ............................................................................................... 231 Formatowanie ...................................................................................................... 231 Analiza składniowa ............................................................................................... 235 Spis treści 7 Konwersja typów podstawowych ............................................................................ 236 Budowanie łańcuchów .......................................................................................... 237 Odśmiecanie ....................................................................................................... 238 Słabe referencje .................................................................................................. 240 Wywołania matematyczne ..................................................................................... 241 Najważniejsze wyjątki ................................................................................................. 244 Wyjątki systemowe ............................................................................................... 245 Inne standardowe wyjątki ...................................................................................... 247 Wyjątki niestandardowe ........................................................................................ 249 Lektura uzupełniająca ................................................................................................ 249 Rozdział 6. Tablice i kolekcje ................................................................................................................ 251 Tablice ..................................................................................................................... 251 Tablice jednowymiarowe ....................................................................................... 252 Tablice wielowymiarowe ........................................................................................ 253 Obsługa tablic w BCL (System.Array) ..................................................................... 256 Tablice stałe ........................................................................................................ 261 Kolekcje ................................................................................................................... 261 Kolekcje generyczne ............................................................................................. 262 Słabo typizowane kolekcje .................................................................................... 283 Porównywalność ................................................................................................... 284 Funkcjonalne typy delegacyjne ............................................................................... 289 Lektura uzupełniająca ................................................................................................ 291 Rozdział 7. Wejście-wyjście, pliki i sieć ............................................................................................. 293 Strumienie ................................................................................................................ 294 Praca z klasą bazową ........................................................................................... 294 Klasy czytające i piszące ...................................................................................... 303 Pliki i katalogi ...................................................................................................... 310 Inne implementacje strumieni ............................................................................... 318 Urządzenia standardowe ............................................................................................ 320 Zapisywanie danych na standardowym wyjściu i standardowym wyjściu błędów ......... 320 Czytanie ze standardowego wejścia ....................................................................... 321 Sterowanie konsolą .............................................................................................. 321 Port szeregowy .................................................................................................... 322 Sieć ......................................................................................................................... 322 Gniazda ............................................................................................................... 323 Informacje o sieci ................................................................................................ 331 Klasy do obsługi protokołów .................................................................................. 332 Lektura uzupełniająca ................................................................................................ 340 Rozdział 8. Internacjonalizacja ............................................................................................................ 343 Definicja internacjonalizacji ........................................................................................ 344 Obsługa platformy ................................................................................................ 344 Proces ................................................................................................................ 346 Przykładowe scenariusze ........................................................................................... 348 Dostarczanie zlokalizowanej treści ......................................................................... 348 Formatowanie regionalne ...................................................................................... 350 Kultura ..................................................................................................................... 351 Reprezentowanie kultur (CultureInfo) ..................................................................... 352 Formatowanie ...................................................................................................... 357 8 .NET Framework 2.0. Zaawansowane programowanie Zasoby ..................................................................................................................... 358 Tworzenie zasobów .............................................................................................. 358 Pakowanie i wdrażanie ......................................................................................... 360 Dostęp do zasobów .............................................................................................. 362 Kodowanie ................................................................................................................ 363 Obsługa BCL ........................................................................................................ 364 Problemy z domyślną kulturą ...................................................................................... 365 Manipulacja łańcuchami (ToString, Parse i TryParse) ............................................... 365 Lektura uzupełniająca ................................................................................................ 369 Część III Zaawansowane usługi CLR 371 Rozdział 9. Bezpieczeństwo ................................................................................................................. 373 Zabezpieczenia dostępu do kodu ................................................................................ 374 Definiowanie zaufania .......................................................................................... 376 Uprawnienia ........................................................................................................ 380 Zarządzanie polityką ............................................................................................. 385 Stosowanie zabezpieczeń ..................................................................................... 386 Zabezpieczenia oparte na tożsamości użytkowników ........................................................ 391 Tożsamość .......................................................................................................... 392 Kontrola dostępu ................................................................................................. 393 Lektura uzupełniająca ................................................................................................ 396 Rozdział 10. Wątki, domeny i procesy ................................................................................................. 397 Wątki ....................................................................................................................... 400 Przydzielanie pracy wątkom należącym do puli ........................................................ 400 Jawne zarządzanie wątkami .................................................................................. 402 Odizolowane dane wątku ...................................................................................... 411 Współdzielenie elementów pomiędzy wątkami ........................................................ 414 Częste problemy współbieżności ........................................................................... 428 Zdarzenia ............................................................................................................ 430 Model programowania asynchronicznego ............................................................... 433 Zaawansowane zagadnienia wątkowości ................................................................ 436 Domeny AppDomain .................................................................................................. 441 Tworzenie ............................................................................................................ 441 Zwalnianie ........................................................................................................... 442 Wczytywanie kodu do domeny AppDomain .............................................................. 442 Szeregowanie ...................................................................................................... 443 Wczytywanie, zwalnianie i wyjątki ........................................................................... 443 Izolacja domeny AppDomain ................................................................................. 444 Procesy .................................................................................................................... 447 Istniejące procesy ................................................................................................ 447 Tworzenie ............................................................................................................ 449 Kończenie procesów ............................................................................................. 450 Lektura uzupełniająca ................................................................................................ 451 Rozdział 11. Interoperacyjność z kodem niezarządzanym ................................................................ 453 Wskaźniki, uchwyty i zasoby ....................................................................................... 454 Definicja interoperacyjności .................................................................................. 454 Natywne wskaźniki w CTS (IntPtr) .......................................................................... 455 Zarządzanie pamięcią i zasobami .......................................................................... 458 Spis treści 9 Niezawodne zarządzanie zasobami (SafeHandle) .................................................... 463 Powiadamianie GC o wykorzystaniu zasobów .......................................................... 467 Regiony ograniczonego wykonania ......................................................................... 469 Interoperacyjność z COM ........................................................................................... 473 Krótka powtórka z COM ........................................................................................ 473 Interoperacyjność wsteczna .................................................................................. 475 Interoperacyjność w przód ..................................................................................... 481 Praca z kodem niezarządzanym .................................................................................. 483 Platform Invoke (P/Invoke) .................................................................................... 484 Łączenie systemów typów ..................................................................................... 487 Lektura uzupełniająca ................................................................................................ 490 Część IV Zaawansowane biblioteki .NET Framework 491 Rozdział 12. Śledzenie i diagnostyka ................................................................................................... 493 Śledzenie ................................................................................................................. 494 Dlaczego śledzenie, a nie wyjątki? ......................................................................... 495 Architektura śledzenia .......................................................................................... 496 Korzystanie ze źródeł śledzenia ............................................................................. 499 Słuchacze śledzenia ............................................................................................. 506 Konfiguracja ........................................................................................................ 513 Lektura uzupełniająca ................................................................................................ 518 Rozdział 13. Wyrażenia regularne ....................................................................................................... 519 Podstawowa składnia wyrażeń .................................................................................... 520 Kilka przykładowych wyrażeń regularnych ............................................................... 521 Literały ................................................................................................................ 524 Metaznaki ........................................................................................................... 526 Obsługa wyrażeń regularnych w BCL ............................................................................ 539 Wyrażenia ............................................................................................................ 539 Wyrażenia kompilowane ........................................................................................ 548 Lektura uzupełniająca ................................................................................................ 551 Rozdział 14. Programowanie dynamiczne .......................................................................................... 553 API refleksji .............................................................................................................. 554 API informacyjne .................................................................................................. 555 Odwzorowywanie tokenów i uchwytów .................................................................... 569 Atrybuty niestandardowe ............................................................................................ 573 Deklarowanie atrybutów niestandardowych ............................................................. 573 Dostęp do atrybutów niestandardowych ................................................................. 577 Delegacje ................................................................................................................. 578 Wewnątrz delegacji ............................................................................................... 578 Delegacje asynchroniczne ..................................................................................... 585 Metody anonimowe (mechanizm językowy) ............................................................. 586 Emitowanie kodu i metadanych .................................................................................. 588 Generowanie podzespołów .................................................................................... 588 Lektura uzupełniająca ................................................................................................ 592 10 .NET Framework 2.0. Zaawansowane programowanie Rozdział 15. Transakcje ........................................................................................................................ 593 Model programowania transakcyjnego .............................................................................. 595 Zasięgi transakcyjne ....................................................................................................... 596 Zagnieżdżanie i kontrola przepływu ........................................................................ 601 Integracja z Enterprise Services ............................................................................ 605 Menedżery transakcji ............................................................................................ 607 Lektura uzupełniająca ................................................................................................ 609 Dodatki 611 Dodatek A Spis instrukcji IL .................................................................................................................. 613 Skorowidz ............................................................................................................................................. 635 System typów to syntaktyczna metoda dowodzenia braku pewnych niepożądanych działań programu przez klasyfikowanie fraz według rodzaju wartości, które w sobie zawierają. — Benjamin C. Pierce, Types and Programming Languages Ostatecznie wszystkie programy są zbudowane z typów danych. U podstaw każdego języka leżą typy wbudowane, sposoby łączenia ich w celu utworzenia nowych typów oraz metody nadawania nowym typom nazw, aby można było ich używać tak samo jak typów wbudowanych. — Jim Miller, The Common Language Infrastructure Annotated Standard Środowisko Common Language Runtime (CLR) — mówiąc ściślej, każda implementacja specyfikacji Common Language Infrastructure (CLI) — wykonuje kod w ramach dobrze zdefiniowanego systemu typów nazywanego Common Type System (CTS). CTS stanowi część specyfikacji CLI standaryzowanej przez międzynarodowe organizacje normalizacyjne ECMA i ISO z udziałem przedstawicieli branży i środowisk akademickich. CTS definiuje zbiór struktur i usług, których mogą używać programy przeznaczone do wykonania przez CLR, w tym bogaty system typów umożliwiający tworzenie abstrakcji z wykorzystaniem zarówno typów wbudowanych, jak i zdefiniowanych przez użytkownika. Innymi słowy, CTS stanowi interfejs między programami zarządzanymi a samym środowiskiem uruchomie- niowym. Ponadto CTS wprowadza zbiór reguł i aksjomatów, które definiują weryfikowalne bezpie- czeństwo typologiczne. Proces weryfikacji klasyfikuje kod na bezpieczny albo niebezpieczny typologicznie, przy czym ta pierwsza kategoria gwarantuje bezpieczne wykonanie kodu w ramach CLR. Wykonywanie bezpieczne typologicznie pozwala uniknąć uszkodzenia zawar- tości pamięci, do którego mogą doprowadzić nieweryfikowalne programy. CLR zezwala jednak na wykonywanie takich programów, zapewniając dużą elastyczność kosztem poten- cjalnego uszkodzenia danych i nieoczekiwanych błędów. Zunifikowany system typów kontroluje dostęp do danych w pamięci, ich przetwarzanie i łączenie. Oferuje statyczne wykrywanie i eliminowanie niektórych klas błędów programi- stycznych, usystematyzowany sposób budowania i wielokrotnego używania abstrakcji, 30 Część I n Podstawowe informacje o CLR wsparcie dla twórców kompilatorów w postaci bezpiecznego, abstrakcyjnego wirtualnego systemu wykonawczego (ang. virtual execution system, VES), a wreszcie mechanizm samo- opisywania się programów z wykorzystaniem metadanych. Bezpieczeństwo typologiczne i metadane to dwie kluczowe cechy platformy, które zapewniają największe korzyści pod względem produktywności, bezpieczeństwa i niezawodności. Innymi ważnymi składnikami platformy są usługi uruchomieniowe, takie jak odśmiecanie (Garbage Collection, GC), oraz obszerny zbiór wywołań API oferowanych przez .NET Framework. Wszystkie te elementy zostaną dokładnie omówione w kolejnych rozdziałach. Myślenie w kategoriach „czystego CTS” bywa trudne. Niemal wszyscy twórcy zarządzanych bibliotek i aplikacji pracują z konkretnym językiem, takim jak C#, VB, C++/CLI lub Python. Poszczególne języki oferują własne „spojrzenie” na system uruchomieniowy, abstrahując, ukrywając, a czasem nawet nadmiernie uwydatniając niektóre jego części. Wszystkie jednak są ostatecznie kompilowane do tego samego, podstawowego zbioru konstrukcji. Ta różno- rodność jest jednym z powodów, dla których CLR jest tak znakomitym środowiskiem pro- gramowania i może obsługiwać tyle odmiennych języków. Z drugiej strony utrudnia to zrozumienie sposobu, w jaki zasady obowiązujące w różnych językach przekładają się na wspólny system typów. Niniejszy rozdział powinien to rozjaśnić. W tym rozdziale większość idiomów CTS prezentuję z wykorzystaniem C#, choć próbuję wskazywać obszary, w których występuje rozbieżność między semantyką języka a CTS. Ponieważ nie omówiłem jeszcze Common Intermediate Language (CIL) — języka, do które- go kompilowane są wszystkie zarządzane programy (zostanie on opisany w rozdziale 3.) — posłużenie się językiem wyższego poziomu, takim jak C#, pozwoli efektywniej wyjaśnić najważniejsze pojęcia. Dowodem na różnorodność języków obsługiwanych przez CTS mogą być poniższe cztery przykłady, każdy z publicznie dostępnym kompilatorem, który tworzy programy przeznaczone dla CLR: C#, C++/CLI, Python i F#: n C# to (w dużej mierze) statycznie typizowany, imperatywny język w stylu C. Oferuje bardzo nieliczne funkcje, które wykraczają poza ramy weryfikowalnego bezpieczeństwa typologicznego CLR, i cechuje się bardzo wysokim stopniem obiektowości. C# zapewnia też interesujące mechanizmy języków funkcjonalnych, takie jak funkcje klasy pierwszej i blisko spokrewnione z nimi domknięcia, i nadal zmierza w tym kierunku, o czym świadczy wprowadzenie dedukcji typów oraz lambd w nowszych wersjach języka. Kiedy pisałem tę książkę, był to najpopularniejszy język programowania na platformie CLR. n C++/CLI to implementacja języka C++ dostosowana do zbioru instrukcji CTS. Programiści tego języka często wykraczają poza ramy weryfikowalnego bezpieczeństwa typologicznego, bezpośrednio manipulując wskaźnikami i segmentami pamięci. Kompilator obsługuje jednak opcje, które pozwalają ograniczyć programy do weryfikowalnego podzbioru języka. Możliwość łączenia świata zarządzanego z niezarządzanym za pomocą C++ jest imponująca — język Rozdział 2. n Wspólny system typów 31 ten pozwala rekompilować wiele istniejących programów niezarządzanych i wykonywać je pod kontrolą CLR, oczywiście z korzyściami w postaci GC oraz (w dużej mierze) weryfikowalnego IL. n Python, tak jak C#, przetwarza dane w sposób obiektowy. Jednak w przeciwieństwie do C# — i bardzo podobnie jak Visual Basic — dedukuje wszystko, co możliwe, i do chwili uruchomienia programu odwleka wiele decyzji, które zwyczajowo podejmuje się w czasie kompilacji. Programiści tego języka nigdy nie pracują na „surowej” pamięci i zawsze operują w ramach weryfikowalnego bezpieczeństwa typologicznego. W tego rodzaju językach dynamicznych kluczowe znaczenie ma produktywność i łatwość programowania, dzięki którym nadają się one dobrze do pisania skryptów lub rozszerzeń istniejących programów. Pomimo to muszą one produkować kod, który uwzględnia typizację oraz inne kwestie związane z CLR gdzieś między kompilacją a wykonaniem programu. Niektórzy twierdzą, że przyszłość należy do języków dynamicznych. Na szczęście CLR obsługuje je równie dobrze jak każdy inny rodzaj języka. n Wreszcie F# jest typizowanym językiem funkcjonalnym wywodzącym się z O’Caml (który z kolei wywodzi się z języka Standard ML). Oferuje dedukcję typów oraz mechanizmy interoperacyjności przypominające języki skryptowe. F# z całą pewnością eksponuje składnię bardzo odmienną od C#, VB czy Pythona; w istocie wielu programistów posługujących się na co dzień językami w stylu C początkowo może uznać ją za bardzo niekomfortową. F# zapewnia matematyczny sposób deklarowania typów oraz wiele innych użytecznych mechanizmów znanych przede wszystkim z języków funkcjonalnych, takich jak dopasowywanie wzorców. Jest to doskonały język do programowania naukowego i matematycznego. Każdy z tych języków oferuje odmienny (czasem skrajnie różny) widok systemu typów, a wszystkie kompilują się do abstrakcji z tego samego systemu CTS oraz instrukcji z tego samego języka CIL. Biblioteki napisane w jednym języku można wykorzystać w drugim. Pojedynczy program może składać się z wielu części napisanych w różnych językach i połą- czonych w jeden zarządzany plik binarny. Zauważmy też, że idea weryfikacji pozwala do- wieść bezpieczeństwa typologicznego, a jednocześnie w razie potrzeby ominąć całe sekcje CTS (jak w przypadku manipulowania wskaźnikami do surowej pamięci w C++). Oczywiście, istnieją ograniczenia, które można nałożyć na wykonywanie nieweryfikowalnego kodu. W dalszej części rozdziału wrócimy do tych ważnych zagadnień. Znaczenie bezpieczeństwa typologicznego Nie tak dawno temu kod niezarządzany i programowanie w C oraz C++ były faktycznie stan- dardem w branży, a typy — jeśli obecne — stanowiły niewiele więcej niż sposób nadawania nazw przesunięciom w pamięci. Na przykład struktura C to w rzeczywistości duża sekwencja bitów z nazwami, które zapewniają precyzyjny dostęp do przesunięć od adresu bazowego (tzn. pól). Referencje do struktur mogły wskazywać niezgodne instancje, a danymi można było manipulować w zupełnie dowolny sposób. Trzeba przyznać, że C++ był krokiem we właściwym kierunku. Nie istniał jednak żaden system uruchomieniowy, który gwarantowałby, że dostęp do pamięci będzie odbywał się zgodnie z regułami systemu typów. We wszyst- kich językach niezarządzanych istniał jakiś sposób obejścia iluzorycznego bezpieczeństwa typologicznego. 32 Część I n Podstawowe informacje o CLR Takie podejście do programowania okazało się podatne na błędy, co z czasem doprowadziło do ruchu w kierunku języków całkowicie bezpiecznych typologicznie. (Języki z ochroną pamięci były dostępne, jeszcze zanim pojawił się C. Na przykład LISP używa maszyny wir- tualnej oraz środowiska z odśmiecaniem przypominającego CLR, ale pozostaje językiem niszowym wykorzystywanym do badań nad sztuczną inteligencją i innych zastosowań aka- demickich). Z czasem bezpieczne języki i kompilatory zyskiwały na popularności, a dzięki statycznemu wykrywaniu programiści byli powiadamiani o operacjach, które mogą dopro- wadzić do uszkodzenia danych w pamięci, jak na przykład rzutowanie w górę w C++. W innych językach, takich jak VB i Java, zastosowano pełne bezpieczeństwo typologiczne, aby zwiększyć produktywność programistów i niezawodność aplikacji. Jeśli nawet kompi- lator zezwalałby na rzutowanie w górę, środowisko uruchomieniowe wyłapałoby nielegalne rzutowania i obsłużyło je w kontrolowany sposób, na przykład zgłaszając wyjątek. CLR idzie w ślady tych języków. Dowodzenie bezpieczeństwa typologicznego Środowisko CLR jest odpowiedzialne za dowiedzenie bezpieczeństwa typologicznego kodu przed jego uruchomieniem. Szkodliwe niezaufane programy nie mogą obejść tych zabezpie- czeń, a zatem nie mogą uszkodzić danych w pamięci. Gwarantuje to, że: n Dostęp do pamięci odbywa się w dobrze znany i kontrolowany sposób z wykorzystaniem typizowanych referencji. Pamięć nie może zostać uszkodzona po prostu wskutek użycia referencji z błędnym przesunięciem pamięciowym, ponieważ spowodowałoby to zgłoszenie błędu przez weryfikator (a nie ślepe wykonanie żądania). Podobnie instancji typu nie można przypadkowo potraktować jako innego, zupełnie odrębnego typu. n Wszystkie dostępy do pamięci muszą przechodzić przez system typów, co oznacza, że instrukcje nie mogą skłonić mechanizmu wykonawczego do przeprowadzenia operacji, która spowodowałaby błędny dostęp do pamięci w czasie działania programu. Przepełnienie bufora albo zaindeksowanie dowolnej lokacji pamięci po prostu nie jest możliwe (chyba że ktoś odkryje usterkę w CLR albo świadomie użyje niezabezpieczonych, a zatem nieweryfikowalnych konstrukcji). Zauważmy, że powyższe uwagi dotyczą wyłącznie kodu weryfikowalnego. Korzystając z kodu nieweryfikowalnego, możemy konstruować programy, które hurtowo naruszają te ograniczenia. Oznacza to jednak, że bez zdefiniowania specjalnej polityki nie będzie można uruchomić tych programów w kontekście częściowego zaufania. Istnieją też sytuacje, w których do wykonania nieprawidłowej operacji można skłonić mecha- nizmy współpracy z kodem niezarządzanym oferowane przez zaufaną bibliotekę. Wyobraźmy sobie, że zaufane, zarządzane wywołanie API z bibliotek Base Class Libraries (BCL) ślepo przyjmuje liczbę całkowitą i przekazuje ją do kodu niezarządzanego. Jeśli ów kod używa jej do wyznaczenia granic tablicy, napastnik mógłby celowo przekazać nieprawidłowy indeks, aby spowodować przepełnienie bufora. Weryfikacja jest omawiana w niniejszym rozdziale, natomiast częściowe zaufanie zostanie opisane w rozdziale 9. (poświęconym bezpieczeństwu). Twórcy biblioteki ponoszą pełną odpowiedzialność za to, aby ich produkt nie zawierał takich błędów. Rozdział 2. n Wspólny system typów 33 Przykład kodu niebezpiecznego typologicznie (w C) Rozważmy program C, który manipuluje danymi w niebezpieczny sposób, co zwykle pro- wadzi do tzw. naruszenia zasad dostępu do pamięci albo niewykrytego uszkodzenia danych. Naruszenie zasad dostępu występuje podczas przypadkowego zapisu do chronionej pamięci; zwykle jest to bardziej pożądane (i łatwiejsze do zdiagnozowania) niż ślepe nadpisywanie pamięci. Poniższy fragment kodu uszkadza stos, co może spowodować naruszenie przepływu sterowania i nadpisanie różnych danych — w tym adresu powrotnego bieżącej funkcji. Nie jest dobrze: #include stdlib.h #include stdio.h void fill_buffer(char*, int, char); int main() { int x = 10; char buffer[16]; /* … */ fill_buffer(buffer, 32, a ); /* … */ printf( d , x); } void fill_buffer(char* buffer, int size, char c) { int i; for (i = 0; i size; i++) { buffer[i] = c; } } Nasza główna funkcja umieszcza na stosie dwa elementy, liczbę całkowitą x oraz 16-znakową tablicę o nazwie buffer. Następnie przekazuje wskaźnik do bufora (który, jak pamiętamy, znajduje się na stosie), a odbiorcza funkcja fill_buffer używa parametrów size i c do wy- pełnienia bufora odpowiednim znakiem. Niestety, główna funkcja przekazała 32 zamiast 16, co oznacza, że zapiszemy na stosie 32 elementy o rozmiarze typu char, o 16 więcej, niż powinniśmy. Rezultat może być katastrofalny. Sytuacja w pewnej mierze zależy od opty- malizacji dokonanych przez kompilator — niewykluczone, że nadpiszemy tylko połowę wartości x — ale może być bardzo poważna, jeśli dojdzie do nadpisania adresu powrotnego. Dzieje się tak dlatego, że pozwoliliśmy na dostęp do „surowej” pamięci poza ramami prymi- tywnego systemu typów C. Statyczna i dynamiczna kontrola typów Systemy typów często dzieli się na statyczne i dynamiczne, choć w rzeczywistości różnią się także pod wieloma innymi względami. Tak czy owak, CTS oferuje mechanizmy obsługi obu rodzajów systemów, pozwalając projektantom języków na wybór sposobu, w jaki będzie eksponowane bazowe środowisko uruchomieniowe. Oba style mają zagorzałych zwolenników, 34 Część I n Podstawowe informacje o CLR choć wielu programistów czuje się najbardziej komfortowo gdzieś pośrodku. Bez względu na język, w którym napisano program, CLR wykonuje kod w środowisku ze ścisłą kontrolą typów. Oznacza to, że język może unikać kwestii typizacji w czasie kompilacji, ale ostatecznie musi pracować z typologicznymi ograniczeniami weryfikowalnego kodu. Wszystko ma typ, nawet jeśli projektant języka postanowi, że użytkownicy nie będą tego świadomi. Przyjrzymy się krótko pewnym różnicom między językami statycznymi i dynamicznymi, które są widoczne dla użytkownika. Większość omawianych tu zagadnień nie dotyczy wyłącznie CTS, ale może pomóc w zrozumieniu, co się dzieje w mechanizmie wykonawczym. Podczas pierwszej lektury niniejszego rozdziału Czytelnicy mogą pominąć te informacje, zwłaszcza jeśli zupełnie nie znają CLR. Kluczowe różnice w strategiach typizacji Typizacja statyczna próbuje dowieść bezpieczeństwa programu podczas kompilacji, tym samym eliminując całą kategorię błędów wykonania związanych z niedopasowaniem typów oraz naruszeniami zasad dostępu do pamięci. Programy C# są w znacznym stopniu typizowa- ne statycznie, choć mechanizmy takie jak „brudne” rzutowanie w górę pozwalają rozluźnić statyczną kontrolę typów na rzecz dynamizmu. Innymi przykładami statycznie typizowanych języków są Java, Haskell, Standard ML i F#. C++ przypomina C# pod tym względem, że zasadniczo korzysta z typizacji statycznej, choć oferuje pewne mechanizmy, które mogą spowodować błędy w czasie wykonania, zwłaszcza w dziedzinie niebezpiecznych typolo- gicznie manipulacji pamięcią, jak w przypadku C. Niektórzy uważają, że typizacja statyczna wymusza bardziej rozwlekły i mniej ekspery- mentalny styl programowania. Programy są na przykład usiane deklaracjami typów, nawet w przypadkach, w których inteligentny kompilator mógłby je wydedukować. Korzyścią jest oczywiście wykrywanie większej liczby błędów w czasie kompilacji, ale w niektórych scena- riuszach sztuczne ograniczenia zmuszają programistę do gry w przechytrzanie kompilatora. Języki dynamiczne obarczają środowisko uruchomieniowe odpowiedzialnością za wiele testów poprawności, które w językach statycznych są wykonywane w czasie kompilacji. Niektóre języki przyjmują skrajne podejście i rezygnują ze wszystkich testów, podczas gdy inne stosują mieszankę kontroli dynamicznej i statycznej. Do tej kategorii należą języki takie jak VB, Python, Common LISP, Scheme, Perl i Ruby. Wiele osób mówi o programach typizowanych silnie lub słabo albo o programowaniu z wcze- snym lub późnym wiązaniem. Niestety, terminologia ta rzadko bywa używana konsekwentnie. Ogólnie rzecz biorąc, typizacja silna oznacza, że podczas dostępu do pamięci programy muszą wchodzić w prawidłowe interakcje z systemem typów. Na podstawie tej definicji stwierdzamy, że CTS jest silnie typizowanym środowiskiem wykonawczym. Późne wiązanie to postać programowania dynamicznego, w których konkretny typ zostaje powiązany z docelową opera- cją dopiero w czasie wykonywania programu. Większość programów wiąże się z odpowiednim tokenem metadanych bezpośrednio w IL. Języki dynamiczne przeprowadzają to wiązanie bardzo późno, tzn. tuż przed ekspedycją (ang. dispatch) wywołania metody. Jedna platforma, by wszystkimi rządzić Rozdział 2. n Wspólny system typów 35 CLR obsługuje całe spektrum języków, od statycznych do dynamicznych i wszystko pomiędzy. Sama platforma .NET Framework oferuje całą bibliotekę do późno wiązanego programowania dynamicznego, określaną nazwą refleksji (szczegółowy opis można znaleźć w rozdziale 14.). Refleksja eksponuje cały CTS za pośrednictwem wywołań API z przestrzeni nazw System. Reflection, oferując funkcje, które ułatwiają twórcom kompilatorów implementowanie ję- zyków dynamicznych, a zwykłym programistom pozwalają na eksperymenty z programo- waniem dynamicznym. Przykłady obsługiwanych języków Przyjrzyjmy się niektórym językom obsługiwanym przez CTS. Poniżej zamieszczono pięć krótkich programów, z których każdy wypisuje dziesiąty element ciągu Fibonacciego (jest to interesujący, dobrze znany algorytm; tutaj przedstawiono jego naiwną implementację). Dwa przykłady są napisane w językach typizowanych statycznie (C++ i F#), jeden w pośrednim (VB), a dwa w typizowanych dynamicznie (Python i Scheme, dialekt LISP-a). Rozbieżności, które widać na pierwszy rzut oka, mają charakter stylistyczny, ale podstawową różnicą jest to, czy IL emitowany przez poszczególne języki jest statyczny, czy też korzysta z dynamicznej kontroli typów i późnego wiązania. Niebawem wyjaśnię, co to oznacza. C# using System; class Program { static int Fibonacci(int x) { if (x = 1) return 1; return Fibonacci(x - 1) + Fibonacci(x - 2); } public static void Main() { Console.WriteLine(Fibonacci(10)); } } F# let rec fibonacci x = match x with 0 - 1 | 1 - 1 | n - fibonacci(x – 1) + fibonacci(x – 2);; fibonacci 10;; 36 Część I n Podstawowe informacje o CLR VB Option Explicit Off Class Program Shared Function Fibonacci(x) If (x = 1) Return 1 End If Return Fibonacci(x - 1) + Fibonacci(x - 2) End Function Shared Sub Main() Console.WriteLine(Fibonacci(10)) End Sub End Class Python def fib(i): if i = 1: return 1 return fib(i-1) + fib(i-2) print fib(10) Scheme (letrec ((fib (lambda (x) (if ( = x 1) 1 (+ (fib (- x 1)) (fib (- x 2))))))) (fib 10)) Wszędzie nazwy typów! Jak widać, tylko wersja C# wspomina, że pracujemy z 32-bitowymi wartościami int. Są to statyczne adnotacje typów, dzięki którym kompilator może dowieść bezpieczeństwa typo- logicznego programu. Z drugiej strony wiele języków statycznych, na przykład F#, używa techniki zwanej dedukcją typów, która pozwala uniknąć adnotacji, jeśli do ustalenia typów wystarczą literały. W tym przykładzie F# emituje kod IL, który pracuje z wartościami int, choć nie określiliśmy tego w kodzie źródłowym. Języki z dedukcją typów czasem wymagają adnotacji, kiedy nie da się wydedukować typu wyłącznie na podstawie użycia. Język z dedukcją typów może łatwo ustalić, że jakaś zmienna x odnosi się do łańcucha, jeśli w programie pojawia się przypisanie x = Witaj, świecie . W tym nadmiernie uproszczo- nym przykładzie nie ma potrzeby deklarować typu zmiennej, a mimo to program pozostaje bezpieczny typologicznie. Funkcja Fibonacci w języku F# doskonale ilustruje sytuacje, w których dedukcja typów bywa pomocna. W bardziej skomplikowanych przypadkach — na przykład podczas przekazywania danych między granicami oddzielnie skompilowanych jednostek — sytuacja nie wygląda tak różowo. Rozdział 2. n Wspólny system typów 37 Pozostałe języki emitują kod, który pracuje z typem Object — jak się niebawem przekonamy, jest to korzeń całej hierarchii typów — i przeprowadza ścisłe wiązanie w czasie wykonywania programu. W tym celu wywołuje własną bibliotekę uruchomieniową. Oczywiście, programy typizowane statycznie często są wydajniejsze od dynamicznych, po prostu dlatego, że mogą emitować „surowe” instrukcje IL, zamiast wywołać dodatkowe funkcje w bibliotekach późnego wiązania. Dostępność kompilatorów Niektórzy Czytelnicy zapewne zastanawiają się, czy mogą uruchomić powyższe przykłady w CLR. Dobra wiadomość jest taka, że — nie licząc zwykłego C — jest to możliwe! C#, VB i C++ wchodzą w skład dystrybucji .NET Framework 2.0 oraz Visual Studio 2005. F# można pobrać z witryny Microsoft Research pod adresem http://research.microsoft.com/ downloads. Implementację Pythona dla CLR można pobrać pod adresem http://workspaces. gotdotnet.com/ironpython. Wreszcie implementacja Scheme używana podczas kursów na Northeastern University jest dostępna pod adresem www.ccs.neu.edu/home/will/Larceny/ CommonLarceny. Pełne omówienie systemów typów, różnic między nimi oraz zalet i wad różnych decyzji projektowych wykraczałoby poza ramy niniejszej książki. Są to jednak interesujące zagad- nienia; dodatkowe materiały wymieniono w podrozdziale „Lektura uzupełniająca” na końcu niniejszego rozdziału. CTS używa abstrakcji wywodzących się ze środowisk programowania obiektowego, co wpływa zarówno na jednostki abstrakcji, jak i na zbiór instrukcji. Jak już wspomniano, ów system typów cechuje się dużą elastycznością i może pracować pod interfejsem niemal każdego języka. Oznacza to jednak, że kiedy mówimy o CTS, musimy posługiwać się kate- goriami klas i obiektów reprezentujących dane i zahermetyzowane operacje. Unifikacja typów Wszystkie typy CTS mają wspólny typ bazowy stanowiący korzeń hierarchii: System.Object. Jak się niebawem przekonamy, unifikacja ta pozwala na bardzo elastyczne przekazywanie instancji typów w obrębie systemu. Oznacza to zarazem, że każdy typ dziedziczy wspólny zbiór składowych, na przykład metody do przekształcania instancji w reprezentację tekstową, do porównywania tożsamości instancji itd. W rezultacie każda instancja dowolnego typu może być „po prostu obiektem”, co pozwala na implementowanie pewnych ogólnych funkcji. Jak się okazuje, jest to niezwykle użyteczne. Hierarchia typów CTS dzieli się na dwa podstawowe drzewa: typy referencyjne i typy wartościowe. Typy referencyjne wywodzą się bezpośrednio z System.Object, a typy warto- ściowe — ze specjalnego typu CTS System.ValueTySe (który sam wywodzi się z System.Object). 38 Część I n Podstawowe informacje o CLR Diagram hierarchii typów abstrakcyjnych oraz niektórych konkretnych typów wbudowanych przedstawiono na rysunku 2.1. Zawiera on kilka konstrukcji specjalnych, którym przyjrzymy się bliżej w dalszej części rozdziału, na przykład interfejsy i wyliczenia, które mają specjalny status w systemie typów. Rysunek 2.1. Hierarchia typów CTS Zauważmy, że kilka podstawowych typów danych jest wymienionych w gałęzi typów warto- ściowych. Znajduje się tu większość fundamentalnych typów, które programiści uznają za oczywiste: n n n System.Boolean (lub bool w tekstowym IL) to typ, którego instancje mogą przybierać dwie wartości: true lub false, reprezentowane w IL odpowiednio przez 1 i 0. Typ ten zajmuje w pamięci nie 1 bit, ale pełny bajt (8 bitów), dzięki czemu jest wyrównany z natywnymi granicami pamięciowymi, a operacje na nim są bardziej wydajne. System.Char (char w tekstowym IL) reprezentuje pojedynczy 2-bajtowy (16-bitowy) znak Unicode, na przykład „a”, „5”, „Æ”, „á” i wiele, wiele innych. System.SByte, Int16, Int32, Int64 (int8, int16, int32 i int64 w tekstowym IL) reprezentują odpowiednio 1-, 2-, 4- i 8-bajtową (8-, 16-, 32- i 64-bitową) liczbę całkowitą ze znakiem. „Ze znakiem” oznacza, że wartości mogą być dodatnie lub ujemne. Rozdział 2. n Wspólny system typów 39 n n n n System.Byte, UInt16, UInt32, UInt64 (unsigned int8, unsigned int16, unsigned int32 i unsigned int64 w tekstowym IL) reprezentują odpowiednio 1-, 2-, 4- i 8-bajtową (8-, 16-, 32- i 64-bitową) liczbę całkowitą bez znaku. „Bez znaku” oczywiście oznacza, że nie używają one bitu do reprezentowania znaku, a zatem nie mogą przechowywać wartości ujemnych, ale dzięki dodatkowemu bitowi mogą reprezentować dwukrotnie więcej wartości dodatnich niż ich odpowiedniki ze znakiem. System.Single i Double (float32 i float64 w tekstowym IL) reprezentują standardowe 4- i 8-bajtowe (32- i 64-bitowe) liczby zmiennopozycyjne. Używa się ich do reprezentowania liczb z częścią całkowitą i ułamkową. System.IntStr i UIntStr (native int i unsigned native int w tekstowym IL) służą do reprezentowania maszynowych liczb całkowitych, odpowiednio ze znakiem i bez znaku. Najczęściej używa się ich do przechowywania wskaźników do pamięci. W systemach 32-bitowych składają się z 4 bajtów (32 bitów), a w systemach 64-bitowych — z 8 bajtów (64 bitów). System.Void (lub po prostu void) to specjalny typ danych, który reprezentuje brak typu. Używa się go tylko w sygnaturach składowych typu, a nie do określania typu lokacji w pamięci. Z tych typów można konstruować inne abstrakcje hierarchii typów, na przykład: n Tablice, czyli typizowane sekwencje elementów (na przykład System.Int32[]). Tablice zostaną omówione szczegółowo w rozdziale 6. n Zarządzane i niezarządzane wskaźniki do typizowanych lokacji w pamięci (na przykład System.Byte* i System.Byte ). n Bardziej zaawansowane struktury danych, zarówno w referencyjnej, jak i wartościowej hierarchii typów (na przykład Struct Sair { int x; int y }). W rozdziale 5. podam więcej informacji o każdym z typów podstawowych, wyjaśnię defi- niowane przez nie metody oraz opiszę typy takie jak Object.String i DateTime, które nie zostały wymienione powyżej. Następnie omówię wyliczenia, interfejsy i delegacje. Typy referencyjne i wartościowe Jak już stwierdzono, typy CTS dzielą się na dwie podstawowe kategorie: typy referencyjne i typy wartościowe. Typy referencyjne często określa się mianem klas, a wartościowe — mianem struktur, co w dużej mierze jest produktem ubocznym słów kluczowych class i struct, za pomocą których definiuje się je w języku C#. Nie wspomniano jednak jeszcze, dlaczego istnieje takie rozróżnienie i co ono właściwie oznacza. Zajmiemy się tym w niniej- szym punkcie. Instancja typu referencyjnego, zwana obiektem, jest alokowana i zarządzana na odśmiecanej (Garbage Collected, GC) stercie, a jej współdzielenie oraz wszystkie odczyty i zapisy odbywają się przez referencję (tzn. za pośrednictwem wskaźnika). Instancja typu wartościowego, zwana wartością, jest natomiast alokowana jako sekwencja bitów, a jej położenie zależy od zasięgu, w którym jest zdefiniowana (na stosie wykonania, jeśli jest wartością lokalną, albo na stercie 40 Część I n Podstawowe informacje o CLR GC, jeśli jest częścią struktury danych zaalokowanej na stercie). Wartości nie są zarządzane niezależnie przez GC, a w razie współdzielenia są kopiowane. Służą do reprezentowania typów podstawowych i skalarnych. Aby zilustrować różnicę między współdzieleniem obiektu a współdzieleniem wartości, roz- ważmy następującą sytuację. Gdy wczytujemy pole zawierające referencję do obiektu, wczytujemy współdzieloną referencję do tego obiektu. Natomiast kiedy wczytujemy pole zawierające wartość, wczytujemy samą wartość, a nie referencję do niej. Dostęp do obiektu spowoduje wyłuskanie wskaźnika w celu odczytania danych ze współdzielonej pamięci, natomiast dostęp do wartości polega na bezpośredniej pracy z sekwencją bitów składającą się na tę wartość. Niektóre sytuacje dyktują wybór jednej albo drugiej kategorii. Na przykład System.String jest typem referencyjnym, a System.Int32 (tzn. int32 w IL, int w C#) — wartościowym. Zdecydowano się na to nie bez powodu. Wyborem domyślnym zawsze powinna być klasa; jeśli jednak mamy małą strukturę danych z semantyką wartościową, użycie struktury często jest bardziej odpowiednie. Postaram się tu wyjaśnić różnice między obiema kategoriami oraz ich wady i zalety. Przedstawię też pojęcia interfejsów, typów wskaźników, opakowywania i odpakowywania oraz definiowania typów dopuszczających wartość pustą (ang. nullability). Typy referencyjne (klasy) Większość typów definiowanych przez użytkownika powinna mieć postać klas. Klasy wywo- dzą się bezpośrednio z Object albo z innych typów referencyjnych, co zapewnia większą elastyczność i ekspresywność w hierarchii typów. Wspomniano już, że wszystkie obiekty są alokowane i zarządzane przez GC na odśmiecanej stercie. Jak przekonamy się w rozdziale 3., oznacza to, że obiekt „żyje” tak długo, dopóki istnieje osiągalna referencja do niego, po czym GC może odzyskać i ponownie wykorzystać zajmowaną przez niego pamięć. Referencje do obiektów mogą przyjmować specjalną wartość null, która zasadniczo ozna- cza, że referencja jest pusta. Innymi słowy, null może reprezentować nieobecność obiektu. Jeśli spróbujemy wykonać operację na referencji null, zwykle otrzymamy wyjątek NullRe- ferenceExceStion. Typy wartościowe nie obsługują takiego mechanizmu, choć w wersji 2.0 .NET Framework wprowadzono specjalny typ (opisywany niżej), który realizuje tę semantykę. W C# nowy typ referencyjny można utworzyć za pomocą słowa kluczowego class, na przykład: class Customer { public string name; public string address; // Itd., itd., itd. } Klasa może zawierać każdą z jednostek abstrakcji omawianych w dalszej części rozdziału, w tym pola, metody, konstruktory, właściwości itd. Typy wartościowe (struktury) Rozdział 2. n Wspólny system typów 41 Typy wartościowe, znane też jako struktury, służą do reprezentowania prostych wartości. Każdy typ wartościowy wywodzi się niejawnie z klasy System.ValueTySe i jest automatycznie pieczętowany (co oznacza, że inne typy nie mogą się z niego wywodzić; omówimy to później). Instancje typów wartościowych są nazywane wartościami i alokowane na stosie wykonania (w przypadku instancji lokalnych) albo na stercie (w przypadku pól klas lub struktur, które same są polami klas (lub struktur…)). Typy wartościowe używane jako pola statyczne są zwykle alokowane na stercie GC, choć jest to szczegół implementacyjny. Pola statyczne o względnym adresie wirtualnym (ang. Relative Virtual Address, RVA) mogą być alokowane w specjalnych segmentach pamięci CLR, jak w przypadku typów skalarnych używanych jako pola statyczne. Struktury narzucają mniejsze koszty pamięciowe i czasowe podczas pracy z lokalnym stosem, ale oszczędności te mogą szybko zostać zdominowane przez koszty kopiowania wartości, zwłaszcza jeśli wartość zajmuje zbyt wiele miejsca. Ogólnie rzecz biorąc, struktur należy używać do przechowywania niezmiennych danych o rozmiarze nieprzekraczającym 64 bajtów. Wkrótce wyjaśnię, jak można ustalić rozmiar struktury. Czas życia wartości zależy od miejsca, w którym jej użyto. Jeśli została zaalokowana na stosie wykonania, jest dealokowana podczas usuwania ramki stosu. Dzieje się to podczas wyjścia z metody wskutek powrotu albo nieobsłużonego wyjątku. Porównajmy to ze stertą, czyli segmentem pamięci zarządzanym przez GC. Jeśli na przykład wartość jest instancyj- nym polem klasy, to jest alokowana wewnątrz instancji obiektu na zarządzanej stercie i ma ten sam czas życia co instancja obiektu. Jeśli wartość jest instancyjnym polem struktury, to jest alokowana tam, gdzie została zaalokowana zawierająca ją struktura, a zatem ma ten sam czas życia co struktura. W C# nowy typ wartościowy można utworzyć za pomocą słowa kluczowego struct, na przykład: struct Point2d { public int x; public int y; } Struktura może zasadniczo zawierać te same jednostki abstrakcji co klasa. Jednak typ war- tościowy nie może definiować bezparametrowego konstruktora, co wynika ze sposobu, w jaki instancje wartości są tworzone przez środowisko uruchomieniowe (opisuję to niżej). Ponieważ inicjalizatory pól są w rzeczywistości kompilowane do postaci konstruktora domyślnego, nie można również określać domyślnych wartości pól struktur. Natomiast ze względu na to, że typy wartościowe wywodzą się niejawnie z ValueTySe, C# nie pozwala definiować typu bazowego, choć nadal można implementować interfejsy. Wartości Wartość to po prostu sekwencja bajtów pozbawiona wewnętrznego opisu, a referencja do wartości jest w rzeczywistości wskaźnikiem do pierwszego z tych bajtów. Podczas tworze- nia wartości CLR „zeruje” bajty, ustawiając każde pole instancji na wartość domyślną. Two- rzenie wartości odbywa się niejawnie w przypadku zmiennych lokalnych i pól typów. 42 Część I n Podstawowe informacje o CLR Zerowanie wartości jes
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

.NET Framework 2.0. Zaawansowane programowanie
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ą: