Wstęp (15)

Rozdział 1. C# - teoria i praktyka (19)

• Wprowadzenie do języka C# (19)
  • Kolejne wersje języka C# (20)
    • C# 2.0 (.NET Framework 2.0, Visual Studio 2005) (20)
    • C# 3.0 (.NET Framework 3.5, Visual Studio 2008) (20)
    • C# 4.0 (.NET Framework 4.0, Visual Studio 2010) (21)
    • C# 5.0 (.NET Framework 4.5, Visual Studio 2012 oraz 2013) (21)
    • C# 6.0 (zapowiedź) (21)
  • Konwencje (21)
    • Cel stosowania konwencji (22)
    • Pliki a klasy i interfejsy (22)
    • Wcięcia (22)
    • Komentarze (23)
    • Deklaracje klas, interfejsów i metod (24)
    • Puste linie (24)
    • Nawiasy klamrowe (25)
    • Konwencje nazewnicze (25)
    • Pozostałe dobre praktyki (26)
  • Typy (26)
    • Deklaracja zmiennej (27)
    • Inicjalizacja zmiennej (28)
    • Słowa kluczowe (29)
    • Stałe i zmienne tylko do odczytu (29)
    • Literały (30)
    • Typ wyliczeniowy (31)
    • Konwersje typów i rzutowanie (31)
    • Opakowywanie (boxing) i rozpakowywanie (unboxing) (32)
    • Wartości zerowe oraz typy dopuszczające wartości zerowe (33)
    • Typy generyczne (34)
  • Tablice, łańcuchy i kolekcje (34)
    • Tablice (34)
    • Łańcuchy (36)
    • Kolekcje (37)
  • Operatory (38)
    • Operator trójargumentowy ?: (38)
    • Operator ?? (40)
  • Instrukcje sterujące (40)
    • Instrukcja if (40)
    • Instrukcja switch (41)
  • Instrukcje iteracyjne (43)
    • Pętla while (43)
    • Pętla do while (43)
    • Pętla for (44)
    • Pętla foreach (45)
    • Instrukcje skoku (45)
  • Klasy, obiekty, pola, metody i właściwości (46)
    • Klasy (46)
    • Obiekty (48)
    • Pola (48)
    • Metody (49)
    • Właściwości (52)
  • Podstawowe pojęcia związane z programowaniem obiektowym (53)
    • Abstrakcja (53)
    • Hermetyzacja (54)
    • Dziedziczenie (54)
    • Polimorfizm (55)
  • Przeciążanie operatorów (56)
    • Przeciążanie operatorów relacji (57)
    • Metody Equals() i GetHashCode() (57)
    • Przeciążanie operatorów konwersji (57)
    • Przeciążanie operatorów logicznych (58)
    • Przeciążanie operatorów arytmetycznych (60)
  • Przeciążanie metod (61)
  • Indeksatory (61)
  • Klasa System.Object (63)
  • Konstruktor i destruktor (64)
  • Garbage Collector (66)
    • Zasada działania GC (66)
    • Podział na generacje (przechowywanie obiektów w pamięci) (66)
  • Struktury (67)
  • Interfejsy (68)
    • Jawna implementacja interfejsu (69)
  • Zwalnianie zasobów niezarządzanych (70)
    • Interfejs IDisposable (70)
    • Słowo kluczowe using (71)
  • Delegaty, metody anonimowe, wyrażenia lambda i zdarzenia (72)
    • Delegaty (72)
    • Metody anonimowe (74)
    • Wyrażenia lambda (74)
    • Zdarzenia (75)
  • Dyrektywy preprocesora (76)
  • Wyjątki (77)
    • Zgłaszanie wyjątków (77)
    • Przepełnienia arytmetyczne (78)
    • Instrukcje checked i unchecked (78)
  • Przestrzenie nazw (79)
    • Zagnieżdżanie przestrzeni nazw (79)
    • Dyrektywa using (81)
    • Aliasy (82)
    • Zewnętrzne aliasy (83)
  • Typy, metody, klasy i kolekcje uogólnione (generyczne) (83)
    • Metody generyczne (84)
    • Klasy generyczne (84)
    • Kolekcje generyczne i interfejsy (86)
    • Interfejs IDictionary - słownik (86)
    • Interfejs IEnumerable (87)
    • Interfejs ICollection<> (87)
    • Interfejs IList<> (87)
    • Interfejs IQueryable<> (88)
  • Wyrażenia regularne (89)
  • Data i czas (90)
  • Operacje wejścia, wyjścia, foldery i pliki (92)
• Pozostałe elementy języka i nowości w wersji C# 5.0 (93)
  • Mechanizm refleksji i atrybuty (93)
    • Atrybuty (94)
  • IEnumerable a IEnumerator (96)
  • Iteratory i słowo kluczowe yield return (97)
  • Inicjalizatory obiektów i kolekcji (100)
  • Drzewa wyrażeń (101)
  • Metody rozszerzające (102)
  • Metody i klasy częściowe (103)
    • Metody częściowe (104)
  • Zmienne domniemane (105)
  • Typy anonimowe (105)
  • Słowa kluczowe this i base (106)
  • Typy dynamiczne (107)
  • Argumenty nazwane - Named Arguments (110)
  • Parametry opcjonalne (111)
  • Obsługa kontra- i kowariancji oraz słowa kluczowe in i out (111)
  • Słowa kluczowe is, as i typeof (114)
  • Leniwa inicjalizacja - Lazy Initialization (114)
  • Metody asynchroniczne - async i await (118)
  • Atrybuty Caller Info (119)
• Nowości w C# 6.0 (120)
  • Konstruktory pierwotne - Primary Constructors (120)
  • Automatyczna inicjalizacja właściwości - Initializers for Auto-properties (120)
  • Dyrektywa using dla składowych statycznych - Using Static Members (121)
  • Inicjalizatory słownikowe - Dictionary Initializer (121)
  • Deklaracje inline dla parametrów out - Inline Declarations for Out Params (122)
  • Wyrażenia dla właściwości - Property Expressions (122)
  • Wyrażenia dla metod - Method Expressions (122)
  • Modyfikator private protected (123)
  • Kolekcje IEnumerable jako parametr - Params for Enumerables (123)
  • Jednoargumentowe sprawdzanie wartości null - Monadic Null Checking (123)
  • Słowo kluczowe await w blokach catch i finally (124)
  • Filtry wyjątków - Exception Filters (124)
  • Literały binarne i separatory cyfr - Binary Literals, Digit Separators (124)

Rozdział 2. Wzorce architektoniczne (125)

• Architektura wielowarstwowa (125)
  • Architektura jednowarstwowa (126)
  • Architektura dwuwarstwowa (126)
  • Architektura trójwarstwowa (126)
  • Architektura n-warstwowa (126)
• MVC (127)
  • View (128)
  • Controller (128)
  • Model (128)
    • Domain Model, MVC Model i ViewModel - porównanie (128)
    • Model pasywny a model aktywny (129)
• MVP (129)
  • Model (130)
  • View (130)
  • Presenter (130)
• MVVM (131)
• MVC, MVP i MVVM (131)
• DDD (132)
• SOA (132)
• EDA (133)

Rozdział 3. Microsoft .NET Framework (135)

• Struktura .NET (135)
  • CLI (136)
  • CIL (137)
  • CLR (137)
  • DLR (137)
  • Elementy .NET wykorzystywane w ASP.NET MVC (138)
  • Implementacje .NET (138)
    • Projekt Mono (139)
• WPF (139)
• WCF (140)
  • Service Contract (140)
  • Operation Contract (140)
  • Data Contract (140)
  • Data Member (140)
  • WCF Endpoint = adres + binding + contract (142)
• Silverlight (142)
• Microsoft Azure (143)
  • Windows Azure Storage (143)
    • BLOB Storage (143)
    • Table Storage (143)
    • Queue Storage (143)
  • Hostowanie aplikacji w Azure (143)
    • Worker Role (144)
    • Web Role (144)
    • Web Site (144)
    • Virtual Machine (144)
  • Azure Service Bus (144)
    • Service Bus Relay (144)
    • Service Bus Queue (145)
    • Service Bus Topic (145)
• ASP.NET Web Forms (145)
• ASP.NET Web Pages (146)
• ADO.NET (146)
  • Obiekt DataSet (147)
    • Obiekty DataTable i DataRow (147)
    • Obiekt DataRelation (147)
    • Obiekt DataView (147)
  • .NET Framework Data Provider (147)
• LINQ (148)
  • LINQ to XML (148)
  • LINQ to Objects (149)
  • LINQ to SQL (149)
  • LINQ to DataSet (149)
  • LINQ to Entities (149)
  • Przykłady zapytań LINQ (150)
    • Składnia metod - Method Syntax (150)
    • Składnia zapytań - Query Syntax (151)
  • PLINQ (151)
• Narzędzia ORM w .NET (153)
  • Entity Framework (153)
  • NHibernate (153)
  • NHibernate 3 a Entity Framework 6 (154)
  • Alternatywa dla Entity Framework i NHibernate (154)

Rozdział 4. Entity Framework 6 (157)

• Podejście do pracy z modelem danych (157)
  • Porównanie różnych podejść (157)
  • Model dla podejścia Model First (158)
  • Model dla podejścia Code First (158)
• Nowości wprowadzane w kolejnych wersjach EF (159)
  • Nowości wprowadzone w EF 5 (159)
  • Nowości wprowadzone w EF 6 (160)
• Relacyjne bazy danych i EF (160)
  • Krótki opis baz relacyjnych (160)
  • Relacja "jeden do wielu" (161)
  • Relacja "jeden do jednego" (161)
  • Relacja "wiele do wielu" (162)
  • Relacje opcjonalne (165)
• Obiekty DbContext i DbSet (165)
  • DbContext i DbSet (165)
  • Metody Attach i Detach (165)
• Relacje poprzez klucz FK a relacje niezależne (obiektowe) (166)
  • Relacje poprzez klucz obcy - FK Association (166)
  • Relacje niezależne - Independent Association (167)
• Odpytywanie bazy danych za pomocą EF i LINQ (168)
  • Wczytywanie zachłanne - Eager Loading (168)
  • Wczytywanie leniwe - Lazy Loading (169)
  • Jawne ładowanie - Explicit Loading (170)
  • Problem N+1 (170)
  • Metoda AsNoTracking() (171)
  • Odroczone i natychmiastowe wykonanie (171)
  • Entity SQL (172)
  • Bezpośrednie zapytania SQL do bazy (Direct/RAW SQL) i procedury składowane w EF (173)
• Transakcje w EF (174)
• Śledzenie zmian (175)
  • Migawkowe śledzenie zmian - Snapshot Change Tracking (175)
  • Dynamiczne śledzenie zmian - Dynamic Change Tracking (proxy) (175)
• Zarządzanie operacjami współbieżnymi (176)
• Kaskadowe usuwanie - Cascade Delete (177)
• Strategie dziedziczenia w bazie danych - TPT, TPH i TPC (178)
  • TPH (178)
  • TPT (178)
  • TPC (179)
• SQL Logging (179)
• Code First Fluent API i Data Annotations (180)
• Migracje (182)
  • Metoda Seed (183)

Rozdział 5. ASP.NET MVC 5 (185)

• Kolejne wersje ASP.NET MVC (185)
  • ASP.NET MVC 1 (185)
  • ASP.NET MVC 2 (185)
  • ASP.NET MVC 3 (186)
  • ASP.NET MVC 4 (186)
  • ASP.NET MVC 5 (186)
  • ASP.NET MVC 6 (zapowiedź) (187)
• Konwencje w MVC (187)
  • Struktura projektu (187)
  • Konwencje a ASP.NET MVC (188)
