Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00375 006237 19033711 na godz. na dobę w sumie
C# 7.0 w pigułce. Wydanie VII - książka
C# 7.0 w pigułce. Wydanie VII - książka
Autor: , Liczba stron: 1024
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-283-4075-6 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c# - programowanie
Porównaj ceny (książka, ebook (-35%), audiobook).

C# jest uważany za flagowy projekt firmy Microsoft. Język ten charakteryzuje się niezwykłą elastycznością i wszechstronnością. Udostępnia wysokopoziomowe abstrakcje, takie jak wyrażenia, zapytania i kontynuacje asynchroniczne, ale też pozwala na korzystanie z mechanizmów niskopoziomowych. W efekcie dzięki takim konstrukcjom, jak własne typy wartościowe programisty czy opcjonalne wskaźniki, można znacząco zwiększyć wydajność aplikacji. Wersja 7.0 jest kolejną poważną aktualizacją języka. Zapoznanie się z tymi zmianami będzie bardzo ważne dla każdego programisty piszącego w C#.

Niniejsza książka jest kolejnym, uzupełnionym i zaktualizowanym wydaniem cenionego kompendium wiedzy o C#, CLR oraz o związanej z C# platformie. Napisano ją z myślą o programistach na co najmniej średnim poziomie zaawansowania. W zrozumiały, a równocześnie dogłębny sposób wyjaśniono takie trudne kwestie, jak współbieżność, bezpieczeństwo i domeny aplikacji. Informacje o nowych składnikach języka C# 6.0 i 7.0, a także o związanej z nim platformie zostały oznaczone. Szczególnie istotny z punktu widzenia programisty może okazać się rozdział o nowym kompilatorze Roslyn, zwanym kompilatorem usługowym.

Najważniejsze zagadnienia ujęte w książce:

C# w nowej odsłonie - nowoczesny język dla profesjonalistów!

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

Darmowy fragment publikacji:

Tytuł oryginału: C# 7.0 in a Nutshell: The Definitive Reference, 7th edition Tłumaczenie: Łukasz Piwko, z wykorzystaniem fragmentów książki C# 6.0 w pigułce. Wydanie VI w tłumaczeniu Roberta Górczyńskiego i Jakuba Hubisza ISBN: 978-83-283-4075-6 © 2018 Helion S.A. Authorized Polish translation of the English edition of C# 7.0 in a Nutshell ISBN 9781491987650 © 2018 Joseph Albahari, Ben Albahari This translation is published and sold by permission of O’Reilly Media, Inc., which owns or controls all rights to publish and sell the same. 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/c7pig7 Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Pliki z przykładami omawianymi w książce można znaleźć pod adresem: ftp://ftp.helion.pl/przyklady/c7pig7.zip Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis treści Wst(cid:253)p ..........................................................................................................................11 1. Wprowadzenie do C# i .NET Framework ................................................................. 15 15 16 17 17 17 18 18 22 Obiektowość Bezpieczeństwo typów Zarządzanie pamięcią Platformy Powiązania C# z CLR CLR i .NET Framework Inne platformy Historia C# w pigułce 2. Podstawy j(cid:253)zyka C# ..................................................................................................29 29 32 34 42 50 52 54 58 67 72 73 82 Pierwszy program w języku C# Składnia Podstawy typów Typy liczbowe Typ logiczny i operatory Łańcuchy znaków i pojedyncze znaki Tablice Zmienne i parametry Wyrażenia i operatory Operatory null Instrukcje Przestrzenie nazw 3 Poleć książkęKup książkę 3. Tworzenie typów w j(cid:253)zyku C# .................................................................................89 89 104 113 117 118 120 125 128 130 Klasy Dziedziczenie Typ object Struktury Modyfikatory dostępu Interfejsy Wyliczenia Typy zagnieżdżone Typy generyczne 4. Zaawansowane elementy j(cid:253)zyka C# ......................................................................143 143 151 158 162 163 171 176 181 184 185 188 190 192 199 202 206 208 Delegaty Zdarzenia Wyrażenia lambda Metody anonimowe Instrukcje try i wyjątki Wyliczanie i iteratory Typy wartościowe dopuszczające wartość null Metody rozszerzające Typy anonimowe Krotki (C# 7) Atrybuty Atrybuty informacji wywołującego Wiązanie dynamiczne Przeciążanie operatorów Niebezpieczny kod i wskaźniki Dyrektywy preprocesora Dokumentacja XML 5. Ogólny zarys platformy ........................................................................................... 213 215 217 221 .NET Standard 2.0 CLR i rdzeń platformy Technologie praktyczne 6. Podstawowe wiadomo(cid:316)ci o platformie ..................................................................229 229 242 249 Obsługa łańcuchów i tekstu Data i godzina Daty i strefy czasowe 4 (cid:95) Spis treści Poleć książkęKup książkę Formatowanie i parsowanie Standardowe łańcuchy formatu i flagi parsowania Inne mechanizmy konwersji Globalizacja Praca z liczbami Wyliczenia Struktura Guid Sprawdzanie równości Określanie kolejności Klasy pomocnicze 255 260 267 271 272 276 279 280 289 293 7. Kolekcje ....................................................................................................................297 297 304 308 316 324 330 336 Przeliczalność Interfejsy ICollection i IList Klasa Array Listy, kolejki, stosy i zbiory Słowniki Kolekcje i pośredniki z możliwością dostosowywania Dołączanie protokołów równości i porządkowania 8. Zapytania LINQ ........................................................................................................343 343 345 351 355 361 364 368 370 376 389 Podstawy Składnia płynna Wyrażenia zapytań Wykonywanie opóźnione Podzapytania Tworzenie zapytań złożonych Strategie projekcji Zapytania interpretowane LINQ to SQL i Entity Framework Budowanie wyrażeń zapytań 9. Operatory LINQ ........................................................................................................395 396 399 403 414 421 424 Informacje ogólne Filtrowanie Projekcja Łączenie Porządkowanie Grupowanie Spis treści (cid:95) 5 Poleć książkęKup książkę Operatory zbiorów Metody konwersji Operatory elementów Metody agregacyjne Kwantyfikatory Metody generujące 427 428 431 433 437 438 10. LINQ to XML .............................................................................................................441 441 442 445 448 452 455 458 461 466 467 Przegląd architektury Informacje ogólne o X-DOM Tworzenie drzewa X-DOM Nawigowanie i wysyłanie zapytań Modyfikowanie drzewa X-DOM Praca z wartościami Dokumenty i deklaracje Nazwy i przestrzenie nazw Adnotacje Projekcja do X-DOM 11. Inne technologie XML ..............................................................................................473 474 Klasa XmlReader 482 Klasa XmlWriter Typowe zastosowania klas XmlReader i XmlWriter 484 488 XSD i sprawdzanie poprawności schematów XSLT 491 12. Zwalnianie zasobów i mechanizm usuwania nieu(cid:348)ytków ....................................493 493 499 501 506 511 515 IDisposable, Dispose i Close Automatyczne usuwanie nieużytków Finalizatory Jak działa mechanizm usuwania nieużytków? Wycieki pamięci zarządzanej Słabe odwołania 13. Diagnostyka i kontrakty kodu ................................................................................. 519 520 523 526 528 Kompilacja warunkowa Debugowanie i klasy monitorowania Integracja z debuggerem Procesy i wątki procesów 6 (cid:95) Spis treści Poleć książkęKup książkę Klasy StackTrace i StackFrame Dziennik zdarzeń Windows Liczniki wydajności Klasa Stopwatch 529 530 533 538 14. Wspó(cid:293)bie(cid:348)no(cid:316)(cid:235) i asynchroniczno(cid:316)(cid:235) .........................................................................539 539 540 557 565 570 586 594 Wprowadzenie Wątkowanie Zadania Reguły asynchroniczności Funkcje asynchroniczne w języku C# Wzorce asynchroniczności Wzorce uznane za przestarzałe 15. Strumienie i wej(cid:316)cie-wyj(cid:316)cie ..................................................................................599 599 601 614 622 624 625 635 638 641 Architektura strumienia Użycie strumieni Adapter strumienia Kompresja strumienia Praca z plikami w postaci archiwum ZIP Operacje na plikach i katalogach Plikowe operacje wejścia-wyjścia w UWP Mapowanie plików w pamięci Odizolowany magazyn danych 16. Sie(cid:235) ...........................................................................................................................643 643 646 647 649 661 667 670 672 673 673 677 679 Architektura sieci Adresy i porty Adresy URI Klasy po stronie klienta Praca z HTTP Utworzenie serwera HTTP Użycie FTP Użycie DNS Wysyłanie poczty elektronicznej za pomocą SmtpClient Użycie TCP Otrzymywanie poczty elektronicznej POP3 za pomocą TCP TCP w środowisku uruchomieniowym Windows Spis treści (cid:95) 7 Poleć książkęKup książkę 17. Serializacja ...............................................................................................................681 681 685 695 697 700 702 706 709 Koncepcje serializacji Serializacja kontraktu danych Kontrakty danych i kolekcje Rozszerzenie kontraktu danych Serializacja binarna Atrybuty serializacji binarnej Serializacja binarna za pomocą ISerializable Serializacja XML 18. Zestawy .................................................................................................................... 719 719 724 727 730 734 736 745 750 751 753 Co znajduje się w zestawie? Silne nazwy i podpisywanie zestawu Nazwy zestawów Technologia Authenticode Global Assembly Cache Zasoby i zestawy satelickie Wyszukiwanie i wczytywanie zestawów Wdrażanie zestawów poza katalogiem bazowym Umieszczenie w pojedynczym pliku wykonywalnym Praca z zestawami, do których nie ma odwołań 19. Refleksja i metadane ...............................................................................................755 756 762 774 775 781 787 791 796 798 801 Refleksja i aktywacja typów Refleksja i wywoływanie składowych Refleksja dla zestawów Praca z atrybutami Generowanie dynamicznego kodu Emitowanie zestawów i typów Emitowanie składowych typów Emitowanie generycznych typów i klas Kłopotliwe cele emisji Parsowanie IL 20. Programowanie dynamiczne ..................................................................................807 807 809 810 816 819 Dynamiczny system wykonawczy języka Unifikacja typów liczbowych Dynamiczne wybieranie przeciążonych składowych Implementowanie obiektów dynamicznych Współpraca z językami dynamicznymi 8 (cid:95) Spis treści Poleć książkęKup książkę 21. Bezpiecze(cid:295)stwo ....................................................................................................... 821 821 822 825 827 828 829 831 835 Code Access Security Tożsamość i role Zabezpieczenia systemu operacyjnego Kryptografia Windows Data Protection Obliczanie skrótów Szyfrowanie symetryczne Szyfrowanie kluczem publicznym i podpisywanie 22. Zaawansowane techniki wielow(cid:233)tkowo(cid:316)ci ...........................................................839 840 840 848 854 859 867 868 871 873 874 875 Przegląd technik synchronizacji Blokowanie wykluczające Blokady i bezpieczeństwo ze względu na wątki Blokowanie bez wykluczania Sygnalizacja przy użyciu uchwytów zdarzeń oczekiwania Klasa Barrier Leniwa inicjalizacja Pamięć lokalna wątku Metody Interrupt i Abort Metody Suspend i Resume Zegary 23. Programowanie równoleg(cid:293)e ...................................................................................879 879 882 895 901 910 913 916 Dlaczego PFX? PLINQ Klasa Parallel Równoległe wykonywanie zadań Klasa AggregateException Kolekcje współbieżne Klasa BlockingCollection T 24. Domeny aplikacji ..................................................................................................... 921 921 923 924 926 927 927 929 Architektura domeny aplikacji Tworzenie i likwidowanie domen aplikacji Posługiwanie się wieloma domenami aplikacji Metoda DoCallBack Monitorowanie domen aplikacji Domeny i wątki Dzielenie danych między domenami Spis treści (cid:95) 9 Poleć książkęKup książkę 25. Wspó(cid:293)dzia(cid:293)anie macierzyste i poprzez COM .........................................................935 935 936 939 939 940 943 946 948 952 952 953 Odwołania do natywnych bibliotek DLL Szeregowanie Wywołania zwrotne z kodu niezarządzanego Symulowanie unii C Pamięć współdzielona Mapowanie struktury na pamięć niezarządzaną Współpraca COM Wywołanie komponentu COM z C# Osadzanie typów współpracujących Główne moduły współpracujące Udostępnianie obiektów C# dla COM 26. Wyra(cid:348)enia regularne ...............................................................................................955 956 960 961 964 965 967 970 Podstawy wyrażeń regularnych Kwantyfikatory Asercje o zerowej wielkości Grupy Zastępowanie i dzielenie tekstu Receptury wyrażeń regularnych Leksykon języka wyrażeń regularnych 27. Kompilator Roslyn ...................................................................................................975 976 977 991 Architektura Roslyn Drzewa składni Kompilacja i model semantyczny Skorowidz ..............................................................................................................1003 10 (cid:95) Spis treści Poleć książkęKup książkę 5 Ogólny zarys platformy Prawie wszystkie elementy funkcjonalności platformy .NET Framework są udostępniane przez szeroki wachlarz typów zarządzanych. Typy te są posegregowane w hierarchicznych przestrzeniach nazw i zapakowane w zbiór zestawów, które to zestawy, wraz z systemem wykonawczym CLR (ang. Common Language Runtime), stanowią platformę .NET. Niektóre typy .NET są bezpośrednio wykorzystywane przez CLR i niezbędne do działania środowiska zarządzanego. Typy te znajdują się w zestawie o nazwie mscorlib.dll i obejmują np. wszystkie typy wbudowane języka C#, jak również: podstawowe klasy kolekcyjne, typy do przetwarzania strumieni, serializacyjne, refleksyjne, wątkowe oraz interoperacyjne (nazwa mscorlib to skrót od ang. słów Multi-language Standard Common Object Runtime Library). Na wyższym poziomie znajdują się dodatkowe typy, na których opiera się funkcjonalność CLR i które zapewniają obsługę formatu XML, sieci oraz LINQ. Znajdują się one w zestawach: System.dll, System.Xml.dll oraz System.Core.dll. Wraz z zestawem mscorlib reprezentują bogate środowisko programistyczne, na bazie którego zbudowana jest cała platforma. Pozostała część książki jest w głównej mierze poświęcona właśnie temu „rdzeniowi platformy”. Reszta platformy .NET Framework obejmuje praktyczne interfejsy API, których większość można zaliczyć do jednego z trzech obszarów funkcjonalności: (cid:120) technologie dotyczące interfejsu użytkownika; (cid:120) technologie zapleczowe; (cid:120) technologie dotyczące systemów rozproszonych. W tabeli 5.1 przedstawiono poziomy wzajemnej zgodności różnych wersji języka C#, CLR oraz .NET Framework. W tym rozdziale znajduje się zwięzły przegląd wszystkich najważniejszych składników platformy .NET Framework — od podstawowych typów opisywanych w tej książce po technologie stosowane. 213 Poleć książkęKup książkę Tabela 5.1. Wersje C#, CLR i .NET Framework Wersja C# Wersja CLR 1.0 1.2 2.0 3.0 4.0 5.0 6.0 7.0 1.0 1.1 2.0 2.0 (SP2) 4.0 4.5 (udoskonalony CLR 4.0) 4.6 (udoskonalony CLR 4.0) 4.6/4.7 (udoskonalony CLR 4.0) Wersja platformy 1.0 1.1 2.0, 3.0 3.5 4.0 4.5 4.6 4.6/4.7 Co nowego w .NET Framework 4.6 (cid:120) Programista ma większe możliwości w zakresie kontrolowania procesu usuwania nieużytków dzięki nowym metodom klasy GC. Dodano też kilka opcji wywoływania GC.Collect. (cid:120) Dodano nowy, szybszy, 64-bitowy kompilator JIT. (cid:120) W przestrzeni nazw System.Numerics znalazły się obsługiwane sprzętowo typy macierzowe i wektorowe, BigInteger oraz Complex. (cid:120) Dodano klasę System.AppContext, dzięki której twórcy bibliotek mogą umożliwiać konsumentom włączanie i wyłączanie nowych funkcji API. (cid:120) Zadania podczas tworzenia pobierają kulturę bieżącego wątku i interfejsu użytkownika. (cid:120) Zwiększono liczbę typów kolekcyjnych implementujących interfejs IReadOnlyCollection T . (cid:120) Wprowadzono dalsze udoskonalenia w WPF, m.in. poprawiono obsługę ekranów dotykowych i o wysokiej rozdzielczości DPI. (cid:120) ASP.NET obsługuje HTTP/2 oraz Token Binding Protocol w Windows 10. Zestawy i przestrzenie nazw należące do platformy .NET Framework są pomieszane. Najbardziej jaskrawymi przykładami są zestawy mscorlib.dll i System.Core.dll za- wierające definicje typów należących do kilkudziesięciu przestrzeni nazw, z których żadna nie ma przedrostka mscorlib ani System.Core. Ale są też mniej oczywiste przykłady, które powodują więcej nieporozumień, np. typy w przestrzeni System. (cid:180)Security.Cryptography. Większość typów należących do tej przestrzeni znajduje się w zestawie System.dll, ale niektóre umieszczono w System.Security.dll. Na stronie internetowej oryginalnego wydania tej książki można znaleźć informacje (w języku angielskim) na temat tego, które przestrzenie nazw odpowiadają poszczególnym ze- stawom (http://www.albahari.com/nutshell/NamespaceReference.aspx). 214 (cid:95) Rozdział 5. Ogólny zarys platformy Poleć książkęKup książkę Wiele rdzennych typów jest zdefiniowanych w następujących zestawach: mscorlib.dll, System.dll oraz System.Core.dll. Zestaw mscorlib.dll zawiera typy wymagane przez samo środowisko wykonawcze. Zestawy System.dll i System.Core.dll zawierają dodatkowe typy potrzebne programiście. Powody istnienia tych dwóch zestawów zamiast jednego mają podłoże historyczne. Firma Microsoft wpro- wadziła platformę .NET Framework 3.5 jako dodatek w tym sensie, że działała ona jako warstwa nad istniejącym CLR 2.0. Dlatego prawie wszystkie nowe typy rdzenne (np. klasy obsługujące LINQ) do- dano do nowego zestawu, któremu nadano nazwę System.Core.dll. Co nowego w .NET Framework 4.7 Framework 4.7 to wersja zawierająca więcej udoskonaleń niż nowych funkcji. Poprawiono w niej wiele błędów i wprowadzono liczne usprawnienia, a ponadto: (cid:120) Struktura System.ValueTuple należy do Framework 4.7, więc w C# 7 można używać krotek bez odwoływania się do zestawu System.ValueTuple.dll. (cid:120) Poprawiono obsługę funkcji dotykowych w WPF. (cid:120) Poprawiono obsługę monitorów o wysokiej rozdzielczości w Windows Forms. .NET Standard 2.0 W rozdziale 1. opisaliśmy trzy główne alternatywy dla .NET Framework w programowaniu wie- loplatformowym: (cid:120) UWP dla urządzeń i komputerów z systemem Windows 10. (cid:120) .NET Core/ASP.NET Core dla Windows, Linux i MacOS. (cid:120) Xamarin dla urządzeń mobilnych (iOS, Android i Windows 10). Dobra wiadomość jest taka, że w .NET Core 2.0 te środowiska — wraz z .NET Framework 4.6.1 i nowszymi — upodobniły się do siebie pod względem funkcjonalności i teraz wszystkie oferują podstawową bibliotekę klas (ang. base class library — BCL) zawierającą podobne typy i składowe. Podobieństwom tym nadano formalny kształt w postaci nowego standardu o nazwie .NET Standard 2.0. Pisząc bibliotekę w Visual Studio 2017, jako platformę docelową można wybrać .NET Standard 2.0 zamiast któregokolwiek spośród bardziej konkretnych środowisk. Dzięki temu biblioteka będzie przenośna i jeden zestaw będzie działał bez modyfikacji w (nowych wersjach) wszystkich czterech środowisk. .NET Standard to nie środowisko, lecz specyfikacja opisująca minimalną podsta- wową funkcjonalność (typy i składowe), która gwarantuje zgodność z określonym zbiorem środowisk. Koncepcja ta jest podobna do koncepcji interfejsów w C#: .NET Standard jest jak interfejs, który może być implementowany przez konkretne typy (środowiska). W tej książce znajduje się opis większości składników .NET Standard 2.0. .NET Standard 2.0 (cid:95) 215 Poleć książkęKup książkę Starsze standardy .NET Standard W użyciu znajdują się także starsze standardy .NET Standard, a konkretnie 1.1, 1.2, 1.3 oraz 1.6. Standard o wyższym numerze wersji zawsze jest nadzbiorem poprzedniego standardu. Gdybyśmy na przykład pisali bibliotekę dla .NET Standard 1.6, to obsługiwałaby ona nie tylko nowe wersje czterech najważniejszych środowisk, ale również .NET Core 1.0. A gdybyśmy pisali dla .NET Standard 1.3, obsługiwalibyśmy wszystko, o czym była już mowa, plus .NET Framework 4.6.0 (zobacz tabelę 5.2). Tabela 5.2. Starsze standardy .NET Standard Standard docelowy Standard 1.6 Standard 1.3 Standard 1.2 Standard 1.1 Dodatkowa obsługa .NET Core 1.0 Powyżej plus .NET 4.6.0 Do .NET 4.5.1, Windows Phone 8.1, WinRT dla Windows 8.1 Do .NET 4.5.0, Windows Phone 8.0, WinRT dla Windows 8.0 Standardy 1.x są pozbawione tysięcy API, które zawiera wersja 2.0, w tym wielu składników opisanych w tej książce. Dlatego pisanie programu dla standardu 1.x może okazać się znacznie trudniejsze, w szczególności jeśli dodatkowo trzeba będzie zintegrować już istniejący kod lub biblioteki. Jeśli interesują Cię starsze środowiska, ale nie potrzebujesz zgodności międzyplat- formowej, to lepszym rozwiązaniem jest obranie za cel starszej wersji konkretnego środowiska. W przypadku systemu Windows dobrym wyborem jest .NET Frame- work 4.5, ponieważ to środowisko jest szeroko rozpowszechnione (zainstalowane we wszystkich komputerach z systemem Windows 8 i nowszymi) i zawiera większość składników .NET Framework 4.7. Standard .NET Standard można też traktować jako swego rodzaju najmniejszy wspólny mianownik. Jeśli chodzi o .NET Standard 2.0, to cztery środowiska, które go implementują, mają podobną bi- bliotekę Base Class Library, dzięki czemu ich najmniejszy wspólny mianownik jest duży i uży- teczny. Gdybyśmy jednak dodatkowo potrzebowali zgodności z .NET Core 1.0 (o bardzo okrojo- nej BCL), to najmniejszy wspólny mianownik — .NET Standard 1.x — byłby jeszcze mniejszy i mniej użyteczny. Zestawy referencyjne Podczas kompilowania programu należy wskazać zestawy zawierające potrzebne w tym programie części środowiska. Na przykład prosty program konsolowy dla platformy .NET Framework, zawie- rający zapytanie LINQ do XML, potrzebowałby zestawów mscorlib.dll, System.dll, System.Xml.dll, System.Xml.Linq.dll oraz System.Core.dll. W Visual Studio zestawy wskazuje się poprzez dodawanie odwołań do projektu (wymienione powyżej zestawy są dodawane automatycznie przy tworzeniu projektów przeznaczonych dla śro- dowiska .NET Framework 4.x). Wskazane przez programistę zestawy są potrzebne tylko kompi- latorowi i nie muszą być takie same jak te wykorzystywane w czasie działania programu. Dlatego można też używać specjalnych zestawów referencyjnych, które mają postać pustych skorup niezawierających 216 (cid:95) Rozdział 5. Ogólny zarys platformy Poleć książkęKup książkę żadnego skompilowanego kodu. Tak właśnie działa .NET Standard: dodajemy zestaw referencyjny o nazwie netstandard.dll, który zawiera wszystkie dozwolone typy i składowe .NET Standard 2.0 (ale bez jakiegokolwiek skompilowanego kodu). Już w czasie działania programu następuje zała- dowanie „prawdziwych” zestawów za pomocą atrybutów przekierowania zestawów. (Wybór „praw- dziwych” zestawów zależy od tego, w którym konkretnie środowisku nastąpi uruchomienie). Zestawy referencyjne umożliwiają także pisanie programów przeznaczonych dla niższych wersji środowiska, niż jest zainstalowane w komputerze. Jeśli na przykład mamy zainstalowane .NET Framework 4.7 i Visual Studio 2017, to nadal możemy utworzyć projekt przeznaczony dla .NET Framework 4.0. Dzięki zbiorowi zestawów referencyjnych Framework 4.0 nasz projekt będzie używał tylko typów i składowych z Framework 4.0. CLR i rdzeń platformy Typy systemowe Najbardziej podstawowe typy znajdują się bezpośrednio w przestrzeni nazw System. Zaliczają się do nich typy wbudowane C#, klasy bazowe Exception, Enum, Array i Delegate oraz Nullable, Type, DateTime, TimeSpan i Guid. Ponadto przestrzeń nazw System zawiera typy do wykonywania funkcji matematycznych (Math), generowania liczb losowych (Random) oraz dokonywania konwersji między różnymi typami (Convert i BitConverter). Typy te zostały opisane w rozdziale 6. razem z interfejsami definiującymi standardowe protokoły wykorzystywane w .NET Framework do wykonywania takich czynności jak formatowanie (IFormat (cid:180)table) czy porównywanie w celu określenia kolejności (IComparable). Dodatkowo w przestrzeni nazw System zdefiniowano interfejs IDisposable i klasę GC do współpracy z systemem usuwania nieużytków. Szerzej na te tematy piszemy w rozdziale 12. Przetwarzanie tekstu Przestrzeń nazw System.Text zawiera klasę StringBuilder (umożliwiającą edytowanie kuzynkę klasy string) i typy do pracy z różnymi technikami kodowania tekstu, np. UTF-8 (Encoding i podtypy). Szerzej na ten temat piszemy w rozdziale 6. Przestrzeń nazw System.Text.RegularExpressions zawiera typy do wykonywania skomplikowa- nych operacji wyszukiwania i zastępowania tekstu na podstawie wzorców. Ich dokładniejszy opis zamieściliśmy w rozdziale 26. Kolekcje Platforma .NET Framework zawiera wiele klas do przechowywania kolekcji elementów. Można wśród nich znaleźć zarówno struktury listowe, jak i słownikowe, które współpracują z zestawem standardowych interfejsów unifikujących ich wspólne cechy. Wszystkie typy kolekcyjne, opisane w rozdziale 7., są zdefiniowane w następujących przestrzeniach nazw: CLR i rdzeń platformy (cid:95) 217 Poleć książkęKup książkę System.Collections // kolekcje niegeneryczne System.Collections.Generic // kolekcje generyczne System.Collections.Specialized // kolekcje silnie typizowane System.Collections.ObjectModel // klasy bazowe do tworzenia kolekcji System.Collections.Concurrent // kolekcje bezpieczne pod wzgl(cid:266)dem w(cid:261)tków (zob. rozdzia(cid:225) 23.) Zapytania Technologia LINQ (ang. Language Integrated Query) została dodana w .NET Framework 3.5. Przy jej użyciu można wysyłać bezpieczne pod względem typów zapytania do lokalnych i zdalnych kolekcji (np. tabel serwera SQL). Opis tej technologii zajmuje rozdziały 8. – 10. Wielką zaletą LINQ jest spójny zapytaniowy interfejs API dla różnych domen. Podstawowe typy służące do rozpoznawania zapytań LINQ znajdują się w następujących przestrzeniach nazw i należą do .NET Standard 2.0: System.Linq // LINQ dla obiektów i PLINQ System.Linq.Expressions // do r(cid:266)cznego tworzenia wyra(cid:298)e(cid:276) System.Xml.Linq // LINQ dla XML Pełne środowisko .NET zawiera również następujące typy, których szczegółowy opis znajduje się w podrozdziale „Technologie zaplecza”: System.Data.Linq // LINQ dla SQL System.Data.Entity // LINQ dla jednostek (Entity Framework) XML Format XML jest powszechnie wykorzystywany w .NET Framework, więc cieszy się też bardzo dobrą obsługą. Cały rozdział 10. jest poświęcony technologii LINQ dla XML, czyli lekkiemu obiektowemu modelowi dokumentu XML, który można tworzyć i odpytywać przez LINQ. W rozdziale 11. znajduje się opis starszego modelu DOM W3C, szybkich niskopoziomowych klas do odczytu i zapisu danych oraz sposobu obsługi przez platformę schematów XML, arkuszy stylów i technologii XPath. Przestrzenie nazw XML to: System.Xml // XmlReader, XmlWriter + stary DOM W3C System.Xml.Linq // DOM LINQ dla XML System.Xml.Schema // obs(cid:225)uga XSD System.Xml.Serialization // deklaratywna serializacja XML dla typów .NET System.Xml.XPath // j(cid:266)zyk zapyta(cid:276) XPath System.Xml.Xsl // obs(cid:225)uga arkuszy stylów Poniższe przestrzenie nazw są dostępne w profilach klasycznych .NET (tzn. nie dla Windows Store): System.Xml.XPath // j(cid:266)zyk zapyta(cid:276) XPath System.Xml.Xsl // obs(cid:225)uga arkuszy stylów Diagnostyka W rozdziale 13. opisujemy narzędzie platformy .NET do obsługi dzienników i definiowania asercji. Ponadto w rozdziale tym dowiesz się, jak współpracować z innymi procesami i zapisywać informa- cje w dzienniku zdarzeń systemu Windows oraz jak monitorować wydajność za pomocą mierników. Odpowiednie do tego typy są zdefiniowane w przestrzeni nazw System.Diagnostics. 218 (cid:95) Rozdział 5. Ogólny zarys platformy Poleć książkęKup książkę Współbieżność i asynchroniczność Wiele nowoczesnych aplikacji musi pracować nad kilkoma rzeczami jednocześnie. Od C# 5.0 stało się to łatwiejsze dzięki dodaniu funkcji asynchronicznych i takich wysokopoziomowych kon- strukcji jak zadania i kombinatory zadań. Szczegółowo zajmujemy się tym w rozdziale 14., po wpro- wadzeniu do podstaw wielowątkowości. Typy do pracy z wątkami i asynchronicznego wykony- wania operacji znajdują się w przestrzeniach nazw System.Threading i System.Threading.Tasks. Strumienie oraz operacje wejścia i wyjścia Platforma .NET Framework zapewnia strumieniowe narzędzia do niskopoziomowej pracy z wej- ściem i wyjściem. Strumienie są zazwyczaj wykorzystywane do bezpośredniego odczytywania i zapi- sywania danych w plikach i połączeniach sieciowych oraz można je łączyć lub opakowywać w stru- mienie dekoracyjne w celu zastosowania kompresji lub szyfrowania. W rozdziale 15. znajduje się opis architektury strumieniowej platformy .NET oraz narzędzi do pracy z plikami i katalogami, kompresji, przechowywania danych w wydzielonej pamięci masowej, pracy z potokami oraz plikami mapowanymi na pamięć. Typy Stream oraz wejścia i wyjścia są zdefiniowane w przestrzeni nazw System.IO i jej przestrzeniach podrzędnych, a typy WinRT do obsługi wejścia i wyjścia plikowego znajdują się w przestrzeni nazw Windows.Storage. Sieć Za pomocą typów z przestrzeni nazw System.Net można bezpośrednio pracować z takimi protokołami, jak: HTTP, FTP, TCP/IP i SMTP. W rozdziale 16. pokazujemy sposoby komunikacji przy użyciu każdego z nich, zaczynając od prostej czynności pobierania strony internetowej, a na pobieraniu poczty POP3 bezpośrednio przy użyciu TCP/IP kończąc. Oto lista przestrzeni nazw, które opisujemy: System.Net System.Net.Http // HttpClient System.Net.Mail // do wysy(cid:225)ania poczty przez SMTP System.Net.Sockets // TCP, UDP i IP Dwie ostatnie przestrzenie są niedostępne dla aplikacji dla Windows Store, jeśli docelowym syste- mem jest Windows 8/8.1 (WinRT), ale są dostępne dla aplikacji Windows 10 Store (UWP) w ra- mach kontraktu .NET Standard 2.0. W przypadku aplikacji WinRT do wysyłania poczty należy używać bibliotek zewnętrznych, a do pracy z gniazdami należy używać typów WinRT z przestrzeni nazw Windows.Networking.Sockets. Serializacja Platforma zawiera kilka systemów do zapisywania i przywracania obiektów do postaci binarnej lub tekstowej. Systemy te są potrzebne w technologiach do budowy aplikacji rozproszonych, np. WCF, usług sieciowych i programów do komunikacji zdalnej, a także do zapisywania obiektów w plikach i przywracania ich stamtąd. W rozdziale 17. opisujemy trzy najważniejsze mechanizmy serializacji — serializator kontraktu danych, serializator binarny oraz serializator XML (w .NET dostępny jest też serializator JSON). Typy do obsługi serializacji znajdują się w następujących przestrzeniach nazw: System.Runtime.Serialization System.Xml.Serialization CLR i rdzeń platformy (cid:95) 219 Poleć książkęKup książkę Zestawy, refleksja i atrybuty Zestawy, do postaci których kompilowane są programy w języku C#, zawierają instrukcje wykony- walne (w postaci języka pośredniego zwanego skrótowo IL od ang. nazwy intermediate language) i metadane opisujące typy, składowe oraz atrybuty programu. Za pomocą technik refleksji można przeglądać te metadane w czasie działania programu i np. dynamicznie wywoływać metody. Za pomo- cą typów z przestrzeni nazw Reflection.Emit można tworzyć nowy kod w locie. W rozdziale 18. opisujemy budowę zestawów oraz sposoby ich podpisywania, metody wykorzystania globalnego bufora zestawów (ang. global assembly cache — GAC) i zasobów zestawów oraz sposoby rozpoznawania odwołań do plików. W rozdziale 19. opisujemy refleksję i atrybuty — metody prze- glądania metadanych, dynamicznego wywoływania funkcji, pisania własnych atrybutów, emitowania nowych typów oraz przetwarzania surowego kodu IL. Typy do posługiwania się technikami re- fleksji i do pracy z zestawami znajdują się w następujących przestrzeniach nazw: System System.Reflection System.Reflection.Emit // tylko .NET Framework Programowanie dynamiczne W rozdziale 20. przedstawiamy niektóre typowe techniki programowania dynamicznego oraz metody wykorzystania systemu DLR (ang. Dynamic Language Runtime) wchodzącego w skład CLR od wersji 4.0 platformy. Pokazujemy sposoby implementacji wzorca wizytator (ang. Visitor), pisania własnych obiektów dynamicznych oraz współpracy z językiem IronPython. Typy do programowania dynamicznego znajdują się w przestrzeni nazw System.Dynamic. Bezpieczeństwo Platforma .NET Framework ma własną warstwę bezpieczeństwa, która pozwala programiście uruchamiać w piaskownicy zarówno inne zestawy, jak i ją samą. W rozdziale 21. opisujemy kwestie dotyczące uprawnień dostępu kodu, ról oraz tożsamości, jak również model transparentności wprowadzony w CLR 4.0. W dalszej części rozdziału opisujemy narzędzia kryptograficzne platformy, m.in. techniki szyfrowania, mieszania i ochrony danych. Odpowiednie do tego typy są zdefiniowane w następujących przestrzeniach nazw: System.Security System.Security.Permissions System.Security.Policy System.Security.Cryptography Zaawansowane techniki pracy z wątkami Funkcje asynchroniczne języka C# znacznie ułatwiają programowanie współbieżne, ponieważ zmniej- szają zapotrzebowanie na techniki niskopoziomowe. Mimo to czasami nie można się obejść bez kon- strukcji sygnalizacyjnych, pamięci wątkowej, blokad odczytu i zapisu itd. Szerzej na ten temat piszemy w rozdziale 22. Typy do pracy z wątkami znajdują się w przestrzeni nazw System.Threading. 220 (cid:95) Rozdział 5. Ogólny zarys platformy Poleć książkęKup książkę Programowanie równoległe W rozdziale 23. zamieściliśmy szczegółowy opis bibliotek i typów służących do pracy z procesorami wielordzeniowymi, m.in.: interfejsów API równoległego wykonywania zadań, imperatywnej równole- głości na poziomie danych oraz równoległości na poziomie funkcji (PLINQ). Domeny aplikacji System CLR zapewnia dodatkowy poziom izolacji wewnątrz procesu, zwany domeną aplikacji (ang. application domain). W rozdziale 24. opisujemy te własności domeny aplikacji, z których można korzystać, i pokazujemy, jak tworzyć dodatkowe domeny aplikacji oraz jak ich używać w obrębie jednego procesu do takich celów jak testowanie jednostkowe. Ponadto pokazujemy sposoby użycia technik pracy zdalnej (ang. remoting) z tymi domenami. Tworzenie osobnych domen aplikacji nie jest częścią .NET Standard 2.0, chociaż można odnosić się do bieżącej domeny za pośrednictwem klasy AppDomain z przestrzeni nazwy System. Interoperacyjność macierzysta i COM Współpracować można zarówno z kodem macierzystym, jak i z COM. Interoperacyjność macierzysta umożliwia wywoływanie funkcji w niezarządzanych bibliotekach DLL, rejestrowanie funkcji zwrot- nych, mapowanie struktur danych oraz współpracę z macierzystymi typami danych. Natomiast inter- operacyjność COM umożliwia wywoływanie typów COM i udostępnianie typów .NET technologii COM. Typy dotyczące tej funkcjonalności znajdują się w przestrzeni nazw System.Runtime. (cid:180)InteropServices i zostały opisane w rozdziale 25. Technologie praktyczne API interfejsu użytkownika Aplikacje z interfejsem użytkownika można podzielić na dwie kategorie: klienty ubogie (ang. thin clients), do których zaliczają się strony internetowe, i klienty bogate (ang. rich clients), do których zali- czają się programy pobierane na dysk komputera lub urządzenia przenośnego i na nim instalowane. Do tworzenia aplikacji pierwszego typu na platformie .NET służą biblioteki ASP.NET i ASP.NET Core. Natomiast aplikacje bogate, przeznaczone dla klasycznych komputerów z systemem Windows 7/8/10, są tworzone przy użyciu interfejsów API WPF i Windows Forms. Aplikacje przeznaczone dla systemów iOS, Android i Windows Phone można tworzyć przy użyciu Xamarin, a do tworzenia bogatych aplikacji dla systemu Windows 10 przeznaczona jest technologia UWP (zobacz tabelę 1.1 w rozdziale 1.). Istnieje też technologia hybrydowa, o nazwie Silverlight, która właściwie straciła znaczenie z chwilą pojawienia się HTML5. Technologie praktyczne (cid:95) 221 Poleć książkęKup książkę ASP.NET Aplikacje napisane w technologii ASP.NET działają na serwerze Windows IIS i można uzyskać do nich dostęp z każdego innego serwera sieciowego. Oto zalety ASP.NET w porównaniu z technolo- giami „bogatymi”: (cid:120) brak konieczności wdrażania u klienta; (cid:120) klient może korzystać z innej platformy niż Windows; (cid:120) łatwość wdrażania aktualizacji. Ponadto, dzięki temu, że większość kodu aplikacji ASP.NET działa na serwerze, warstwa dostępu do danych może działać w tej samej domenie aplikacji — bez ograniczania bezpieczeństwa i możli- wości skalowania. Natomiast klienty bogate o podobnej funkcjonalności nie są generalnie tak bez- pieczne ani skalowalne. (Rozwiązaniem jest dodanie warstwy środkowej między klientem i bazą danych. Warstwa ta działa na zdalnym serwerze aplikacji — często obok serwera baz danych — i komunikuje się z bogatymi klientami poprzez WCF, usługi sieciowe lub technologie pracy zdalnej). Pisząc stronę internetową, można wybierać między tradycyjnymi API Web Forms (formularze internetowe) i nowszym MVC (ang. Model-View-Controller). Obie technologie bazują na in- frastrukturze ASP.NET. Formularze internetowe są obecne na platformie od początku. Natomiast MVC dodano znacznie później jako odpowiedź na sukces Ruby on Rails i MonoRail. Generalnie MVC zapewnia lepszą abstrakcję programistyczną niż Web Forms i daje większą kontrolę nad gene- rowanym kodem HTML. Porzucając Web Forms, tracimy natomiast projektanta, więc technologia ta nadal jest dobrym wyborem, jeśli trzeba utworzyć stronę zawierającą głównie statyczną treść. Ograniczenia ASP.NET są zasadniczo odzwierciedleniem ogólnych ograniczeń systemów klientów ubogich: (cid:120) Choć dzięki technologiom HTML5 i AJAX przeglądarka internetowa jest w stanie zapewnić bogaty interfejs użytkownika, to wciąż pod względem funkcjonalności i szybkości działania ustępuje bogatym API macierzystym, takim jak WPF. (cid:120) Przechowywanie informacji o stanie na kliencie — lub w jego imieniu — może być kłopotliwe. Typy służące do pisania aplikacji ASP.NET są zdefiniowane w przestrzeni nazw System.Web.UI i jej przestrzeniach podrzędnych oraz znajdują się w zestawie System.Web.dll. Technologia ASP.NET 5 jest dostępna w NuGet. ASP.NET Core Dość świeży dodatek, ASP.NET Core, jest podobny do ASP.NET, ale działa zarówno w .NET Framework, jak i .NET Core (dzięki czemu umożliwia obsługę wielu platform). ASP.NET Core ma lekką architekturę modułową, umożliwia samodzielne hostowanie we własnym procesie oraz jest dostępny na licencji open source. W odróżnieniu od poprzedników ASP.NET Core nie zależy od System.Web ani historycznego bagażu Web Forms. Najlepiej sprawdza się w mikrousługach i wdrożeniach w kontenerach. 222 (cid:95) Rozdział 5. Ogólny zarys platformy Poleć książkęKup książkę Windows Presentation Foundation (WPF) System WPF został wprowadzony w .NET 3 jako technologia do tworzenia aplikacji z bogatym interfejsem użytkownika. Zalety WPF w stosunku do poprzedniego systemu, Windows Forms, są następujące: (cid:120) Obsługa zaawansowanych operacji graficznych, takich jak: przekształcenia dowolnego rodzaju, renderowanie grafik trójwymiarowych, multimedia oraz prawdziwa przezroczystość. Skinning jest obsługiwany poprzez szablony i style. (cid:120) Podstawowa jednostka miary nie jest oparta na pikselu, więc aplikacje wyglądają prawidłowo przy każdych ustawieniach DPI (liczba punktów na cal). (cid:120) Dobra obsługa układów dynamicznych, dzięki czemu można dokonywać lokalizacji programów bez obawy, że elementy zaczną na siebie nachodzić. (cid:120) Szybkie renderowanie przy użyciu DirectX z wykorzystaniem akceleracji sprzętowej. (cid:120) Niezawodne wiązanie danych. (cid:120) Możliwość deklarowania interfejsu użytkownika aplikacji w plikach XAML, które mogą być przechowywane i modyfikowane niezależnie od „obsługującego je kodu” — w ten sposób lepiej oddziela się warstwę prezentacyjną od logiki. Jednak rozmiar i złożoność WPF sprawiają, że nauka posługiwania się tym systemem jest dość trudna. Typy do pisania aplikacji WPF znajdują się w przestrzeni nazw System.Windows i wszystkich jej przestrzeniach podrzędnych z wyjątkiem System.Windows.Forms. Windows Forms Windows Forms to interfejs API do tworzenia aplikacji „bogatych”. Jest tak stary jak sama platforma .NET Framework. W porównaniu z WPF Windows Forms jest dość prostą technologią zapewniającą większość funkcji potrzebnych do napisania typowej aplikacji dla systemu Windows. Ponadto jest potrzebny przy obsłudze serwisowej starych aplikacji. Ma jednak kilka wad w porównaniu z WPF: (cid:120) Położenie i rozmiar kontrolek są ustalane w pikselach, przez co aplikacja może źle wyglądać w urządzeniu mającym ekran o innych ustawieniach DPI niż ekran programisty (chociaż trochę to poprawiono we Framework 4.7). (cid:120) Do rysowania niestandardowych kontrolek wykorzystywana jest biblioteka GDI+, która wprawdzie jest całkiem elastyczna, ale powoli renderuje duże obszary (a bez podwójnego bufo- rowania może powodować miganie). (cid:120) Kontrolki są pozbawione prawdziwej przezroczystości. (cid:120) Dla większości kontrolek nie ma możliwości komponowania z innymi kontrolkami. Na przy- kład nie można umieścić kontrolki obrazu w kontrolce karty. Modyfikowanie widoków list i pól kombi jest czasochłonne i żmudne. (cid:120) Trudno jest stworzyć niezawodny układ dynamiczny. Technologie praktyczne (cid:95) 223 Poleć książkęKup książkę Ostatni punkt jest doskonałym argumentem przemawiającym na korzyść WPF, nawet jeśli ktoś pi- sze aplikację biznesową, w której potrzebny jest tylko interfejs użytkownika, bez zważania na kwe- stie „wrażeń estetycznych użytkownika”. Elementy układowe WPF, np. Grid, umożliwiają takie rozmieszczenie etykiet i pól tekstowych, że zawsze znajdują się w odpowiednim miejscu — nawet po zamianie języka — i aby to osiągnąć, nie trzeba się posługiwać skomplikowaną logiką i nie wy- stępuje żadne miganie. Ponadto nie trzeba sprowadzać projektu interfejsu do najniższego wspólnego mianownika pod względem rozdzielczości ekranu — elementy układu WPF od początku projekto- wano z myślą o dostosowywaniu rozmiaru do zmiennych warunków. Jeśli chodzi o zalety Windows Forms, to technologia ta jest względnie łatwa do nauki i wciąż po- wszechnie wykorzystuje się ją w kontrolkach różnych producentów. Typy Windows Forms znajdują się w przestrzeniach nazw System.Windows.Forms (w zestawie System.Windows.Forms.dll) i System.Drawing (w zestawie System.Drawing.dll). Druga z wymienionych przestrzeni zawiera też typy GDI+ do rysowania niestandardowych kontrolek. Xamarin Xamarin, już w posiadaniu Microsoftu, służy do pisania aplikacji mobilnych w języku C# prze- znaczonych dla systemów iOS, Android i Windows Phone. Jest to wieloplatformowe rozwiązanie, które nie działa na bazie .NET Framework, lecz na bazie własnego środowiska (pochodnego plat- formy open source Mono). Więcej informacji znajduje się na stronie https://www.xamarin.com. UWP (Universal Windows Platform) UWP służy do pisania klasycznych aplikacji dla systemu Windows 10 i dla wyposażonych w ten system urządzeń aplikacji dystrybuowanych za pośrednictwem Windows Store. Ten bogaty API klienta jest przeznaczony do pisania interfejsów dotykowych. Powstał na podstawie inspiracji technologią WPF i do definiowania układu wykorzystuje XAML. Jego przestrzenie nazw to Windows.UI i Windows.UI.Xaml. Silverlight Silverlight także jest odrębną technologią od .NET Framework. Służy do pisania graficznych in- terfejsów użytkownika działających w przeglądarce internetowej, podobnie jak Adobe Flash. Ro- snąca popularność HTML5 skłoniła firmę Microsoft do porzucenia projektu Silverlight. Technologie zapleczowe ADO.NET ADO.NET to zarządzany interfejs API dostępu do danych. Choć część jego nazwy pochodzi jeszcze z lat 90. (ang. ActiveX Data Objects — ADO), technologia ta jest już zupełnie inna. ADO.NET składa się z dwóch niskopoziomowych elementów: Warstwa dostawcza Model dostawcy definiuje wspólne klasy i interfejsy zapewniające niskopoziomowy dostęp do dostawców baz danych. Interfejsy te zawierają: połączenia, polecenia, adaptery i czytniki (kursory jednokierunkowe i tylko do odczytu baz danych). Platforma .NET Framework standardowo obsługuje Microsoft SQL Server i sterowniki do licznych baz danych innych producentów. 224 (cid:95) Rozdział 5. Ogólny zarys platformy Poleć książkęKup książkę Model DataSet DataSet to strukturalny bufor danych. Przypomina prymitywną przechowywaną w pamięci bazę danych, która definiuje takie konstrukcje SQL, jak: tabele, wiersze, kolumny, relacje, ograniczenia i widoki. Wykorzystując w programie taki bufor, można zredukować liczbę odwołań do serwera baz danych, zapewniając tym samym lepszą skalowalność i krótszy czas reakcji interfejsu użyt- kownika. Zbiory danych DataSet można serializować oraz przesyłać przez sieć między klientem a aplikacjami serwerowymi. Nad warstwą dostawczą znajdują się trzy interfejsy API umożliwiające wysyłanie do baz danych zapy- tań LINQ: (cid:120) Entity Framework (tylko .NET Framework). (cid:120) Entity Framework Core (.NET Framework i .NET Core). (cid:120) LINQ to SQL (tylko .NET Framework). Wszystkie te trzy technologie zawierają mapery ORM (ang. object-relational mapper), a więc auto- matycznie mapują obiekty (na podstawie zdefiniowanych przez programistę klas) na wiersze bazy danych. Pozwala to na przeszukiwanie tych obiektów za pomocą zapytań LINQ (nie trzeba pisać in- strukcji SQL select) oraz modyfikowanie ich bez potrzeby pisania instrukcji SQL insert, delete czy update. Przyczynia się to do zmniejszenia objętości kodu źródłowego w warstwie dostępu do da- nych (zwłaszcza eliminowany jest kod „wypełniający”) oraz zapewnia wysoki poziom bezpieczeń- stwa statycznego typów. Dodatkowo technologie te eliminują konieczność używania obiektów DataSet jako odbiorników danych, chociaż te bufory zapewniają możliwość przechowywania i se- rializacji zmian stanu (coś, co jest bardzo ważne w aplikacjach wielowarstwowych). Technologii Entity Framework i LINQ to SQL można używać w połączeniu z obiektami DataSet, choć nie jest to może najwygodniejsze rozwiązanie, nie mówiąc już o tym, że obiekty DataSet z natury są dość niepo- ręczne. Innymi słowy: jak na razie w ofercie Microsoftu z zakresu ORM brak prostych gotowych rozwiązań do pisania aplikacji wielowarstwowych. Technologia LINQ to SQL jest prostsza niż Entity Framework i od dawna wiadomo, że dostarcza lepszej jakości kod SQL (choć Entity Framework też znacznie poprawiono dzięki licznym aktualiza- cjom). Z kolei interfejs Entity Framework jest elastyczniejszy, ponieważ umożliwia przeprowadzanie wyrafinowanych mapowań między bazą danych a odpytywanymi klasami (Entity Data Model) i udostępnia model zapewniający możliwość obsługi innych baz danych niż SQL Server. Entity Framework Core (EF Core) to Entity Framework z uproszczoną budową inspirowaną LINQ to SQL. Porzucono w nim skomplikowany Entity Data Model i może działać zarówno w .NET Framework, jak i .NET Core. .NET Standard 2.0 zawiera wspólne interfejsy w warstwie dostawcy, jak również DataSets, ale jest pozbawiony typów specyficznych dla SQL Server i maperów obiektowo-relacyjnych. Technologie praktyczne (cid:95) 225 Poleć książkęKup książkę Windows Workflow (tylko .NET Framework) Windows Workflow to system szkieletowy do modelowania i obsługi potencjalnie długotrwałych procesów biznesowych. Wykorzystuje standardową bibliotekę wykonawczą, więc nie ma obaw o spój- ność i współpracę z innymi rozwiązaniami. Ponadto system ten pozwala zredukować objętość źródłową dynamicznie kontrolowanych drzew decyzyjnych. Windows Workflow nie jest, ściśle rzecz biorąc, technologią zapleczową, ponieważ systemu tego można używać wszędzie (np. do definiowania przepływu stron w interfejsie użytkownika). Technologia ta została dodana w .NET Framework 3.0, a jej typy przypisano do przestrzeni nazw System.WorkFlow. W .NET Framework 4.0 Windows Workflow poddano gruntownym zmianom. Nowe typy znajdują się w przestrzeni nazw System.Activities. COM+ i MSMQ (tylko .NET Framework) Platforma .NET Framework może współpracować z technologią COM+ w zakresie takich usług, jak obsługa transakcji rozproszonych, za pośrednictwem typów znajdujących się w przestrzeni nazw System.EnterpriseServices. Dodatkowo obsługuje też technologię MSMQ (ang. Microsoft Message Queuing) do asynchronicznego jednokierunkowego przesyłania wiadomości za pomocą typów z prze- strzeni nazw System.Messaging. Technologie systemów rozproszonych Windows Communication Foundation (WCF) WCF to zaawansowana infrastruktura komunikacyjna, którą wprowadzono w .NET Framework 3.0. Jest tak elastyczna i zapewnia tyle możliwości konfiguracji, że przez nią starsze technologie — Remoting i (.ASMX) Web Services — stały się w znacznej części niepotrzebne. Technologie WCF, Remoting i Web Services łączy to, że wszystkie implementują następujący pod- stawowy model komunikacji klienta z aplikacją serwerową: (cid:120) Na serwerze należy określić, które metody mają być dostępne do zdalnego wywoływania przez aplikacje klienckie. (cid:120) Na kliencie należy określić lub wydedukować sygnatury metod serwerowych, które mają być wywoływane. (cid:120) Zarówno na serwerze, jak i na kliencie wybiera się protokół przesyłania i komunikacji (w WCF dokonuje się tego przez wiązanie). (cid:120) Klient ustanawia połączenie z serwerem. (cid:120) Klient wywołuje zdalną metodę, która zostaje wykonana na serwerze. Dzięki kontraktom usługowym i dotyczącym danych WCF jeszcze skuteczniej likwiduje zależność klienta od serwera. Zasadniczo współpraca przebiega w ten sposób, że klient wysyła wiadomość (w formacie XML lub binarnym) do odbiorcy w usłudze zdalnej, a nie bezpośrednio wywołuje zdalną metodę. Jedną z zalet takiego rozdziału jest to, że klienci nie są w żaden sposób uzależnieni od platformy .NET ani żadnego należącego do jakiejś firmy protokołu komunikacyjnego. 226 (cid:95) Rozdział 5. Ogólny zarys platformy Poleć książkęKup książkę Możliwości konfiguracji WCF są bardzo szerokie. Prócz tego można korzystać z bardzo dobrej obsługi standardowych protokołów przesyłania wiadomości opartych na SOAP, w tym WS-*. Dzięki temu można się komunikować z jednostkami wykorzystującymi różne rodzaje oprogra- mowania — działającego na rozmaitych platformach — i jednocześnie nadal korzystać z zaawan- sowanych funkcji, takich jak szyfrowanie. Z drugiej strony, praktyczność tego rozwiązania ograni- cza poziom złożoności protokołów i dlatego aktualnie najlepszym wyjściem w zakresie przesyłania wiadomości między niekompatybilnymi systemami jest skorzystanie z technologii REST i HTTP, które Microsoft obsługuje poprzez warstwę Web API na ASP.NET. Natomiast do komunikacji między aplikacjami .NET w WCF zapewniono bogatszy wybór funkcji serializacji i innych narzędzi niż dla API REST. Ponadto procesy te powinny przebiegać szybciej, ponieważ pomijają HTTP i mogą wykorzystywać serializację binarną. Typy do komunikacji z WCF znajdują się w przestrzeni nazw System.ServiceModel i przestrzeniach podrzędnych. Web API Web API działa na bazie ASP.NET/ASP.NET Core i pod względem architektury przypomina API MVC Microsoftu, z tym że służy do udostępniania usług i danych, a nie stron internetowych. Jego zaletą w porównaniu z WCF jest to, że pozwala na stosowanie popularnych technik REST-owych z wykorzystaniem HTTP, co zapewnia lepszą współpracę z szerszym spektrum platform. Implementacje REST są prostsze niż protokoły SOAP i WS-, które WCF wykorzystuje do współpra- cy międzyplatformowej. Ponadto REST-owe interfejsy API mają elegantszą architekturę do pracy z luźno powiązanymi systemami, de facto bazują na standardach oraz doskonale wykorzystują możliwości protokołu HTTP. Remoting i .ASMX Web Services (tylko .NET Framework) Remoting i .ASMX Web Services to poprzednicy WCF. Wraz z pojawieniem się WCF technolo- gia Remoting prawie przestała być potrzebna, a technologia .ASMX Web Services całkiem straciła rację bytu. Technologia Remoting zachowała użyteczność w dziedzinie komunikacji między domenami aplikacji w obrębie tego samego procesu (rozdział 24.). Jest przeznaczona do pracy ze ściśle powiązanymi aplikacjami, więc typowym przykładem jej użycia jest aplikacja i serwer napisane w technologii .NET przez jedną firmę (albo różne firmy posługujące się tymi samymi zestawami). Komunikacja z reguły polega na wymianie potencjalnie złożonych niestandardowych obiektów .NET, które są następnie serializowane i deserializowane przez Remoting bez jakiejkolwiek zewnętrznej pomocy. Typy technologii Remoting znajdują się w przestrzeni nazw System.Runtime.Remoting i przestrze- niach podrzędnych. Typy Web Services znajdują się pod przestrzenią nazw System.Web.Services. Technologie praktyczne (cid:95) 227 Poleć książkęKup książkę 228 (cid:95) Rozdział 5. Ogólny zarys platformy Poleć książkęKup książkę Skorowidz aplikacje UWP, 635 Windows Store, 757 architektura domeny aplikacji, 921 Roslyn, 976 sieci, 643 strumienia, 599, 600 archiwum ZIP, 624 argument NumberStyles, 263 argumenty, 30 nazwane, 66, 949 asercja, 523, 961 o zerowej długości, 972 asocjacje, 383 ASP.NET, 222 ASP.NET Core, 222 asynchroniczne wyrażenia lambda, 581 asynchroniczność, 219, 539, 586 asynchroniczny odczyt, 602 atak słownikowy, 830 atomowość, 844 atrapy, 655 atrybut, 188, 220, 775 [Conditional], 521, 522 [NonSerialized], 702 [OnDeserialized], 703 [OnDeserializing], 703 [OnSerialized], 704 [OnSerializing], 704 [OptionalField], 704 [Serializable], 699, 701 [ThreadStatic], 871 [XmlArrayItem], 715 AttributeUsage, 777 .ASMX Web Services, 227 .NET Framework, 18 .NET Framework 4.6, 214 .NET Framework 4.7, 215 .NET Standard 2.0, 215 A abstrakcyjne klasy, 109 adapter StringReader, 620 StringWriter, 620 strumienia, 614 adaptery binarne, 620 tekstowe, 615 adnotacje, 466 ADO.NET, 224 adresy, 646 URI, 647, 652 agregacje bez ziarna, 435 akcesory widoku, 640 aktualizacje, 387 aktywacja typów, 756 algorytm porównywania kulturowego, 235 porządkowego, 235 aliasy typów, 86 analiza działających procesów, 528 wątków w procesie, 528 anonimowe wywoływanie składowych, 772, 813 anulowanie zadań, 904 API, 389 API interfejsu użytkownika, 221 1003 Poleć książkęKup książkę atrybut Flags, 126 LoaderOptimization, 925 StructLayout, 938 atrybuty cele, 190 debuggera, 527 definiowanie, 778 informacji wywołującego, 190 klasy, 189 nazwane, 189 pobieranie w czasie działania, 779 pobieranie w kontekście refleksji, 780 pozycyjne, 189 pseudoniestandardowe, 777 przypisywanie, 795 serializacji binarnej, 702 warunkowe, 207 zestawu, 721 automatyczne usuwanie nieużytków, 499 autonomiczne zadania, 560 B bariera pamięci, 844 wątku wykonawczego, 867 bezpieczeństwo, 220, 821 deklaratywne, 823 imperatywne, 823 pliku, 628 typów, 16, 127 wątków, 546, 605, 848, 849 przy odczycie, 851 w serwerach aplikacji, 852 białe znaki, 985 biblioteki DLL, 935 PFX, 880, 882 Roslyn, 975 BitTorrent, 673 blok finally, 166 instrukcji, 73 kodu, 30 blokady, 843, 848 odczytu, 855 z możliwością uaktualnienia, 857 zapisu, 855 1004 (cid:95) Skorowidz bloki try-catch-finally, 174 blokowanie, 844 bez wykluczania, 840, 854 wykluczające, 840 błędy parsowania, 265 zaokrąglania liczb, 49 buforowanie, 516 w miejscu wykonania, 808 bufory, 205 C C# 2.0, 28 C# 3.0, 27 C# 4.0, 26 C# 5.0, 26 C# 6.0, 25 C# 7.0, 22 CA, certificate authority, 731 CAS, Code Access Security, 821 cele delegatów, 146 emisji, 798 certyfikat, 731 do podpisywania kodu, 732 ciąg tekstowy zapytania, 662 CLR, Common Language Runtime, 17, 28, 41, 213, 217 COM, 27, 221, 935, 946 COM+, 226 COM-callable wrapper, 953 cookies, 664 cykl życiowy obiektu, 499 czas letni, 253 D dane, 36 formularza, 663 hierarchiczne, 484 data i godzina, 242 deasembler, 801 debugger, 526 debugowanie, 523 definiowanie metod generycznych, 796 przestrzeni nazw, 463 równości, 285 Poleć książkęKup książkę typów, 35 typów generycznych, 797 własnych atrybutów, 778 deklarowanie, 458 kowariantnego parametru typu, 139 parametrów typów, 133 XML, 460 wielu pól, 90 dekonstruktory, 23, 93 dekonstruowanie krotek, 187 dekrementacja, 46 delegat, 143, 148, 390, 770 Action, 147 Func, 147 MatchEvaluator, 966 delegaty asynchroniczne, 595 multiemisji, 145 deserializacja, 697 deserializer, 702 diagnostyka, 218, 519, 993 diagnozowanie wycieku pamięci, 514 DLR, dynamic language runtime, 807 DNS, Domain Name Service, 645, 672, 680 dokumentacja XML, 208 dokumenty, 458 dołączanie debuggera, 527 protokołów równości, 336 DOM, 391, 441 domeny aplikacji, 221, 921 architektura, 921 dzielenie danych, 929 likwidowanie, 923 monitorowanie, 927 tworzenie, 923 wątki, 927 zastosowanie, 924 domknięcie, 159 domyślna wartość generyczna, 134 dostawcy formatu, 255, 256 dostęp do składowych niepublicznych, 770 drobiazgi, 985 strukturalne, 986 drzewo obiektów, 681 składni Roslyn, 977 przeszukiwanie, 981 transformacja, 987 tworzenie, 980 węzły, 979 wyszukiwanie elementu, 983 wyrażeń, 28, 158, 370, 390 wywołań, 567 wywołań asynchronicznych, 579 X-DOM, 445 dynamiczne dynamiczny wybieranie przeciążonych składowych, 810 wywoływanie składowej, 768 odbiorca, 197 system wykonawczy języka, 807 dyrektywa fixed, 943 using, 83, 86 using static, 84 dyrektywy preprocesora, 206, 520, 985 dziedziczenie, 104, 111 dzielenie całkowitoliczbowe, 46 danych, 929 na części, 892 przy użyciu skrótów, 891 zakresowe, 892 dziennik zdarzeń, 530 monitorowanie, 532 odczyt danych, 532 zapis danych, 531 E EAP, Event-based Asynchronous Pattern, 595 egzemplarze, 36 kontekstu typizowanego, 379 nasłuchujące, 526 typów referencyjnych, 59 element główny, 500 elementy, 343 opcjonalne, 478 podklas kolekcji, 696, 716 puste, 478 składowe klasy Assembly, 724 Stream, 601 TextReader, 616 TextWriter, 616 emisja podzespołu, 993 Skorowidz (cid:95) 1005 Poleć książkęKup książkę emitowanie generycznych typów i klas, 796 konstruktorów, 794 metod, 791 pól i właściwości, 793 składowych typów, 791 typów, 787 zestawów, 787 Entity Framework, 376 enumerator, 171 ewaluacja, 782 F fabryka abstrakcyjna, 910 zadań, 910 filtr, 385 filtrowanie, 399 z indeksowaniem, 400 filtry wyjątków, 26, 165 finalizatory, 31, 102, 501, 505 flagi parsowania, 260 forma base64, 269 XML, 218 formater SoapFormatter, 701 formatery, 684 binarne, 688 formatowanie, 255 złożone, 258 formularze, 663 FTP, File Transfer Protocol, 645, 670 funkcje, 36 asynchroniczne, 26, 570 fabryczne ziaren, 893 klasy FileStream, 609 operatorowe, 200 pieczętowanie, 110 tworzenie, 577 wyrażeniowe, 25 G GAC, Global Assembly Cache, 734 garbage collection, 493 generacje na stercie, 508 generator list z list, 351 1006 (cid:95) Skorowidz generowanie dynamicznego kodu, 781 IL, 781 metod instancji, 792 zmiennych lokalnych, 784 generyczne typy delegacyjne, 147 globalizacja, 271 globalna przestrzeń nazw, 83 głębokie klonowanie, 447 główne moduły współpracujące, 952 grupowanie, 424 H hierarchia klas, 708 obiektów, 404 HTTP, Hypertext Transfer Protocol, 645, 661, 667 I identyfikatory, 32 implementacja indeksatorów, 99 interfejsu, 121 interfejsów przeliczeniowych, 301 obiektów dynamicznych, 816 własności, 99 zabezpieczeń, 824 indeksatory, 31, 99, 950 indeksowanie tablic, 310 inferencja typów literałów liczbowych, 43 informacje o postępie, 588 o woluminie, 634 inicjalizacja pól, 90 tablic, 57 inicjalizatory indeksów, 25 kolekcji, 172 obiektów, 27, 94, 368 własności, 98 inkrementacja, 46 instalacja certyfikatu, 731 instancje typów, 760 Poleć książkęKup książkę instrukcja, 29, 73 break, 81 continue, 81 fixed, 203 foreach, 172 goto, 77, 81 if, 75 if-else, 77 lock, 841 return, 82 switch, 76, 77 throw, 82 try, 163 using, 166 yield break, 174 instrukcje deklaracji, 73 iteracyjne, 79 skoku, 80 wyboru, 75 wyrażeniowe, 74 interfejs, 125 Close, 493 COM, 947 Dispose, 493 EqualityComparer, 337 ICollection, 304, 305 ICollection T , 305 IComparable, 290 ICustomFormatter, 259 IDictionary, 326 IDictionary TKey,TValue , 325 IDispatch, 948 IDisposable, 300, 493, 497 IEnumerable, 298 IEnumerable T , 299, 300 IEnumerator, 298 IEnumerator T , 299 IEqualityComparer, 337 IEquatable T , 284, 288 IFormatProvider, 259 IList, 304, 306 IList T , 306 IOrderedEnumerable, 423 IOrderedQueryable, 423 IProducerConsumerCollection T , 914 IProgress T , 589 IReadOnlyList T , 307 ISerializable, 701, 706 IStructuralComparable, 341 IStructuralEquatable, 341 ISymbol, 996 IUnknown, 948 IXmlSerializable, 684, 700, 716 interfejsy, 15, 120, 124, 148, 759 jawna implementacja, 121 niegeneryczne, 300 przeliczeniowe, 301 reimplementacja, 123 rozszerzanie, 121 wirtualna implementacja składowych, 122 internacjonalizacja aplikacji, 271 interoperacyjność, 700 macierzysta, 221 interpolacja łańcuchów, 25, 54 IP, Internet Protocol, 645, 680 iteratory, 172, 174, 301 izolowanie typów, 931 zestawów, 931 J jednolity system typów, 15 języki dynamiczne, 819 K katalog, 636 bazowy, 750 specjalny, 632 klasa, 15, 31, 89, 125 AggregateException, 910 AppContext, 295 Array, 308, 314 ArrayList, 316 Assembly, 723, 749 AssemblyName, 728 AutoResetEvent, 859 BackgroundWorker, 596 Barrier, 867 BinaryReader, 620 BinaryWriter, 620 BitArray, 322 BitConverter, 270 BlockingCollection T , 916 BufferedStream, 613 Collection T , 331 Skorowidz (cid:95) 1007 Poleć książkęKup książkę klasa CollectionBase, 331, 333 ConcurrentBag T , 915 Console, 293 Convert, 267 CountdownEvent, 863 CredentialCache, 659 CryptoStream, 832–834 CSharpSyntaxRewriter, 990 CSharpSyntaxWalker, 984 DataContext, 379, 381 DataLoadOptions, 385 DelegatingHandler, 656 Dictionary TKey,TValue , 326 DictionaryBase, 333 Directory, 629 DirectoryInfo, 630 Dns, 672 DynamicMethod, 781 DynamicObject, 816 Encoding, 240, 241 Enumerable, 407, 420 Environment, 294 EqualityComparer, 337 EventWaitHandle, 864 ExpandoObject, 818 File, 607, 626 FileInfo, 630 FileStream, 606, 609 FileSystemWatcher, 634 HashSet T , 322 Hashtable, 326 HttpClient, 652, 653, 662 HttpClient, 649 HttpMessageHandler, 655 HybridDictionary, 328 KeyedCollection TKey,TItem , 333 Lazy T , 869 LazyInitializer, 870 LinkedList T , 318 List T , 316 ListDictionary, 328 ManualResetEvent, 862 Math, 273 MemberInfo, 764 MemoryStream, 609 MessageBox, 935 Monitor, 842 Mutex, 847 1008 (cid:95) Skorowidz NetDataContractSerializer, 691 Object, 117 ObjectContext, 379, 381 OrderedDictionary, 328 Parallel, 880, 895 ParallelLoopState, 898 Path, 630 PipeStream, 610 Process, 294 Queue T , 320 Random, 275 ReadOnlyCollection T , 335 RSA, 836 SortedSet T , 322 Stack T , 321 StackFrame, 529 StackTrace, 529 Stopwatch, 538 StorageFolder, 636 Stream, 601 Stream
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

C# 7.0 w pigułce. Wydanie VII
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ą: