C# od podszewki. Wydanie II
- Wydawnictwo:
- Helion
- Ocena:
- 5.0/6 Opinie: 9
- Stron:
- 632
- Druk:
- oprawa miękka
- Dostępne formaty:
-
PDFePubMobi

Sprawdź nowe wydanie
C# od podszewki. Wydanie IV
Jon Skeet
Opis ebooka: C# od podszewki. Wydanie II
Poznaj najskrytsze zakamarki C#!
Obecnie szczególnie cenione są te języki programowania, które pozwalają na błyskawiczne osiągnięcie oczekiwanych efektów. Dodatkowo absolutnie niezbędne jest zachowanie możliwości uruchamiania raz napisanej aplikacji na różnych platformach bez konieczności jej przepisywania. Nikt nie ma na to czasu! C# to nowoczesny język, który zdobył uznanie programistów na całym świecie, ponieważ spełnia nawet najbardziej wyśrubowane wymagania!
Ten bezcenny podręcznik zaprowadzi Cię w najskrytsze zakątki języka C#. Autorzy założyli, że znasz jego podstawy - to pozwoliło im skupić uwagę na niuansach, ciekawostkach oraz subtelnych szczegółach. W trakcie lektury zrozumiesz, co się dzieje w czeluściach C#, a dzięki temu unikniesz ukrytych pułapek. Książka ta jest obowiązkową pozycją każdego programisty C#. Bez niej najciekawsze funkcje C# wciąż będą Ci obce!
Dowiedz się:
- do czego przydają się typy generyczne
- jak zaimplementować iteratory
- jak zoptymalizować skompilowany kod
- w czym może pomóc język LINQ
- jak testować kod
Fascynująca podróż w głąb C#!
Wybrane bestsellery
-
To czwarte wydanie podręcznika przeznaczonego dla programistów C#, którzy znają podstawy tego języka, jednak zależy im na dogłębnym zrozumieniu ważnych pojęć i przyswojeniu różnych sposobów myślenia o pozornie znanych zagadnieniach. W książce skrótowo opisano wersje C# od 2 do 5, a wyczerpująco o...(64.35 zł najniższa cena z 30 dni)
64.35 zł
99.00 zł(-35%) -
To kolejne wydanie lubianego samouczka, dzięki któremu w ramach 24 godzinnych lekcji przyswoisz solidne podstawy programowania. Zrozumiesz, jak działają programy, i nauczysz się reguł stosowanych przez profesjonalistów przy ich projektowaniu. Dowiesz się, jak wygląda świat programistów i na czym ...
Programowanie dla początkujących w 24 godziny. Wydanie IV Programowanie dla początkujących w 24 godziny. Wydanie IV
(9.90 zł najniższa cena z 30 dni)37.95 zł
69.00 zł(-45%) -
Zaczynamy od skonfigurowania środowiska testowego oraz nauki sposobu optymalizacji API Selenium WebDriver. Następnie, poprzez implementację własnych zadań, uczymy się użycia wzorców projektowych oraz poznajemy sposoby rozszerzania API Selenium WebDriver. Na koniec konfigurujemy własne środowisko ...
Selenium i testowanie aplikacji. Receptury. Wydanie II Selenium i testowanie aplikacji. Receptury. Wydanie II
-
Po przyswojeniu zagadnień związanych z językiem C# i aplikacjami konsoli dowiesz się, jak tworzyć praktyczne aplikacje i usługi z wykorzystaniem biblioteki ASP.NET Core, a także wzorzec MVC i technologię Blazor. Zapoznasz się z metodami stosowania wielozadaniowości do poprawy wydajności i skalowa...
C# 10 i .NET 6 dla programistów aplikacji wieloplatformowych. Twórz aplikacje, witryny WWW oraz serwisy sieciowe za pomocą ASP.NET Core 6, Blazor i EF Core 6 w Visual Studio 2022 i Visual Studio Code. Wydanie VI C# 10 i .NET 6 dla programistów aplikacji wieloplatformowych. Twórz aplikacje, witryny WWW oraz serwisy sieciowe za pomocą ASP.NET Core 6, Blazor i EF Core 6 w Visual Studio 2022 i Visual Studio Code. Wydanie VI
(95.40 zł najniższa cena z 30 dni)103.35 zł
159.00 zł(-35%) -
Managing people is difficult wherever you work. But in the tech industry, where management is also a technical discipline, the learning curve can be brutal—especially when there are few tools, texts, and frameworks to help you. In this practical guide, author Camille Fournier (tech lead tur...
The Manager's Path. A Guide for Tech Leaders Navigating Growth and Change The Manager's Path. A Guide for Tech Leaders Navigating Growth and Change
(29.90 zł najniższa cena z 30 dni)135.15 zł
159.00 zł(-15%) -
Użytkownicy mogą być różni, wszystkich jednak łączą te same oczekiwania dotyczące niezawodności i prawidłowego działania oprogramowania. Podążając za tymi oczekiwaniami, można zauważyć, że sprawnie działająca aplikacja przekłada się na zadowolenie użytkowników i powoduje wzrost zaufania do jakośc...
Tester manualny. Kurs video. Techniki projektowania testów Tester manualny. Kurs video. Techniki projektowania testów
(39.90 zł najniższa cena z 30 dni)81.95 zł
149.00 zł(-45%) -
Branża IT kusi licznymi ofertami pracy, atrakcyjnymi zarobkami i ciekawymi ścieżkami rozwoju nie tylko zawodowych programistów, lecz również osoby bez wykształcenia informatycznego czy doświadczenia w tej dziedzinie. Te ostatnie zwykle zaczynają karierę od roli testera aplikacji. Jednym z podstaw...(53.40 zł najniższa cena z 30 dni)
57.85 zł
89.00 zł(-35%) -
When you have questions about C# 10 or .NET 6, this best-selling guide has the answers you need. C# is a language of unusual flexibility and breadth, and with its continual growth, there's always so much more to learn. In the tradition of O'Reilly's Nutshell guides, this thoroughly updated editio...(29.90 zł najniższa cena z 30 dni)
262.65 zł
309.00 zł(-15%) -
Naglący termin, niedoczas, permanentne opóźnienie - oto najwierniejsi towarzysze i zarazem najwięksi wrogowie kierownika projektu. Nawet certyfikowani project managerowie, ludzie z ogromną wiedzą i nie mniejszym doświadczeniem, raz po raz znajdują się w sytuacji, w której potrzeba naprawdę wielki...(35.40 zł najniższa cena z 30 dni)
38.35 zł
59.00 zł(-35%) -
Ten praktyczny przewodnik jest przeznaczony dla osób, które chcą się nauczyć myśleć jak rasowi programiści Go. Dzięki niemu zaczniesz pisać idiomatyczny kod w Go, co pozwoli Ci optymalnie wykorzystywać możliwości tego języka. Dowiesz się, jak wygląda środowisko programistyczne Go i w jaki sposób ...
Język Go. Tworzenie idiomatycznego kodu w praktyce Język Go. Tworzenie idiomatycznego kodu w praktyce
(53.40 zł najniższa cena z 30 dni)57.85 zł
89.00 zł(-35%)
O autorze ebooka
Jon Skeet jest starszym inżynierem oprogramowania w firmie Google. Odpowiada za tworzenie bibliotek klienckich dla .NET na platformie Google Cloud. Bierze również udział w tworzeniu standardu języka C# w organizacji ECMA. Jest programistą o niemal legendarnych umiejętnościach tworzenia kodu, przy tym chętnie dzieli się wiedzą i doświadczeniem z innymi. Ma nietypowe hobby: interesuje się zagadnieniami pomiaru czasu i dat.
Ebooka przeczytasz na:
-
czytnikach Inkbook, Kindle, Pocketbook i innych
-
systemach Windows, MacOS i innych
-
systemach Windows, Android, iOS, HarmonyOS
-
na dowolnych urządzeniach i aplikacjach obsługujących formaty: PDF, EPub, Mobi
Masz pytania? Zajrzyj do zakładki Pomoc »
Audiobooka posłuchasz:
-
w aplikacji Ebookpoint na Android, iOS, HarmonyOs
-
na systemach Windows, MacOS i innych
-
na dowolnych urządzeniach i aplikacjach obsługujących format MP3 (pliki spakowane w ZIP)
Masz pytania? Zajrzyj do zakładki Pomoc »
Kurs Video zobaczysz:
-
w aplikacji Ebookpoint na Android, iOS, HarmonyOs
-
na systemach Windows, MacOS i innych
-
na dowolnych urządzeniach i aplikacjach obsługujących format MP4 (pliki spakowane w ZIP)
Szczegóły ebooka
- Tytuł oryginału:
- C# in Depth, Second Edition
- Tłumaczenie:
- Janusz Grabis
- ISBN Książki drukowanej:
- 978-83-246-3921-2, 9788324639212
- Data wydania książki drukowanej:
- 2012-09-10
- ISBN Ebooka:
- 978-83-246-6458-0, 9788324664580
- Data wydania ebooka:
-
2012-10-29
Data wydania ebooka często jest dniem wprowadzenia tytułu do sprzedaży i może nie być równoznaczna z datą wydania książki papierowej. Dodatkowe informacje możesz znaleźć w darmowym fragmencie. Jeśli masz wątpliwości skontaktuj się z nami sklep@ebookpoint.pl.
- Format:
- 168x237
- Numer z katalogu:
- 8672
- Rozmiar pliku Pdf:
- 7.9MB
- Rozmiar pliku ePub:
- 5.1MB
- Rozmiar pliku Mobi:
- 5.1MB
- Pobierz przykładowy rozdział PDF
- Przykłady na ftp
Ebook zawiera materiały dodatkowe, które możesz pobrać z serwera FTP - link znajdziesz na stronie redakcyjnej.
Spis treści ebooka
- 1.1. Na początek prosty typ danych (34)
- 1.1.1. Typ Product w C# 1 (35)
- 1.1.2. Kolekcje o mocnym typie w C# 2 (36)
- 1.1.3. Właściwości implementowane automatycznie w C# 3 (37)
- 1.1.4. Argumenty nazwane w C# 4 (38)
- 1.2. Sortowanie i filtrowanie (39)
- 1.2.1. Sortowanie produktów po nazwie (40)
- 1.2.2. Wyszukiwanie elementów w kolekcjach (43)
- 1.3. Obsługa braku danych (44)
- 1.3.1. Reprezentacja nieznanej ceny (45)
- 1.3.2. Parametry opcjonalne i wartości domyślne (46)
- 1.4. Wprowadzenie do LINQ (46)
- 1.4.1. Wyrażenia kwerendowe i zapytania wewnątrzprocesowe (47)
- 1.4.2. Wykonywanie zapytań na XML-u (48)
- 1.4.3. LINQ dla SQL-a (49)
- 1.5. COM i typy dynamiczne (50)
- 1.5.1. Uproszczenie współpracy z COM (50)
- 1.5.2. Współpraca z językiem dynamicznym (51)
- 1.6. Analiza zawartości środowiska .NET (52)
- 1.6.1. Język C# (53)
- 1.6.2. Środowisko wykonania (53)
- 1.6.3. Biblioteki środowiska (54)
- 1.7. Jak zmienić Twój kod w kod doskonały? (54)
- 1.7.1. Prezentacja pełnych programów w formie fragmentów kodu (55)
- 1.7.2. Kod dydaktyczny nie jest kodem produkcyjnym (56)
- 1.7.3. Twój nowy najlepszy przyjaciel - specyfikacja języka (56)
- 1.8. Podsumowanie (57)
- 2.1. Delegaty (60)
- 2.1.1. Przepis na prosty delegat (61)
- 2.1.2. Łączenie i usuwanie delegatów (66)
- 2.1.3. Dygresja na temat zdarzeń (67)
- 2.1.4. Podsumowanie delegatów (68)
- 2.2. Charakterystyka systemu typów (69)
- 2.2.1. Miejsce C# w świecie systemów typów (69)
- 2.2.2. Kiedy system typów C# 1 jest niedostatecznie bogaty? (73)
- 2.2.3. Podsumowanie charakterystyki systemu typów (75)
- 2.3. Typy wartościowe i referencyjne (76)
- 2.3.1. Wartości i referencje w rzeczywistym świecie (76)
- 2.3.2. Podstawy typów referencyjnych i wartościowych (77)
- 2.3.3. Obalanie mitów (79)
- 2.3.4. Opakowywanie i odpakowywanie (81)
- 2.3.5. Podsumowanie typów wartościowych i referencyjnych (82)
- 2.4. Więcej niż C# 1 - nowe cechy na solidnym fundamencie (83)
- 2.4.1. Cechy związane z delegatami (83)
- 2.4.2. Cechy związane z systemem typów (85)
- 2.4.3. Cechy związane z typami wartościowymi (87)
- 2.5. Podsumowanie (88)
- 3.1. Czemu potrzebne są typy generyczne? (92)
- 3.2. Proste typy generyczne do codziennego użycia (94)
- 3.2.1. Nauka przez przykład - słownik typu generycznego (94)
- 3.2.2. Typy generyczne i parametry typów (96)
- 3.2.3. Metody generyczne i czytanie deklaracji generycznych (100)
- 3.3. Wkraczamy głębiej (103)
- 3.3.1. Ograniczenia typów (104)
- 3.3.2. Interfejs argumentów typu dla metod generycznych (109)
- 3.3.3. Implementowanie typów generycznych (110)
- 3.4. Zaawansowane elementy typów generycznych (116)
- 3.4.1. Pola i konstruktory statyczne (117)
- 3.4.2. Jak kompilator JIT traktuje typy generyczne (119)
- 3.4.3. Iteracja przy użyciu typów generycznych (121)
- 3.4.4. Refleksja i typy generyczne (123)
- 3.5. Ograniczenia typów generycznych C# i innych języków (128)
- 3.5.1. Brak wariancji typów generycznych (128)
- 3.5.2. Brak ograniczeń operatorów lub ograniczeń "numerycznych" (133)
- 3.5.3. Brak generycznych właściwości, indekserów i innych elementów typu (135)
- 3.5.4. Porównanie z C++ (136)
- 3.5.5. Porównanie z typami generycznymi Javy (137)
- 3.6. Podsumowanie (139)
- 4.1. Co robisz, kiedy zwyczajnie nie masz wartości? (142)
- 4.1.1. Czemu zmienne typu wartościowego nie mogą zawierać null? (142)
- 4.1.2. Metody reprezentacji wartości null w C# 1 (143)
- 4.2. System.Nullable<T> i System.Nullable (145)
- 4.2.1. Wprowadzenie Nullable<T> (146)
- 4.2.2. Opakowywanie i odpakowywanie Nullable<T> (149)
- 4.2.3. Równość instancji Nullable<T> (150)
- 4.2.4. Wsparcie ze strony niegenerycznej klasy Nullable (151)
- 4.3. Składnia C# 2 dla typów nullowalnych (152)
- 4.3.1. Modyfikator ? (152)
- 4.3.2. Przypisania i porównania z null (154)
- 4.3.3. Konwersje i operatory nullowalne (156)
- 4.3.4. Logika typów nullowalnych (159)
- 4.3.5. Stosowanie operatora as z typami nullowalnymi (161)
- 4.3.6. Nullowy operator koalescencyjny (161)
- 4.4. Nowatorskie zastosowania typów nullowalnych (164)
- 4.4.1. Testowanie operacji bez parametrów zwrotnych (165)
- 4.4.2. Bezbolesne porównania przy użyciu nullowalnego operatora koalescencyjnego (167)
- 4.5. Podsumowanie (169)
- 5.1. Pożegnanie z dziwaczną składnią delegatów (173)
- 5.2. Konwersja grupy metod (174)
- 5.3. Kowariancja i kontrawariancja (176)
- 5.3.1. Kontrawariancja parametrów delegatów (176)
- 5.3.2. Kowariancja typu zwracanego delegata (178)
- 5.3.3. Małe ryzyko niekompatybilności (179)
- 5.4. Akcje delegatów tworzone w miejscu przy użyciu metod anonimowych (180)
- 5.4.1. Rozpoczynamy prosto - operując na parametrach (181)
- 5.4.2. Zwracanie wartości z metod anonimowych (183)
- 5.4.3. Ignorowanie parametrów typu (185)
- 5.5. Przechwytywanie zmiennych w metodach anonimowych (186)
- 5.5.1. Definicja domknięcia i różnych typów zmiennych (187)
- 5.5.2. Analiza zachowania zmiennych przechwyconych (188)
- 5.5.3. Jaki cel mają zmienne przechwycone? (189)
- 5.5.4. Przedłużone życie zmiennych przechwyconych (190)
- 5.5.5. Instancje zmiennej lokalnej (192)
- 5.5.6. Mieszanka zmiennych współdzielonych i odrębnych (194)
- 5.5.7. Wskazówki odnośnie do zmiennych przechwyconych i podsumowanie (196)
- 5.6. Podsumowanie (197)
- 6.1. C# 1 - udręka ręcznego pisania iteratorów (201)
- 6.2. C# 2 - proste iteratory z wyrażeniami yield (204)
- 6.2.1. Wprowadzenie do uproszczeń iteratorów i wyrażenia yield return (204)
- 6.2.2. Wizualizacja toku wykonania iteratora (206)
- 6.2.3. Zaawansowany tok wykonania iteratora (208)
- 6.2.4. Dziwactwa w implementacji (211)
- 6.3. Przykłady z życia (213)
- 6.3.1. Iterowanie po datach w harmonogramie (213)
- 6.3.2. Iterowanie po wierszach pliku (214)
- 6.3.3. Leniwe filtrowanie elementów z użyciem uproszczenia iteratora i predykatu (217)
- 6.4. Pseudosynchroniczny kod z użyciem biblioteki CCR (219)
- 6.5. Podsumowanie (222)
- 7.1. Typy częściowe (227)
- 7.1.1. Tworzenie typu składającego się z kilku plików (227)
- 7.1.2. Użycie typów częściowych (229)
- 7.1.3. Metody częściowe - tylko w C# 3 (231)
- 7.2. Klasy statyczne (233)
- 7.3. Niezależny poziom dostępu do getterów i setterów właściwości (235)
- 7.4. Aliasy przestrzeni nazw (237)
- 7.4.1. Kwalifikowanie aliasów przestrzeni nazw (238)
- 7.4.2. Aliasy globalnej przestrzeni nazw (239)
- 7.4.3. Aliasy zewnętrzne (240)
- 7.5. Dyrektywy pragma (241)
- 7.5.1. Pragmy ostrzeżeń (242)
- 7.5.2. Pragmy sum kontrolnych (243)
- 7.6. Bufory o stałym rozmiarze w kodzie niezarządzanym (243)
- 7.7. Udostępnianie wybranych elementów innym modułom (245)
- 7.7.1. Zaprzyjaźnione moduły w prostym przypadku (246)
- 7.7.2. Do czego warto używać InternalsVisibleTo? (247)
- 7.7.3. InternalsVisibleTo i moduły podpisane (247)
- 7.8. Podsumowanie (248)
- 8.1. Właściwości implementowane automatycznie (255)
- 8.2. Zmienne lokalne o typie niejawnym (257)
- 8.2.1. Zastosowanie var do deklarowania zmiennych lokalnych (257)
- 8.2.2. Ograniczenia w typach niejawnych (259)
- 8.2.3. Zalety i wady typów niejawnych (260)
- 8.2.4. Zalecenia (261)
- 8.3. Uproszczona inicjalizacja (262)
- 8.3.1. Definicja prostych typów (262)
- 8.3.2. Ustawianie prostych właściwości (263)
- 8.3.3. Ustawianie właściwości obiektów zagnieżdżonych (265)
- 8.3.4. Inicjalizatory kolekcji (266)
- 8.3.5. Zastosowanie inicjalizatorów (269)
- 8.4. Tablice o typie niejawnym (270)
- 8.5. Typy anonimowe (272)
- 8.5.1. Pierwsze spotkania z gatunkiem anonimowym (272)
- 8.5.2. Części składowe typów anonimowych (274)
- 8.5.3. Inicjalizatory odwzorowujące (275)
- 8.5.4. Jaki to ma sens? (276)
- 8.6. Podsumowanie (277)
- 9.1. Wyrażenia lambda i delegaty (281)
- 9.1.1. Przygotowanie - wprowadzenie delegatów typu Func<...> (281)
- 9.1.2. Pierwsze przekształcenie na wyrażenie lambda (282)
- 9.1.3. Używanie pojedynczego wyrażenia jako ciała (283)
- 9.1.4. Lista parametrów o typie niejawnym (284)
- 9.1.5. Skrót dla pojedynczego parametru (284)
- 9.2. Proste przykłady użycia List<T> i zdarzeń (286)
- 9.2.1. Filtrowanie, sortowanie i operacje na listach (286)
- 9.2.2. Logowanie w metodach obsługi zdarzeń (288)
- 9.3. Drzewa wyrażeń (289)
- 9.3.1. Budowanie drzew wyrażeń w sposób programistyczny (289)
- 9.3.2. Kompilowanie drzew wyrażeń do postaci delegatów (291)
- 9.3.3. Konwersja wyrażeń lambda C# na drzewa wyrażeń (292)
- 9.3.4. Drzewa wyrażeń w sercu LINQ (296)
- 9.3.5. Drzewa wyrażeń poza LINQ (297)
- 9.4. Zmiany we wnioskowaniu typów i rozwiązywaniu przeciążeń (299)
- 9.4.1. Powód do zmiany - usprawnienie wywołań metod generycznych (300)
- 9.4.2. Wnioskowanie typu zwracanego funkcji anonimowych (301)
- 9.4.3. Dwufazowe wnioskowanie typu (302)
- 9.4.4. Wybieranie odpowiedniego przeciążenia metody (306)
- 9.4.5. Podsumowanie wnioskowania typów i rozwiązywania przeciążeń (308)
- 9.5. Podsumowanie (308)
- 10.1. Życie przed metodami rozszerzającymi (312)
- 10.2. Składnia metod rozszerzających (315)
- 10.2.1. Deklarowanie metod rozszerzających (315)
- 10.2.2. Wywoływanie metod rozszerzających (316)
- 10.2.3. Wykrywanie metod rozszerzających (318)
- 10.2.4. Wywołanie metody na pustej referencji (319)
- 10.3. Metody rozszerzające w .NET 3.5 (321)
- 10.3.1. Pierwsze kroki z Enumerable (321)
- 10.3.2. Filtrowanie z użyciem Where i spinania wywołań metod (323)
- 10.3.3. Antrakt: czy metody Where nie widzieliśmy już wcześniej? (325)
- 10.3.4. Projekcja przy użyciu metody Select i typów anonimowych (326)
- 10.3.5. Sortowanie przy użyciu OrderBy (327)
- 10.3.6. Przykłady logiki biznesowej z użyciem łańcuchowania (328)
- 10.4. Wskazówki i uwagi odnośnie do użycia (330)
- 10.4.1. "Rozszerzanie świata" i wzbogacanie interfejsów (330)
- 10.4.2. Płynne interfejsy (331)
- 10.4.3. Rozważne użycie metod rozszerzających (332)
- 10.5. Podsumowanie (334)
- 11.1. Wprowadzenie do LINQ (336)
- 11.1.1. Podstawowe koncepcje w LINQ (336)
- 11.1.2. Definiowanie przykładowego modelu danych (341)
- 11.2. Prosty początek - wybieranie elementów (343)
- 11.2.1. Rozpoczynanie od źródła i kończenie na selekcji (343)
- 11.2.2. Translacja kompilatora jako podstawa wyrażeń kwerendowych (344)
- 11.2.3. Zmienne zakresu i projekcje nietrywialne (347)
- 11.2.4. Cast, OfType i zmienne zakresu o typie jawnym (349)
- 11.3. Filtrowanie i porządkowanie sekwencji (351)
- 11.3.1. Filtrowanie przy użyciu klauzuli where (351)
- 11.3.2. Zdegenerowane wyrażenia kwerendowe (352)
- 11.3.3. Porządkowanie przy użyciu klauzuli orderby (353)
- 11.4. Klauzule let i identyfikatory przezroczyste (356)
- 11.4.1. Wprowadzenie do wykonania pośredniego z użyciem let (356)
- 11.4.2. Identyfikatory przezroczyste (357)
- 11.5. Złączenia (359)
- 11.5.1. Złączenia wewnętrzne korzystające z klauzul join (359)
- 11.5.2. Złączenia grupowe z użyciem klauzul join ... into (363)
- 11.5.3. Złączenia krzyżowe i spłaszczanie sekwencji przy użyciu wielokrotnych klauzul from (366)
- 11.6. Grupowania i kontynuacje (369)
- 11.6.1. Grupowanie przy użyciu klauzuli group ... by (369)
- 11.6.2. Kontynuacje zapytań (373)
- 11.7. Wybór pomiędzy wyrażeniami kwerendowymi a notacją kropkową (375)
- 11.7.1. Operacje wymagające notacji kropkowej (376)
- 11.7.2. Wyrażenia kwerendowe, dla których prostszym rozwiązaniem może się okazać notacja kropkowa (377)
- 11.7.3. Gdzie wyrażenia kwerendowe lśnią? (377)
- 11.8. Podsumowanie (379)
- 12.1. Odpytywanie bazy danych przez LINQ dla SQL-a (382)
- 12.1.1. Zaczynamy od bazy danych i modelu (383)
- 12.1.2. Zapytania wstępne (385)
- 12.1.3. Zapytania wymagające złączeń (388)
- 12.2. Translacje przy użyciu IQueryable i IQueryProvider (390)
- 12.2.1. Wprowadzenie do IQueryable<T> i związanych z nim interfejsów (391)
- 12.2.2. Prototyp - implementacja interfejsów wykonująca wpisy w dzienniku (393)
- 12.2.3. Spajanie wszystkiego razem - metody rozszerzające typu Queryable (395)
- 12.2.4. Udawany dostawca w działaniu (397)
- 12.2.5. Podsumowanie IQueryable (398)
- 12.3. Interfejsy zaprzyjaźnione z LINQ i LINQ dla XML-a (399)
- 12.3.1. Rdzenne typy LINQ dla XML-a (399)
- 12.3.2. Konstrukcja deklaratywna (401)
- 12.3.3. Zapytania na pojedynczych węzłach (404)
- 12.3.4. Operatory zapytań spłaszczonych (406)
- 12.3.5. Praca w harmonii z LINQ (407)
- 12.4. Zastąpienie LINQ dla Obiektów Równoległym LINQ (408)
- 12.4.1. Kreślenie zbioru Mandelbrota przez pojedynczy wątek (409)
- 12.4.2. Wprowadzenie ParallelEnumerable, ParallelQuery i AsParallel (410)
- 12.4.3. Podkręcanie zapytań równoległych (411)
- 12.5. Odwrócenie modelu zapytania przy użyciu LINQ dla Rx (413)
- 12.5.1. IObservable<T> i IObserver<T> (414)
- 12.5.2. Zaczynamy (ponownie) łagodnie (416)
- 12.5.3. Odpytywanie obiektów obserwowalnych (417)
- 12.5.4. Jaki to wszystko ma sens? (419)
- 12.6. Rozszerzanie LINQ dla Obiektów (420)
- 12.6.1. Wytyczne odnośnie do projektu i implementacji (421)
- 12.6.2. Proste rozszerzenie - wybieranie losowego elementu (422)
- 12.7. Podsumowanie (424)
- 13.1. Parametry opcjonalne i argumenty nazwane (430)
- 13.1.1. Parametry opcjonalne (430)
- 13.1.2. Argumenty nazwane (437)
- 13.1.3. Złożenie dwóch cech w całość (441)
- 13.2. Usprawnienia we współpracy z COM (446)
- 13.2.1. Horror automatyzacji Worda przed C# 4 (446)
- 13.2.2. Zemsta parametrów opcjonalnych i argumentów nazwanych (447)
- 13.2.3. Kiedy parametr ref nie jest parametrem ref? (448)
- 13.2.4. Wywoływanie indekserów nazwanych (449)
- 13.2.5. Łączenie głównych bibliotek COM-owych (451)
- 13.3. Wariancja typów generycznych dla interfejsów i delegatów (453)
- 13.3.1. Typy wariancji: kowariancja i kontrawariancja (454)
- 13.3.2. Użycie wariancji w interfejsach (455)
- 13.3.3. Zastosowanie wariancji w delegatach (458)
- 13.3.4. Złożone sytuacje (459)
- 13.3.5. Restrykcje i uwagi (461)
- 13.4. Mikroskopijne zmiany w blokadach i zdarzeniach w formie pól (465)
- 13.4.1. Solidne blokowanie (465)
- 13.4.2. Zmiany w zdarzeniach w formie pól (467)
- 13.5. Podsumowanie (467)
- 14.1. Co? Kiedy? Dlaczego? Jak? (471)
- 14.1.1. Czym są typy dynamiczne? (471)
- 14.1.2. Kiedy typy dynamiczne są użyteczne i dlaczego? (472)
- 14.1.3. W jaki sposób C# zapewnia typy dynamiczne? (474)
- 14.2. Pięciominutowy przewodnik po typie dynamic (474)
- 14.3. Przykłady użycia typów dynamicznych (477)
- 14.3.1. COM w ogólności i Microsoft Office w szczególności (477)
- 14.3.2. Języki dynamiczne, takie jak IronPython (479)
- 14.3.3. Typy dynamiczne w kodzie całkowicie zarządzanym (484)
- 14.4. Zaglądamy pod maskę (490)
- 14.4.1. Wprowadzenie do DLR (491)
- 14.4.2. Fundamentalne koncepcje DLR (493)
- 14.4.3. Jak kompilator C# obsługuje słowo dynamic? (496)
- 14.4.4. Kompilator C# staje się jeszcze sprytniejszy (500)
- 14.4.5. Ograniczenia kodu dynamicznego (503)
- 14.5. Implementacja zachowania dynamicznego (506)
- 14.5.1. Użycie klasy ExpandoObject (506)
- 14.5.2. Użycie klasy DynamicObject (511)
- 14.5.3. Implementacja IDynamicMetaObjectProvider (518)
- 14.6. Podsumowanie (522)
- 15.1. Życie przed kontraktami kodu (525)
- 15.2. Wprowadzenie do kontraktów kodu (527)
- 15.2.1. Warunki wstępne (529)
- 15.2.2. Warunki końcowe (530)
- 15.2.3. Inwarianty (531)
- 15.2.4. Asercje i założenia (533)
- 15.2.5. Kontrakty legacyjne (534)
- 15.3. Przepisywanie kodu binarnego przez ccrewrite i ccrefgen (536)
- 15.3.1. Proste przepisywanie (536)
- 15.3.2. Dziedziczenie kontraktów (538)
- 15.3.3. Referencyjne moduły kontraktów (541)
- 15.3.4. Zachowanie w przypadku porażki (543)
- 15.4. Sprawdzanie statyczne (545)
- 15.4.1. Wprowadzenie do analizy statycznej (545)
- 15.4.2. Zobowiązania niejawne (548)
- 15.4.3. Selektywne włączanie opcji (551)
- 15.5. Dokumentowanie kodu przy użyciu ccdocgen (554)
- 15.6. Kontrakty w praktyce (556)
- 15.6.1. Filozofia - czym jest kontrakt? (557)
- 15.6.2. Jak mam zacząć? (558)
- 15.6.3. Opcje, wszędzie opcje (559)
- 15.7. Podsumowanie (562)
- 16.1. C# - połączenie tradycji z nowoczesnością (566)
- 16.2. Spotkanie .NET z informatyką (567)
- 16.3. Świat informatyki (568)
- 16.4. Pożegnanie (569)
- A.1. Agregacja (574)
- A.2. Konkatenacja (575)
- A.3. Konwersja (575)
- A.4. Operatory jednoelementowe (577)
- A.5. Równość (578)
- A.6. Generacja (579)
- A.7. Grupowanie (580)
- A.8. Złączenia (580)
- A.9. Partycjonowanie (582)
- A.10. Projekcja (582)
- A.11. Kwantyfikatory (583)
- A.12. Filtrowanie (584)
- A.13. Operatory bazujące na zbiorach (584)
- A.14. Sortowanie (585)
- B.1. Interfejsy (588)
- B.2. Listy (590)
- B.2.1. List<T> (590)
- B.2.2. Tablice (591)
- B.2.3. LinkedList<T> (592)
- B.2.4. Collection<T>, BindingList<T>, ObservableCollection<T> i KeyedCollection<TKey, TItem> (593)
- B.2.5. ReadOnlyCollection<T> i ReadOnlyObservableCollection<T> (594)
- B.3. Słowniki (594)
- B.3.1. Dictionary<TKey, TValue> (594)
- B.3.2. SortedList<TKey, TValue> i SortedDictionary<TKey, TValue> (595)
- B.4. Zbiory (596)
- B.4.1. HashSet<T> (597)
- B.4.2. SortedSet<T> (.NET 4) (597)
- B.5. Queue<T> i Stack<T> (598)
- B.5.1. Queue<T> (598)
- B.5.2. Stack<T> (598)
- B.6. Kolekcje konkurencyjne (.NET 4) (598)
- B.6.1. IProducerConsumerCollection<T> i BlockingCollection<T> (599)
- B.6.2. ConcurrentBag<T>, ConcurrentQueue<T>, ConcurrentStack<T> (600)
- B.6.3. ConcurrentDictionary<TKey, TValue> (600)
- B.7. Podsumowanie (600)
- C.1. Główne wersje dystrybucyjne środowiska typu desktop (604)
- C.2. Cechy języka C# (605)
- C.2.1. C# 2.0 (605)
- C.2.2. C# 3 (605)
- C.2.3. C# 4.0 (606)
- C.3. Biblioteki środowiska (606)
- C.3.1. .NET 2.0 (606)
- C.3.2. .NET 3.0 (606)
- C.3.3. .NET 3.5 (607)
- C.3.4. .NET 4 (607)
- C.4. Cechy środowiska uruchomieniowego (CLR) (608)
- C.4.1. CLR 2.0 (608)
- C.4.2. CLR 4.0 (609)
- C.5. Inne rodzaje środowiska uruchomieniowego (609)
- C.5.1. Compact Framework (609)
- C.5.2. Silverlight (610)
- C.5.3. Micro Framework (611)
- C.6. Podsumowanie (611)
Przedmowa (17)
Wstęp (19)
Podziękowania (21)
O książce (23)
Część I Przygotowanie do wyprawy (31)
1. Nieustająca metamorfoza C# (33)
2. Rdzeń systemu - C# 1 (59)
Część II C# 2 - rozwiązanie problemów C# 1 (89)
3. Parametryzowanie typów i metod (91)
4. Wyrażanie "niczego" przy użyciu typów nullowalnych (141)
5. Przyspieszone delegaty (171)
6. Implementowanie iteratorów w prosty sposób (199)
7. Pozostałe cechy C# 2 (225)
Część III C# 3 - rewolucja w metodzie programowania (251)
8. Redukcja nadmiarowości przez zmyślny kompilator (253)
9. Wyrażenia lambda i drzewa wyrażeń (279)
10. Metody rozszerzające (311)
11. Wyrażenia kwerendowe i LINQ dla Obiektów (335)
12. LINQ - nie tylko kolekcje (381)
Część IV C# 4 - dobra współpraca z innymi interfejsami (427)
13. Małe zmiany dla uproszczenia kodu (429)
14. Dynamiczne wiązanie w języku statycznym (469)
15. Jaśniejsze wyrażanie kodu przy użyciu kontraktów kodu (523)
16. Dokąd teraz? (565)
Dodatki (571)
A Standardowe operatory kwerendowe LINQ (573)
B Kolekcje generyczne w .NET (587)
C Podsumowanie wersji środowisk .NET (603)
Skorowidz (613)
Oceny i opinie klientów: C# od podszewki. Wydanie II Jon Skeet (9)
Weryfikacja opinii następuję na podstawie historii zamówień na koncie Użytkownika umieszczającego opinię. Użytkownik mógł otrzymać punkty za opublikowanie opinii uprawniające do uzyskania rabatu w ramach Programu Punktowego.
(2)
(5)
(2)
(0)
(0)
(0)
Data dodania: 2015-11-04 Ocena: 6 Opinia potwierdzona zakupem
Krzysztof, Programista .NET
Data dodania: 2014-11-22 Ocena: 6 Opinia potwierdzona zakupem
Damian Daranowski, Programista C#
Data dodania: 2016-01-07 Ocena: 5 Opinia potwierdzona zakupem
Data dodania: 2015-12-27 Ocena: 5 Opinia potwierdzona zakupem
Piotr, Programista
Data dodania: 2014-01-30 Ocena: 5 Opinia potwierdzona zakupem
Sebastian Majsner, Programista
Data dodania: 2013-01-18 Ocena: 5 Opinia potwierdzona zakupem
Bogdan, programista
Data dodania: 2013-01-09 Ocena: 5 Opinia potwierdzona zakupem
Data dodania: 2014-08-04 Ocena: 4 Opinia niepotwierdzona zakupem
Roman, programista
Data dodania: 2013-09-05 Ocena: 4 Opinia niepotwierdzona zakupem
więcej opinii