• MVC Pipeline - ścieżka wywołań, handlery i moduły (189)
  • Ścieżka wywołań (189)
    • Pierwsze żądanie do aplikacji ASP.NET (189)
    • Podstawowe obiekty tworzone dla każdego żądania (189)
    • HttpApplication (190)
  • Uchwyty i moduły HTTP (193)
    • Uchwyty HTTP (193)
    • Moduły HTTP (193)
    • HttpHandler a HttpModule (193)
• Kontroler (194)
  • Typy rezultatu (194)
  • Parametry akcji (196)
  • Żądanie GET (196)
  • Żądanie POST (196)
  • Filtry akcji (197)
• Widok (200)
  • Zasady odnajdywania widoków (200)
  • Folder Shared (201)
  • Widoki częściowe (201)
  • Razor (202)
    • Dodatkowe właściwości silnika Razor (203)
  • ViewBag, ViewData i TempData (204)
  • Widoki typowane - Strongly Typed Views (205)
  • HTML helpery (208)
  • Paczki skryptów i minimalizacja - Script/CSS Bundling and Minification (209)
• Sekcje (211)
• Routing (214)
  • Kolejność w routingu (214)
  • Ignorowanie ścieżek (214)
  • Ograniczenia (215)
  • Routing na podstawie atrybutów (215)
    • Prefiksy (216)
    • Ograniczenia (217)
    • Nazywanie ścieżek i generowanie linków po nazwie ścieżki (217)
    • Obszary (217)
• Model (218)
  • ViewModel (218)
• Walidacja (222)
• MVC Scaffolding (223)
  • Generowanie kontrolerów (223)
  • Generowanie widoków (227)
• Metody synchroniczne i asynchroniczne w MVC (228)
  • Słowa kluczowe - Async, Await, Task (230)
• Cache (231)
  • Cachowanie po stronie serwera - Server Side Caching (231)
    • Atrybut OutputCache (232)
    • Cachowanie częściowe (233)
    • Cachowanie rozproszone (233)
  • Cachowanie po stronie klienta - Client Side Caching (234)
  • Cachowanie w HTML 5 (234)
    • HTML 5 Application Cache (234)
    • HTML 5 WebStorage (234)
• Code First Data annotations (235)
• Bezpieczeństwo (235)
  • SQL Injection (236)
  • Cross-Site Request Forgery (236)
  • Cross-Site Scripting (237)
  • Over-Posting - parametr binding (237)
• Obsługa, śledzenie i logowanie wyjątków w MVC (238)
  • Lokalne zarządzanie wyjątkami (238)
    • Blok try-catch (238)
    • Nadpisywanie metody OnException() w kontrolerze (238)
  • Globalne zarządzanie wyjątkami (239)
    • Klasa FilterConfig (239)
    • HandleError na poziomie kontrolerów i akcji (239)
    • Zwracanie widoków dostosowanych do konkretnych typów wyjątków (240)
  • Logowanie globalne za pomocą osobnych narzędzi (240)
• Identyfikacja, uwierzytelnianie i autoryzacja w MVC 5 (241)
  • Identyfikacja (241)
  • Uwierzytelnianie (241)
  • Autoryzacja (242)
    • Role w MVC (242)
  • Stan aplikacji, sesje i ciasteczka (242)
    • Stan aplikacji (242)
    • Ciasteczka (243)
    • Sesje (243)
  • OWIN (244)
  • ASP.NET Identity (244)
  • WIF i uwierzytelnianie za pomocą claimów (245)
    • Identity Provider, STS (246)
    • Strona ufająca - Relying Party (246)
  • Federated Authentication (247)
  • Windows ACS (248)
  • OpenId i OpenAuth (249)
    • OpenId (249)
    • OpenAuth (250)

Rozdział 6. Web serwisy i ASP.NET Web API 2 (251)

• Web API 2 (251)
• Web API a ASP.NET MVC (252)
• Web serwis, REST, SOAP i OData (253)
  • SOAP (253)
  • REST (253)
  • OData (254)
• CORS i JSONP (255)
  • JSONP (255)
  • CORS (255)
    • Uruchamianie CORS w Web API (256)
• Routing w Web API (257)
  • Mapowanie żądań na akcje bądź metody w kontrolerze Web API (257)
• Web API a Entity Framework i warstwa modelu (258)
• Typy rezultatu w Web API (258)
  • Typ void (259)
  • HttpResponseMessage (259)
  • IHttpActionResult (260)
  • Inny dowolny typ z aplikacji (260)
• Pobieranie danych z Web API (261)
  • Pobieranie danych po stronie serwera (.NET, C#) (261)
  • Pobieranie danych po stronie klienta (JavaScript, jQuery, AJAX) (261)
• Wersjonowanie w Web API (262)

Rozdział 7. Narzędzia, licencje i ceny (263)

• Serwer IIS (263)
  • Kategorie dla modułów dostępnych w IIS (263)
  • Pule aplikacji w IIS (264)
  • Przetwarzanie żądań w IIS (264)
• Microsoft SQL Server 2014 (264)
  • Licencjonowanie SQL Server 2014 (265)
  • Ceny licencji SQL Server 2014 (265)
  • Nowości w SQL Server 2014 (266)
• Windows Server 2012 (267)
  • Wersje Windows Server 2012 (267)
  • Licencjonowanie Windows Server 2012 (267)
  • Ceny Windows Server 2012 (268)
• Microsoft Visual Studio 2013 Ultimate (268)
  • Snippety (269)
  • Page Inspector (269)
  • Nowości w Visual Studio 2013 (269)
    • Poprawiony pasek przewijania (270)
    • Podgląd definicji (270)
    • Browser Link (270)
    • JSON Editor i JavaScript (271)
    • Powiązanie z Microsoft Azure (272)
    • Wsparcie dla GIT (272)
  • Najważniejsze skróty klawiszowe (272)

Rozdział 8. Aplikacja i wdrożenie (277)

• Wzorce projektowe i architektoniczne wykorzystywane w .NET (277)
  • Repozytorium (277)
  • Wzorzec IoC (277)
  • Repozytorium generyczne (278)
  • Wzorzec UnitOfWork (278)
• Przykładowa aplikacja (278)
  • Etap 1. Krok 1. Tworzenie nowego projektu i aktualizacja pakietów (279)
  • Etap 1. Krok 2. Utworzenie modelu danych (283)
    • Klasa Kategoria (286)
    • Klasa Ogloszenie_Kategoria (287)
    • Klasa Uzytkownik (287)
  • Etap 1. Krok 3. Tworzenie klasy kontekstu (290)
  • Etap 1. Krok 4. Przenoszenie warstwy modelu do osobnego projektu (294)
    • Dodawanie referencji pomiędzy projektami (296)
    • Ustawienie projektu startowego (297)
    • Instalacja bibliotek dla nowego projektu (298)
    • Przenoszenie plików z modelem do osobnej warstwy (projektu) (299)
  • Etap 1. Krok 5. Migracje (300)
    • Instalacja migracji (300)
    • Konfiguracja migracji (301)
    • Tworzenie migracji początkowej (302)
    • Uruchomienie pierwszej migracji (305)
    • Metoda Seed() (306)
    • Zmiany w modelu i kolejna migracja (309)
    • Praca z błędami i niespójnością w migracjach (310)
  • Etap 1. Podsumowanie (warstwa modelu i migracje) (311)
  • Etap 2. Krok 1. Dodawanie kontrolerów i widoków - akcja Index (311)
    • Dodawanie kontrolera z widokami (311)
    • Pierwsze uruchomienie aplikacji i routing (316)
    • Lista ogłoszeń (akcja Index) - aktualizacja widoku/wyglądu strony (317)
    • Lista ogłoszeń a pobieranie danych (321)
    • Optymalizacja listy ogłoszeń (322)
  • Etap 2. Krok 2. Debugowanie oraz metody AsNoTracking() i ToList() (324)
    • Sprawdzanie wartości zmiennych (325)
    • Metoda ToList() i odroczone wykonanie (Deferred Execution) (325)
    • Metoda AsNoTracking() (326)
  • Etap 2. Krok 3. Poprawa wyglądu i optymalizacja pod kątem SEO (329)
    • Poprawa wyglądu strony za pomocą Twitter Bootstrap (329)
    • Podświetlanie wierszy za pomocą CSS (330)
    • Optymalizacja pod kątem pozycjonowania - SEO (331)
  • Etap 2. Podsumowanie (333)
  • Etap 3. Krok 1. Poprawa architektury aplikacji (334)
    • Przeniesienie zapytania LINQ do osobnej metody (334)
    • Przeniesienie metody do repozytorium (334)
  • Etap 3. Krok 2. Zastosowanie kontenera Unity - IoC (336)
    • Wstrzykiwanie repozytorium poprzez konstruktor w kontrolerze (336)
    • Tworzenie interfejsu dla repozytorium (337)
    • Instalacja kontenera IoC Unity (338)
    • Wstrzykiwanie kontekstu do repozytorium (340)
    • Cykl życia obiektu a kontener IoC (341)
  • Etap 3. Podsumowanie (341)
  • Etap 4. Krok 1. Akcje Details, Create, Edit, Delete (342)
    • Details (342)
    • Metoda Details() w repozytorium (342)
    • Aktualizacja i optymalizacja SEO dla widoku Details (343)
    • Delete (345)
    • Create (353)
    • Edit (359)
  • Etap 4. Krok 2. Aktualizacja szablonu _Layout.cshtml (365)
  • Etap 4. Krok 3. Widoki częściowe - PartialViews (366)
  • Etap 4. Podsumowanie (369)
  • Etap 5. Bezpieczeństwo, uwierzytelnianie i autoryzacja dostępu (369)
    • Uwierzytelnianie i logowanie przez portale (369)
    • Autoryzacja - role (372)
    • Zabezpieczanie akcji (373)
  • Etap 5. Podsumowanie (380)
  • Etap 6. Stronicowanie i sortowanie (381)
    • Stronicowanie (381)
    • Sortowanie (388)
  • Etap 6. Podsumowanie (392)
  • Etap 7. Ogłoszenia użytkownika, kategorie, cache i ViewModel (393)
    • Zakładka Moje ogłoszenia (393)
    • Cache (394)
    • Kategorie (395)
    • Zastosowanie HTML helpera - Html.Action (402)
    • Zastosowanie ViewModel (403)
  • Etap 7. Podsumowanie (406)
  • Etap 8. Dane w JSON, zarządzanie relacją "wiele do wielu" i attribute routing (407)
    • PartialView a dane w formacie JSON lub XML (407)
    • Użycie attribute routingu (407)
    • Zarządzanie relacją "wiele do wielu" i autocomplete (409)
    • Dodatek na AspNetMvc.pl (409)
  • Etap 8. Podsumowanie (410)
  • Etap 9. Dodatek - tworzenie modelu dla podejścia Model First (410)
• Publikacja systemu na zewnętrznym serwerze hostingowym (415)
  • Dodawanie domeny (416)
  • Konfiguracja witryny (418)
  • Tworzenie bazy danych (421)
  • Tworzenie konta FTP (422)
  • Połączenie z bazą danych poprzez SQL Server Management Studio (422)
  • Wdrażanie aplikacji na serwer za pomocą Microsoft Visual Studio (423)

Dodatek A Zasady i metodologie w programowaniu (427)

• Zasady (427)
  • SOLID (427)
    • Zasada pojedynczej odpowiedzialności (SRP) (427)
    • Zasada otwarte-zamknięte (OCP) (428)
    • Zasada podstawienia Liskov (LSP) (428)
    • Zasada separacji interfejsów (ISP) (429)
    • Zasada odwrócenia zależności (DIP) (431)
  • GRASP (432)
    • Creator (433)
    • Information Expert (433)
    • Controller (433)
    • Low Coupling (433)
    • High Cohesion (434)
    • Polymorphism (434)
    • Pure Fabrication (434)
    • Indirection (435)
    • Protected Variations (435)
  • DRY (435)
  • KISS (436)
  • Rule of Three (436)
  • Separation of Concern (436)
  • YAGNI (437)
  • MoSCoW (437)
• Metodologie (437)
  • Manifest Agile (437)
  • Scrum (439)
  • eXtreme Programming (439)
  • TDD (440)

Dodatek B HTTP i SSL/TLS (443)

• HTTP (443)
• SSL/TLS (447)
  • Rodzaje certyfikatów (449)
  • Zakup certyfikatu SSL (450)
  • Aktywacja, walidacja i instalacja certyfikatu SSL (450)
  • Certyfikat w praktyce (450)

Dodatek C HTML 5 i CSS 3 (453)

• HTML 5 (453)
  • Sekcje (457)
  • Nowe typy pól formularza (458)
  • Atrybuty dla formularza (459)
  • Znaczniki (459)
  • Web Storage (461)
  • Server Side Events (461)
  • WebSockets (462)
  • Drag and Drop (463)
  • Geolokalizacja (465)
  • Walidacja (466)
• CSS 3 (466)
  • Nowe selektory (471)
  • Nowe własności (472)
  • Twitter Bootstrap (473)
• CSS 4 (473)

Dodatek D HTML DOM i JavaScript (477)

• HTML DOM (477)
  • Metody dostępne w DOM (477)
  • Właściwości dostępne w DOM (479)
  • Poziomy DOM (479)
• JavaScript (480)
  • Składnia języka (480)
  • Możliwości JavaScriptu (483)
  • JQuery (484)
    • Instalacja jQuery (485)
    • Selektory i filtry (485)
    • Zdarzenia (487)
    • Efekty w postaci animacji (488)
    • Metody (488)
    • Przechodzenie po elementach HTML (489)
  • JQuery UI (490)
  • JQuery Mobile (490)
  • AJAX (491)
    • JSON (492)
    • XMLHttpRequest (493)
    • AJAX w jQuery (494)

Dodatek E Bazy nierelacyjne (497)

• MongoDB (498)
• RavenDB (498)

Dodatek F Podstawy pozycjonowania w Google (499)

• Metatagi (499)
  • Znacznik
  • Opis strony (500)
  • Słowa kluczowe (500)
  • Wartości noindex i nofollow (500)
• Znaczniki HTML (500)
• Linkowanie (501)
• Zaplecze, katalogi stron i precle (502)
  • Skrypty katalogów (502)
  • Skrypty blogowe (503)
• Schematy linkowania (503)
  • Schemat koła (503)
  • Schemat piramidy (504)
  • Gwiazda (504)
  • Schematy mieszane (505)
• Linkowanie wewnętrzne (505)
• "Długi ogon" (505)
• Przyjazne adresy URL - Friendly URL (506)
• Pliki związane z pozycjonowaniem (506)
  • robots.txt (506)
  • sitemap.xml (507)
  • .htaccess (508)
• Filtry i kary (509)
  • Ban (509)
  • Sandbox (509)
• Zmiany algorytmu Google (510)
  • Panda (510)
  • Pingwin (510)
  • EDM (511)
• Narzędzia związane z pozycjonowaniem (511)
  • Google Analytics i Google Webmasters Tools (511)
  • Narzędzia do pracy z tekstem (511)
  • Systemy wymiany linków (512)
  • Półautomaty, "dodawarki" i automaty do postowania (512)
  • Inne narzędzia (513)

Skorowidz (515)

• Tytuł: C# 6.0 i MVC 5. Tworzenie nowoczesnych portali internetowych
• Autor: Krzysztof Żydzik, Tomasz Rak
• ISBN: 978-83-283-0864-0, 9788328308640
• Data wydania: 2015-02-26
• Format: Ebook
• Identyfikator pozycji: c6mvc5
• Wydawca: Helion