Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00435 007307 13441032 na godz. na dobę w sumie
Tajniki C# i .NET Framework - ebook/pdf
Tajniki C# i .NET Framework - ebook/pdf
Autor: Liczba stron:
Wydawca: Promise Język publikacji: polski
ISBN: 978-83-7541-355-7 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie
Porównaj ceny (książka, ebook, audiobook).

Książka Tajniki C# i .NET Framework szczegółowo przedstawia zagadnienia związane z językiem C# 6.0/7.0 oraz platformą .NET 4.6 pozwalając zrozumieć, jak działa ta platforma podczas wykonywania kodu i jak wykorzystać tę wiedzę do pisania wydajnych aplikacji. Pozwala w pełni spożytkować nową rewolucję w programowaniu .NET, w tym otwarty kod źródłowy platformy, możliwości wieloplatformowe i zmiany architektoniczne w CoreCLR.
Zaczniemy od omówienia, w jaki sposób CLR wykonuje kod oraz odkryjemy niszowe i zaawansowane aspekty programowania w języku C# - od delegatów i typów ogólnych aż do programowania asynchronicznego. Poznamy nowe formy deklarowania typów i przypisań, wywoływanie kodu źródłowego, składnię statycznych deklaracji using, automatyczne inicjowanie właściwości, inicjowanie słowników, operatory warunkowe dla wartości null i wiele innych zagadnień. Następnie odblokujemy prawdziwy potencjał platformy .NET. Dowiemy się, jak pisać aplikacje zgodne z OWASP, jak prawidłowo implementować wzorce projektowe w C# oraz jak stosować ogólne zasady SOLID i ich implementacje w kodzie C#.
Zakończymy na wskazówkach pomagających maksymalnie wykorzystać język C# i platformę .NET.
W ostatnim rozdziale książki omówimy też kwestie związane z platformą .NET Core 1.1.
Dzięki tej książce można:
Dokładnie zrozumieć podstawowe pojęcia języka C# od algorytmów sortujących do notacji dużego O.
Poznać najnowsze zmiany w języku C# 6/7.
Łączyć bazy danych SQL Server i NoSQL z platformą .NET.
Zrozumieć zasady SOLID i najistotniejsze wzorce Gang of Four na praktycznych przykładach w języku C# 6.0.
Dowiedzieć się, jak bronić aplikacje w języku C# przed atakami.
Korzystać z platformy Roslyn do kompilowania i manipulowania językami C# oraz Visual Basic .NET.
Rozróżniać zapytania LINQ i związane z nimi wyrażenia Lambda, typy ogólne oraz delegaty.
Zaprojektować od podstaw nową aplikację w .NET.
Zrozumieć wewnętrzną strukturę podzespołu .NET.
Poznać przydatne i zaawansowane funkcje związane z optymalizacją i programowaniem równoległym.

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

Darmowy fragment publikacji:

Marino Posadas Tajniki C# i .NET Framework Wydajne aplikacje dzięki zaawansowanym funkcjom języka C# i architektury .NET ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Tajniki C# i .NET Framework Buduj wydajne aplikacje dzięki zaawansowanym funkcjom języka C# i architektury .NET. Marino Posadas Przekład: Jakub Niedźwiedź APN Promise Warszawa 2017 ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Tajniki C# i .NET Framework Original English language edition © 2016 Packt Publishing All rights reserved. Authorised translation from the English language edition book Mastering C# and .NET Framework, ISBN 978-1-78588-437-5 , published by Packt Publishing. © Polish edition by APN PROMISE SA, Warszawa 2017 APN PROMISE SA, ul. Domaniewska 44a, 02-672 Warszawa tel. +48 22 35 51 600, fax +48 22 35 51 699 e-mail: mspress@promise.pl Wszystkie prawa zastrzeżone. Żadna część niniejszej książki nie może być powielana ani rozpowszechniana w jakiejkolwiek formie i w jakikolwiek sposób (elektroniczny, mechaniczny), włącznie z fotokopiowaniem, nagrywaniem na taśmy lub przy użyciu innych systemów bez pisemnej zgody wydawcy. Książka ta przedstawia poglądy i opinie autorów. Przykłady fi rm, produktów, osób i wydarzeń opisane w niniejszej książce są fi kcyjne i nie odnoszą się do żadnych konkretnych fi rm, produktów, osób i wydarzeń, chyba że zostanie jednoznacznie stwierdzone, że jest inaczej. Ewentualne podobieństwo do jakiejkolwiek rzeczywistej fi rmy, organizacji, produktu, nazwy domeny, adresu poczty elektronicznej, logo, osoby, miejsca lub zdarzenia jest przypadkowe i niezamierzone. Wszystkie nazwy handlowe i towarowe występujące w niniejszej publikacji mogą być znakami towarowymi zastrzeżonymi lub nazwami zastrzeżonymi odpowiednich fi rm odnośnych właścicieli. APN PROMISE SA dołożyła wszelkich starań, aby zapewnić najwyższą jakość tej publikacji. Jednakże nikomu nie udziela się rękojmi ani gwarancji. APN PROMISE SA nie jest w żadnym wypadku odpowiedzialna za jakiekolwiek szkody będące następstwem korzystania z informacji zawartych w niniejszej publikacji, nawet jeśli APN PROMISE została powiadomiona o możliwości wystąpienia szkód. ISBN: 978-83-7541-334-2 Przekład: Jakub Niedźwiedź Redakcja: Marek Włodarz Korekta: Ewa Swędrowska Skład i łamanie: MAWART Marek Włodarz ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Zespół Koordynator projektu Izzat Contractor Korektor Safi s Editing Opracowanie indeksu Rekha Nair Grafi ka Disha Haria Koordynator produkcji Aparna Bhagat Projekt okładki Aparna Bhagat Autor Marino Posadas Recenzent Fabio Claudio Ferracchiati Redaktor prowadzący Edward Gordon Redaktor ds. zakupów Denim Pinto Redaktor treści Priyanka Mehta Redaktor techniczny Dhiraj Chandanshive Redaktor tekstu Stuti Srivastava O autorze Marino Posadas jest niezależnym szkoleniowcem, pisarzem i konsultantem w dzie- dzinie technologii Microsoft oraz standardów WWW. Może poszczycić się tytułem Microsoft MVP w dziedzinie C#, Visual Studio i technologii programistycznych oraz posiada certyfi katy MCT, MAP (2013), MCPD, MCTS, MCAD, MCSD i MCP. Ponadto był dyrektorem rozwoju w fi rmie Solid Quality Mentors w Hiszpanii i Portugalii. Opublikował 14 książek i ponad 500 artykułów na temat technologii programistycz- nych w kilku czasopismach. W swoich książkach zajmował się różnymi tematami od języków Clipper i Visual Basic 5.0/6.0, aż po C#, bezpieczne programowanie w .NET, Silverlight 2.0 i 4.0 oraz standardy WWW. Jego poprzednią książką był Przewodnik po programowaniu w HTML5, CSS3 i JavaScript przy pomocy Visual Studio. Bywa też prelegentem na konferencjach Microsoft w Hiszpanii, Portugalii, Anglii, Stanach Zjednoczonych, Kostaryce i Meksyku. Można go znaleźć w serwisie LinkedIn pod adresem https://es.linkedin.com/in/ mposadas. Jego serwis WWW http//elavefenix.net zawiera też fi lmy i inne zasoby dla progra- mistów w języku angielskim i hiszpańskim, w tym wywiady z przedstawicielami Microsoft i środowiska programistów WWW. ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Podziękowania Chciałbym podziękować pracownikom Packt Publishing: Denim Pinto, Priyanka Mehta i Fabio Claudio Ferracchiati za ciągłe wsparcie i wiarę we mnie podczas pisa- nia tej książki. Specjalne podziękowania dla profesjonalistów i propagatorów technologii, których praca zainspirowała różne części tej książki. W szczególności chciałbym wyróżnić następujące osoby: Mark Russinowich, Scott Hanselman, Scott Hunter, Daniel Roth, Lluis Franco, Luis Ruiz Pavón, Dino Esposito, Miguel Katrib, James Gray, Paul Cotton, Stephen Toub i Troy Hunt. Chciałbym też pamiętać o zajmującej się programem MVP w Hiszpanii Cristinie González Herrero za jej ciągłe wsparcie i pomoc oraz o innych osobach z Microsoft, które zawsze wspierały moje działania. Obejmuję tutaj pamięcią następujące osoby: Alfonso Rodríguez, David Carmona, David Salgado, José Bonnín, César de la Torre, Andy Gonzalez i Leon Welicki. Chciałbym też docenić swoich kolegów z Netmind: Alex i Bernat Palau, Miquel Rodriguez, Israel Zorrilla oraz Angel Rayo – za ich wsparcie dla tej inicjatywy od samego początku. O recenzencie Fabio Claudio Ferracchiati jest starszym konsultantem i starszym analitykiem/ programistą wykorzystującym technologie Microsoft. Pracuje dla React Consulting (www.reactconsulting.it) jako architekt rozwiązań Microsoft Dynamics 365. Posiada tytuły Microsoft Certifi ed Solution Developer for .NET, Microsoft Certifi ed Application Developer for .NET, Microsoft Certifi ed Professional i jest autorem licznych publika- cji oraz recenzji technicznych. W ciągu ostatnich 10 lat napisał wiele artykułów dla włoskich i międzynarodowych czasopism oraz był współautorem ponad 10 książek na różne tematy komputerowe. ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Dedykuję tę książkę mojej żonie Milagros i mojej rodzinie, ze szczególnym uwzględnieniem moich bratanków, siostrzeńców, bratanic i siostrzenic: Fernando, Sarah, Ana, Paula, Pablo, Javier, Adrian, Irene, Luis i Juan. ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Spis treści Wstęp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xvii Rozdział 1: Wewnątrz CLR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 Uwagi dotyczące kilku ważnych pojęć komputerowych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 Kontekst . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 Model wykonywania wielu zadań w systemie operacyjnym . . . . . . . . . . . . . . . . . . . . 2 Typy kontekstu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 Bezpieczeństwo wątków . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 Stan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 Stan programu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 Serializacja . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 Proces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 Wątek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 SysInternals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 Pamięć statyczna i dynamiczna . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 Odśmiecanie pamięci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 Przetwarzanie współbieżne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 Przetwarzanie równoległe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 Programowanie imperatywne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 Programowanie deklaratywne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 Ewolucja .NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 .NET jako reakcja na świat języka Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 Ruch otwartego oprogramowania i .NET Core . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 Common Language Runtime . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 Common Intermediate Language . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 Zarządzane wykonywanie kodu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 Składniki i języki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 Struktura pliku podzespołu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 Metadane . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 Wprowadzenie do metadanych przy pomocy podstawowego programu Hello World . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 PreJIT, JIT, EconoJIT i RyuJIT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== viii Spis treści Wspólny system typów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 Szybka wskazówka dotycząca analizy wykonywania i pamięci dla podzespołu w Visual Studio 2015 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 Stos i sterta . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 Odśmiecanie pamięci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 Implementowanie algorytmów w CLR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 Struktury danych, algorytmy i złożoność . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 Notacja wielkiego O . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 Istotne funkcje pojawiające się w wersjach 4.5x, 4.6 oraz .NET Core 1.0 i 1.1 . . . . 47 .NET 4.5.x . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 .NET 4.6 (wraz z Visual Studio 2015) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48 .NET Core 1.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 .NET Core 1.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 Podsumowanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 Rozdział 2: Najważniejsze pojęcia języka C# i platformy .NET . . . . . . . . . . . . . . . . 51 C# – co jest innego w tym języku? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52 Języki: silnie typowane, słabo typowane, dynamiczne i statyczne . . . . . . . . . . . . . . . . . . . 53 Główne różnice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54 Prawdziwy powód dla stworzenia delegatów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57 Ewolucja w wersjach 2.0 i 3.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 Typy ogólne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 Tworzenie niestandardowych typów i metod ogólnych . . . . . . . . . . . . . . . . . . . . 63 Wyrażenia lambda i typy anonimowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68 Wyrażenia lambda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 Składnia LINQ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 Składnia LINQ jest oparta na języku SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73 Odroczone wykonywanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74 Łączenie i grupowanie kolekcji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74 Projekcje typów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76 Metody rozszerzeniowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77 Podsumowanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78 Rozdział 3: Zaawansowane pojęcia języka C# i platformy .NET . . . . . . . . . . . . . . . 79 C# 4 i .NET Framework 4.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 Kowariancja i kontrawariancja. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 Kowariancja w interfejsach . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82 Kowariancja w typach ogólnych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84 ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Spis treści ix Kowariancja w LINQ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85 Kontrawariancja . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86 Krotki: przypomnienie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 Krotki: implementacja w C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 Krotki: wsparcie dla równości strukturalnej . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 Krotki a typy anonimowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90 Leniwe inicjowanie i tworzenie wystąpień obiektów . . . . . . . . . . . . . . . . . . . . . . . . . . 92 Programowanie dynamiczne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95 Dynamiczne typowanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95 Obiekt ExpandoObject . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 Parametry opcjonalne i nazwane . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100 Obiekt Task i wywołania asynchroniczne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100 C# 5.0: deklaracje async/await . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 Co nowego w wersji C# 6.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104 Interpolacja łańcuchów tekstowych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 Filtry wyjątków . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 Operator nameof . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106 Operator warunkowy dla wartości null. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107 Automatyczne inicjowanie właściwości . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 Statyczne deklaracje using . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110 Metody z ciałem w postaci wyrażenia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111 Inicjowanie indeksów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112 Co nowego w wersji C# 7.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113 Literały binarne i separatory cyfr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113 Dopasowywanie do wzorca i instrukcje switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114 Krotki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116 Dekompozycja . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118 Funkcje lokalne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119 Zwracanie wartości typu ref . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119 Podsumowanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120 Rozdział 4: Porównanie różnych typów podejścia do programowania . . . . . . . 123 Języki funkcjonalne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124 F# 4 a platforma .NET Framework . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126 Nieodłączny program demonstracyjny Hello World . . . . . . . . . . . . . . . . . . . . . . . 127 Identyfi katory i zakres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129 Listy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130 Język TypeScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136 ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== x Spis treści Nowy JavaScript. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137 TypeScript: nadzbiór JavaScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139 Czym dokładnie jest TypeScript? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140 Główne funkcje i koalicje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140 Instalowanie narzędzi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141 Transpilacja do różnych wersji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143 Korzyści w zintegrowanym środowisku programistycznym . . . . . . . . . . . . . . . . 144 Uwaga na temat obiektowo zorientowanej składni języka TypeScript . . . . . . . . . 146 Więcej szczegółów i funkcjonalności . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147 Podsumowanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147 Rozdział 5: Mechanizm refl eksji i programowanie dynamiczne . . . . . . . . . . . . . 149 Refl eksja w .NET Framework . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150 Wywoływanie zewnętrznych podzespołów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155 Refl eksja dla typów ogólnych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157 Emitowanie kodu w trakcie działania programu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159 Przestrzeń nazw System.CodeDOM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159 Przestrzeń nazw Refl ection.Emit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162 Interoperacyjność . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163 Główne podzespoły Interop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165 Formatowanie komórek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169 Wstawianie multimediów do arkusza . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170 Interop w Microsoft Word . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175 Aplikacje dla pakietu Offi ce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180 Domyślny projekt aplikacji pakietu Offi ce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180 Różnice architektoniczne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183 Podsumowanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185 Rozdział 6: Programowanie baz danych SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187 Model relacyjny. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188 Właściwości tabel relacyjnych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188 Narzędzia – SQL Server 2014 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191 Język SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193 Korzystanie z SQL Server z poziomu Visual Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . 194 Dostęp do danych w Visual Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200 Dostęp do danych w .NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201 Korzystanie z podstawowych obiektów ADO.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203 Konfi gurowanie interfejsu użytkownika . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204 ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Spis treści xi Model danych Entity Framework . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205 Podsumowanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211 Rozdział 7: Programowanie baz danych NoSQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213 Krótki kontekst historyczny . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214 Świat NoSQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215 Zmiany architektoniczne względem systemów RDBMS . . . . . . . . . . . . . . . . . . . . . . 217 Zapytania do innych zapytań . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218 Problem nieznormalizowanych danych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218 Zagnieżdżanie danych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218 Operacje CRUD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219 MongoDB w systemie Windows. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221 Struktura plików i domyślna konfi guracja . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221 Kilka przydatnych poleceń . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223 Zmienianie danych – pozostałe operacje CRUD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227 Indeksy tekstowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228 MongoDB z poziomu Visual Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230 Pierwszy program demonstracyjny: proste zapytanie z Visual Studio . . . . . . . . . 230 Operacje CRUD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234 Usuwanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234 Wstawianie. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235 Modyfi kacje i zastąpienia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236 Podsumowanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237 Rozdział 8: Programowanie otwarte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239 Historyczne ruchy programowania otwartego . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240 Inne projekty i inicjatywy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240 Otwarty kod źródłowy dla programisty . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241 Inne języki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241 Projekt Roslyn . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245 Różnice w stosunku do tradycyjnych kompilatorów . . . . . . . . . . . . . . . . . . . . . . . . . 246 Rozpoczęcie pracy z Roslyn . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247 Pierwsze spojrzenie na Microsoft Code Analysis Services . . . . . . . . . . . . . . . . . . . . . 250 Analizatory kodu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250 Cały przykład otwartego oprogramowania: ScriptCS . . . . . . . . . . . . . . . . . . . . . . 251 Podstawowy projekt wykorzystujący Microsoft.CodeAnalysis . . . . . . . . . . . . . . 252 Pierwsze podejście do refaktoringu kodu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255 Debugowanie i testowanie programu demonstracyjnego . . . . . . . . . . . . . . . . . 260 ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== xii Spis treści TypeScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262 Debugowanie kodu TypeScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263 Debugowanie TypeScript przy pomocy Chrome . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264 Interfejsy i silne typowanie. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264 Implementowanie przestrzeni nazw . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265 Deklaracje, zakres i Intellisense . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266 Zakres i hermetyzacja . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267 Klasy i dziedziczenie klas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268 Funkcje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270 Tablice i interfejsy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274 Więcej języka TypeScript w działaniu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275 Połączenie z DOM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278 Podsumowanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280 Rozdział 9: Architektura . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281 Wybór architektury . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282 Platforma Microsoft . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282 Platforma uniwersalna . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283 Model aplikacji MSF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284 Model zespołu. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285 Model zarządzania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288 Model ryzyka . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290 Ocena ryzyka . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292 Szacowanie ryzyka . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292 Plany działań na wypadek ryzyka . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292 Narzędzia CASE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294 Rola Visio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295 Pierwszy przykład . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296 Projekt bazy danych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298 Tworzenie demonstracyjnej aplikacji w Visual Studio . . . . . . . . . . . . . . . . . . . . . . . . 300 Projektowanie serwisu WWW . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302 Raporty . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306 Wiele innych opcji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307 BPMN 2.0 (Business Process Model and Notation) . . . . . . . . . . . . . . . . . . . . . . . . . 308 Obsługa standardu UML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310 Narzędzia Visual Studio do planowania architektury, testowania i analizy . . . . . . . . . . 310 Architektura aplikacji w Visual Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310 Diagramy klas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313 ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Spis treści xiii Testowanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314 Testowanie naszej aplikacji w Visual Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314 Menu Analyze . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317 Koniec cyklu życia – publikowanie rozwiązania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317 Podsumowanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319 Rozdział 10: Wzorce projektowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321 Początki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322 Zasady SOLID . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322 Zasada pojedynczej odpowiedzialności . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324 Przykład . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 326 Zasada otwarte-zamknięte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330 Powrót do naszego przykładu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331 Zasada podstawienia Liskov . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333 Ponownie wracamy do kodu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334 Inne implementacje zasady podstawienia Liskov w .NET (typy ogólne) . . . . . . . 335 Zasada rozdzielenia interfejsów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338 Zasada odwrócenia zależności . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341 Końcowa wersja programu przykładowego . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341 Wzorce projektowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344 Singleton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347 Wzorzec fabryki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348 Wzorzec adaptera . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348 Wzorzec fasady . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351 Wzorzec dekoratora . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352 Wzorzec polecenia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352 Przykład implementacji obecnej już w .NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353 Wzorzec obserwatora . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354 Wzorzec strategii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356 Inne wzorce programowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356 Inne wzorce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359 Podsumowanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360 Rozdział 11: Bezpieczeństwo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361 Inicjatywa OWASP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362 Lista 10 największych zagrożeń według OWASP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362 A1 – Wstrzykiwanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366 Wstrzykiwanie kodu SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366 ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== xiv Spis treści Zapobieganie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367 Przypadek baz danych NoSQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369 A2 – Niewłaściwe uwierzytelnianie i zarządzanie sesją . . . . . . . . . . . . . . . . . . . . . . . . . . . . 370 Przyczyny . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371 Zapobieganie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372 Kodowanie w .NET w związku z A2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373 Aplikacje biurkowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373 Aplikacje WWW . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374 A3 – Cross-Site Scripting (XSS) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377 Zapobieganie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379 A4 – Niebezpieczne bezpośrednie odwołania do obiektów . . . . . . . . . . . . . . . . . . . . . . . . 379 Zapobieganie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381 A5 – Błędna konfi guracja zabezpieczeń . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382 Możliwe przykłady ataków . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383 Zapobieganie – aspekty warte rozważenia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384 Środki zapobiegawcze . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384 A6 – Ujawnienie wrażliwych danych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385 A7 – Brakująca kontrola dostępu na poziomie funkcji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387 Zapobieganie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389 A8 – Cross-Site Request Forgery . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389 Zapobieganie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390 A9 – Wykorzystanie składników ze znanymi lukami zabezpieczeń . . . . . . . . . . . . . . . . . . 391 A10 – Niesprawdzone przekierowania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 393 Podsumowanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 394 Rozdział 12: Wydajność . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395 Inżynieria wydajności aplikacji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395 Narzędzia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 397 Zaawansowane opcje w Visual Studio 2015 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 398 Inne narzędzia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 406 Proces dostrajania wydajności . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 408 Liczniki wydajności . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409 Wykrywanie wąskich gardeł . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409 Korzystanie z kodu do oceny wydajności . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412 Optymalizowanie aplikacji WWW . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415 Optymalizacja IIS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416 Optymalizacja ASP.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417 Podsumowanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 423 ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Spis treści xv Rozdział 13: Tematy zaawansowane . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 425 Podsystem komunikatów Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426 Struktura komunikatu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426 Techniki tworzenia podklas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 429 Kilka przydatnych narzędzi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 431 Platform/Invoke: wywoływanie funkcji systemu operacyjnego z .NET . . . . . . . . . . . . . . 434 Proces wywoływania platformowego . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434 Windows Management Instrumentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437 Programowanie równoległe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 446 Różnica pomiędzy wielowątkowością a programowaniem równoległym . . . . . . 448 Parallel LINQ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 449 Radzenie sobie z innymi problemami . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 453 Anulowanie wykonywania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454 Klasa Parallel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456 Wersja pętli Parallel.ForEach . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 459 Biblioteka Task Parallel Library . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 461 Komunikacja pomiędzy wątkami . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 461 .NET Core 1.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 467 Lista obsługiwanych środowisk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 468 Core FX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 468 Core CLR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 469 Core RT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 469 Core CLI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 470 Instalacja .NET Core . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 470 Interfejs CLI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 477 ASP.NET Core 1.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 479 Co nowego . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 479 Pierwsze podejście . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 480 Ustawienia konfi guracji i uruchamiania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 482 Samodzielne aplikacje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 486 ASP.NET Core 1.0 MVC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 487 Zarządzanie skryptami . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493 .NET Core 1.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 494 Podsumowanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 495 Indeks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 497 ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Wstęp Popularność platformy .NET i języka C# stale rośnie od ich wprowadzenia w roku 2001. Główny autor języka C#, Anders Hejlsberg, kierował w tym czasie kilkoma gru- pami programistów pracującymi nad stałym ulepszaniem platformy aż do obecnej wersji .NET 4.6 i bardzo ważnej jej nowej odmiany .NET Core 1.0/1.1. Jego praca zwią- zana jest też z nowym językiem TypeScript, który również omówimy w tej książce. Niniejsza książka stanowi podróż przez różne opcje i możliwości platformy .NET Framework w ogólności oraz języka C# w szczególności. Pokazuje programistom, jak budować aplikacje działające w systemie Windows oraz (co zobaczymy w ostatnim rozdziale) na innych platformach i urządzeniach. Sądzę, że może być pomocna dla programistów chcących zaktualizować swoją wiedzę do najnowszych wersji tego zestawu technologii, ale również dla tych, któ- rzy przychodzą do .NET i języka C# z innych środowisk i chcieliby rozszerzyć swoje umiejętności oraz zestaw narzędzi programistycznych. Wszystkie główne punkty tutaj omówione są ilustrowane przykładami, a ważne elementy tych demonstracji są szczegółowo objaśniane, co ułatwia ich dokładne prześledzenie. Co omawia ta książka Rozdział 1, Wewnątrz CLR, opisuje wewnętrzną strukturę .NET, sposób budowania podzespołów, dostępne narzędzia i zasoby oraz możliwości integracji .NET z syste- mem operacyjnym. Rozdział 2, Najważniejsze pojęcia języka C# i platformy .NET, obejmuje podstawy języka, jego główne charakterystyki i prawdziwe powody określonego wyglądu pew- nych funkcji takich jak delegaty. Rozdział 3, Zaawansowane pojęcia języka C# i platformy .NET, zaczyna od przeglądu wersji 4.0, typowych nowych praktyk dla języka i bibliotek, zwłaszcza związanych z synchronizacją, wykonywaniem wątków i programowaniem dynamicznym. Na ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== xviii Wstęp koniec znajdziemy opis wielu nowych aspektów, które pojawiły się w wersjach 6.0 i 7.0, a których celem jest uproszczenie sposobu pisania kodu. Rozdział 4, Porównanie różnych typów podejścia do programowania, zajmuje się dwoma członkami ekosystemu języków .NET: językami F# i TypeScript (zwa- nymi również językami funkcjonalnymi), które zyskują popularność w środowisku programistów. Rozdział 5, Mechanizm refl eksji i programowanie dynamiczne, omawia możliwo- ści programu .NET związane z badaniem, analizą i modyfi kowaniem swojej własnej struktury i działania, a także sposobami współpracy z innymi programami takimi jak pakiet Offi ce. Rozdział 6, Programowanie baz danych SQL, zajmuje się dostępem do baz danych zbudowanych zgodnie z zasadami modelu relacyjnego, a w szczególności bazami danych SQL. Omawia Entity Framework 6.0 i krótko przypomina ADO.NET. Rozdział 7, Programowanie baz danych NoSQL, omawia nowszy model baz danych zwany bazami danych NoSQL. Wykorzystamy w nim najpopularniejszą tego rodzaju bazę MongoDB i zobaczymy, jak zarządzać nią z poziomu kodu C#. Rozdział 8, Programowanie otwarte, omawia obecny stan programowania otwar- tego przy użyciu technologii Microsoft i ekosystem programowania z otwartym kodem źródłowym. Zajmiemy się technologiami Node.js, Roselyn, a także TypeScript, choć z nieco innego punktu widzenia. Rozdział 9, Architektura, zajmuje się strukturą aplikacji i dostępnymi narzędziami służącymi do ich konstruowania, takimi jak MSF, dobre praktyki itd. Rozdział 10, Wzorce projektowe, skupia się na jakości kodu i jego strukturze pod względem efektywności, precyzji i łatwości utrzymania. Zajmuje się zasadami SOLID, wzorcami Gang of Four i innymi projektami. Rozdział 11, Bezpieczeństwo, analizuje 10 najważniejszych rekomendacji OWASP dotyczących bezpieczeństwa z punktu widzenia programisty .NET. Rozdział 12, Wydajność, zajmuje się typowymi problemami, jakie może napotkać programista w odniesieniu do wydajności aplikacji oraz tym, jakie techniki i wska- zówki mogą służyć do uzyskania elastycznego i dobrze zachowującego się oprogra- mowania ze specjalnym podkreśleniem wydajności WWW. Rozdział 13, Tematy zaawansowane, omawia interakcję z systemem operacyjnym poprzez tworzenie podklas, usługi platform/invoke, pobieranie danych systemowych przez WMI, programowanie równoległe oraz wprowadzenie do nowych technologii wieloplatformowych .NET Core i ASP.NET Core. ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Wstęp xix Co jest potrzebne do korzystania z tej książki Ponieważ ta książka jest poświęcona językowi C# i platformie .NET, głównym wyko- rzystywanym narzędziem będzie Visual Studio. Można jednak korzystać z różnych jego wersji przy stosowaniu kodu z większości fragmentów tej książki. Ja korzystałem z wersji Visual Studio 2015 Ultimate Update 3, ale można też korzy- stać z darmowej edycji Community (również w najnowszej wersji 2017) w przypadku ponad 90 omawianej treści. Innymi dostępnymi opcjami jest też darmowa edycja Visual Studio 2015 Express oraz darmowy i wieloplatformowy program Visual Studio Code. Ponadto wymagana jest też podstawowa instalacja SQL Server Express 2014 (rów- nież darmowa) wraz z SQL Server Management Studio (wersja 2016 będzie działać równie dobrze w odniesieniu do omawianych tutaj tematów). Na potrzeby rozdziału dotyczącego NoSQL wymagana jest podstawowa instalacja MongoDB. Do debugowania serwisów WWW dobrze jest zainstalować przeglądarkę Chrome Canary lub Firefox Developer Edition, ponieważ mają rozbudowane funkcjonalności przeznaczone dla programistów. Inne narzędzia można zainstalować korzystając z opcji Extensions and Updates w menu Tools w różnych wersjach Visual Studio. W kilku przypadkach będą przydatne dodatkowe narzędzia, które można pobrać z serwisów internetowych wskazanych w tej książce, choć nie są one absolutnie wy- magane do pełnego zrozumienia zawartości tej książki. Dla kogo jest ta książka Ta książka została napisana wyłącznie dla programistów .NET. Tworzącym aplikacje C# dla swoich klientów, w pracy lub w domu, książka ta pomoże rozwinąć umie- jętności potrzebne do tworzenia nowoczesnych, wspaniałych i wydajnych aplikacji w języku C#. Nie jest wymagana żadna wiedza dotycząca C# 6/7 albo .NET 4.6 — wszystkie naj- nowsze funkcje zostaną omówione, aby pomóc w pisaniu aplikacji na różne platformy. Trzeba dobrze znać Visual Studio, choć omówione też zostaną wszystkie nowe funkcje w Visual Studio 2015. ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== xx Wstęp Konwencje W tej książce znajdziemy wiele stylów tekstu, którymi oznaczane są różne rodzaje informacji. Oto kilka przykładów tych stylów oraz wyjaśnienie ich znaczenia. Elementy kodu w tekście, nazwy tabel bazodanowych, nazwy folderów, nazwy plików, rozszerzenia plików, nazwy ścieżek dostępu, dane wpisywane przez użyt- kowników oraz identyfi katory Twitter są przedstawiane następująco: „Korzystamy z metody ForEach, która otrzymuje argument Action będący delegatem”. Blok kodu jest formatowany następująco: static void GenerateStrings() { string initialString = Initial Data- ; for (int i = 0; i  5000; i++) { initialString += -More data- ; } Console.WriteLine( Strings generated ); } Nowe terminy i ważne słowa są wyróżnione bezszeryfową kursywą. Słowa, które są widoczne na ekranie, na przykład w menu lub oknach dialogowych, pojawiają się w tekście w następującej formie: „Na karcie Memory Usage możemy zobaczyć aktu- alny stan tego, co się dzieje”. Ostrzeżenia lub ważne uwagi pojawiają się w takiej ramce. Wskazówki i porady pojawiają się w takiej ramce. Informacje od czytelników Informacje zwrotne od naszych czytelników są zawsze mile widziane. Prosimy o opi- nie na temat tej książki – co się w niej podoba, a co nie. Informacje od czytelników są dla nas ważne, żebyśmy mogli przygotowywać najbardziej pożądane tytuły. W celu przekazania ogólnych uwag, wystarczy wysłać e-maila na adres feedback@ packtpub.com podając tytuł książki w temacie wiadomości. ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Wstęp xxi Jeśli ktoś jest ekspertem w jakiejś dziedzinie i chciałby napisać lub uczestniczyć w pracach nad książką, może zajrzeć do naszego przewodnika dla autorów pod adre- sem www.packtpub.com/authors. Obsługa klienta Dla dumnego posiadacza książki wydawnictwa Packt mamy wiele rzeczy pomocnych w maksymalnym skorzystaniu ze swojego zakupu. Pobieranie kodu przykładowego Pliki z przykładowym kodem dla tej książki można pobrać ze swojego konta pod adre- sem http://www.packtpub.com. Jeśli książka została zakupiona gdzie indziej, można odwiedzić adres http://www.packtpub.com/support, aby się zarejestrować i otrzymać pliki pocztą elektroniczną. Pliki z kodem można pobrać korzystając z następujących kroków: 1. Zalogować się lub zarejestrować w naszym serwisie korzystając ze swojego adresu e-mail i hasła. 2. Wskazać kursorem myszy kartę SUPPORT u góry. 3. Kliknąć Code Downloads Errata. 4. Wpisać nazwę książki w polu Search. 5. Wybrać książkę, dla której poszukiwane są pliki z kodem. 6. Wskazać w rozwijanym menu, gdzie została zakupiona książka. 7. Kliknąć Code Download. Można też pobrać pliki z kodem klikając przycisk Code Files na stronie WWW książki w serwisie Packt Publishing. Dostęp do tej strony można uzyskać wpisując nazwę książki w polu Search. Trzeba być zalogowanym do swojego konta Packt. Po pobraniu pliku można go rozpakować korzystając z  najnowszych wersji oprogramowania: 쎲 WinRAR / 7-Zip dla Windows 쎲 Zipeg / iZip / UnRarX dla Mac 쎲 7-Zip / PeaZip dla systemu Linux Pakiet z kodem dla tej książki jest też dostępny w serwisie GitHub pod adresem https:// github.com/PacktPublishing/Mastering-C-Sharp-and-.NET-Framework. Również inne ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== xxii Wstęp pakiety kodu z naszego bogatego katalogu książek i fi lmów są dostępne pod adresem https://github.com/PacktPublishing/. Warto je sprawdzić! Errata Chociaż podjęliśmy wszelkie starania, aby zapewnić poprawność treści tej książki, błędy czasem się zdarzają. W razie znalezienia błędu w jednej z naszych książek – na przykład błędu w tekście lub w kodzie – bylibyśmy wdzięczni za zgłoszenie nam go. Dzięki temu możemy oszczędzić innym czytelnikom kłopotów i poprawić kolejne wer- sje tej książki. Wszelkie poprawki prosimy zgłaszać pod adresem http://www.packtpub. com/submit-errata, wybierając daną książkę, klikając łącze Errata Submission Form i wprowadzając szczegóły błędu. Po zatwierdzeniu zgłoszenia, zostanie ono przyjęte i opublikowane na naszej stronie WWW lub dodane do listy istniejących poprawek w części Errata dla danego tytułu. Wcześniej przesłane poprawki można znaleźć pod adresem https://www.packtpub. com/books/content/support wpisując tytuł (oryginalny, tzn. angielski) książki w polu wyszukiwania. Żądane informacje pojawią się w części Errata. Piractwo Internetowe piractwo materiałów chronionych prawem autorskim jest stałym prob- lemem. W wydawnictwie Packt bardzo poważnie traktujemy ochronę naszych praw autorskich i licencji. W razie natrafi enia w Internecie na nielegalne egzemplarze na- szych prac w jakiejkolwiek formie prosimy o podanie nam adresu lub nazwy strony WWW, abyśmy mogli podjąć stosowne działania. Prosimy o kontakt pod adresem copyright@packtpub.com z podaniem łącza do materiału podejrzanego o piractwo. Dziękujemy za pomoc w ochronie naszych autorów i naszych możliwości dostar- czania cennych treści. Pytania W  przypadku problemów z  dowolnym aspektem tej książki prosimy o  kontakt pod adresem questions@packtpub.com, a postaramy się pomóc w miarę naszych możliwości. ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== 1 Wewnątrz CLR Ponieważ CLR (Common Language Runtime — wspólne środowisko uruchomieniowe języka) jest tylko ogólną nazwą dla różnych narzędzi i programów opartych na do- brze znanych i przyjętych zasadach programowania, zaczniemy od przeglądnięcia kilku najważniejszych pojęć związanych z programowaniem, które często przyjmu- jemy za rzecz oczywistą. Aby więc nadać sprawom odpowiedni kontekst, rozdział ten omówi najważniejsze pojęcia związane z motywacjami do utworzenia .NET, jak platforma ta integruje się z systemem operacyjnym Windows i co sprawia, że CLR jest tak świetną platformą uruchomieniową. W skrócie, rozdział ten omawia następujące zagadnienia: 쎲 Krótki, ale starannie dobrany słownik typowych pojęć i terminów wykorzystywa- nych w programowaniu ogólnym i związanym z .NET. 쎲 Szybki przegląd celów stworzenia platformy .NET i głównych zasad architekto- nicznych związanych z jej budową. 쎲 Wyjaśnienie każdej z głównych części składających się na platformę uruchomie- niową CLR, jej narzędzi i sposobu ich działania. 쎲 Podstawowe podejście do złożoności algorytmów i sposobów jej mierzenia. 쎲 Wybraną listę najbardziej wyróżniających się charakterystyk związanych z CLR, które pojawiły się w najnowszych wersjach. ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== 2 Uwagi dotyczące kilku ważnych pojęć komputerowych Uwagi dotyczące kilku ważnych pojęć komputerowych Przypomnijmy sobie kilka ważnych pojęć używanych w  dziedzinie tworzenia oprogramowania, z którymi mamy często do czynienia przy programowaniu dla platformy .NET. Kontekst Jak stwierdza Wikipedia: W informatyce kontekst zadania jest minimalnym zbiorem danych wykorzysty- wanym przez zadanie (mogące być procesem lub wątkiem), który należy zapisać, aby można było przerwać zadanie w danym momencie, a później wznowić to za- danie w punkcie przerwania w dowolnym przyszłym momencie. Innymi słowy, kontekst jest pojęciem związanym z danymi obsługiwanymi przez wą- tek. Dane takie są w miarę zapotrzebowania zapisywane i wydobywane przez system. Praktyczne podejścia do tego pojęcia obejmują scenariusze związane z zapyta- niami i odpowiedziami HTTP oraz bazami danych, w których kontekst odgrywa bar- dzo ważną rolę. Model wykonywania wielu zadań w systemie operacyjnym Procesor komputera jest w stanie zarządzać wieloma procesami w danym okresie czasu. Jak wspominaliśmy, można to osiągnąć przez zapisywanie i przywracanie (w bardzo szybki sposób) kontekstu wykonywania przy pomocy techniki zwanej przełączaniem kontekstu. Gdy wątek przestaje być wykonywany, mówimy, że jest w stanie bezczynności (idle). Ta kategoryzacja może być przydatna podczas analizowania wykonywania procesów przy pomocy narzędzi, które mogą wyodrębniać wątki będące w stanie bezczynności (patrz ilustracja na sąsiedniej stronie). Typy kontekstu W niektórych językach, takich jak C# mamy również do czynienia z pojęciem bez- piecznego kontekstu. W pewnym sensie jest to związane z tak zwanym bezpieczeń- stwem wątków. ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Rozdział 1: Wewnątrz CLR 3 Proces P0 System operacyjny Proces P1 Wykonywany Przerwanie lub wywołanie systemowe Zapisanie stanu w PCB0 Załadowanie stanu z PCB1 Bezczynny Bezczynny Przerwanie lub wywołanie systemowe Wykonywany Zapisanie stanu w PCB1 Wykonywany Załadowanie stanu z PCB0 Bezczynny Bezpieczeństwo wątków Mówi się, że fragment kodu jest wątkowo bezpieczny, jeśli jedynie manipuluje wspól- nymi strukturami danych w sposób gwarantujący bezpieczne wykonywanie wielu wątków w tym samym czasie. Istnieją różne strategie używane do tworzenia bez- piecznych wątkowo struktur danych, a platforma .NET zwraca szczególną uwagę na to pojęcie i jego implementacje. W istocie ofi cjalna dokumentacja MSDN zawiera w dolnej części opisu znacznej większości typów określenie ten typ jest wątkowo bezpieczny. Stan Stan oprogramowania komputerowego jest terminem technicznym obejmującym ca- łość przechowywanej w danym momencie czasu informacji, do której dany program ma dostęp. Wyjście programu komputerowego w danym momencie jest całkowicie określane przez jego aktualne wejścia oraz jego stan. Bardzo ważnym wariantem tego pojęcia jest stan programu. ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== 4 Uwagi dotyczące kilku ważnych pojęć komputerowych Stan programu To pojęcie jest szczególnie ważne i ma kilka znaczeń. Wiemy, że program kompu- terowy przechowuje dane w zmiennych, które są po prostu nazwanymi miejscami w pamięci komputera. Zawartość tych miejsc w pamięci w danym momencie wyko- nywania programu jest zwana stanem programu. W językach zorientowanych obiektowo mówi się, że klasa defi niuje swój stan po- przez pola, a wartości tych pó
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Tajniki C# i .NET Framework
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ą: