reklama - zainteresowany?

ASP.NET MVC 4. Zaawansowane programowanie - Helion

ASP.NET MVC 4. Zaawansowane programowanie
Autor: Adam Freeman, Steven Sanderson
Tytuł oryginału: Pro ASP.NET MVC 4 (Professional Apress)
Tłumaczenie: Robert Górczyński
ISBN: 978-83-246-7299-8
stron: 696, Format: 168x237, okładka: miękka
Data wydania: 2013-09-09
Księgarnia: Helion

Cena książki: 29,90 zł (poprzednio: 96,45 zł)
Oszczędzasz: 69% (-66,55 zł)

Dodaj do koszyka ASP.NET MVC 4. Zaawansowane programowanie

Tagi: .NET - Programowanie | programowanie-kupon

Kompendium wiedzy o platformie ASP.NET MVC 4!

ASP.NET MVC jest rewelacyjną alternatywą dla ASP.NET Web Forms. Pozwala na połączenie efektywności ze schludnością architektury model–widok–kontroler (MVC). Nowa wersja platformy - ASP.NET MVC 4 - to kolejny milowy krok w rozwoju platformy ASP.NET, stworzonej przez giganta z Redmond. Dzięki ASP.NET MVC 4 błyskawicznie stworzysz łatwe w utrzymaniu i rozwojowe aplikacje internetowe.

Lektura tej książki pozwoli Ci zapoznać się z technikami programowania w oparciu o testy (TDD). Przekonasz się, jak działa wzorzec MVC w praktyce. Ponadto uda Ci się szczegółowo poznać całą platformę ASP.NET MVC oraz zauważyć różnice, wady i zalety ASP.NET MVC względem klasycznego ASP.NET. Przekonasz się, jak zastosowanie filtrów może ułatwić Ci życie oraz jak niezwykle istotną kwestią jest zapewnienie bezpieczeństwa Twojej aplikacji. Książka ta jest doskonałym i kompletnym źródłem wiedzy na temat ASP.NET MVC. Obowiązkowa lektura dla każdego programisty tej platformy!

Sięgnij po książkę i sprawdź:

  • jak wykorzystanie architektury MVC może ułatwić Ci pracę
  • jaki wpływ na jakość Twojego kodu ma architektura MVC
  • jak zapewnić bezpieczeństwo Twojej aplikacji
  • w jaki sposób implementowana jest architektura MVC

Lektura obowiązkowa każdego programisty!

Dodaj do koszyka ASP.NET MVC 4. Zaawansowane programowanie

 

Osoby które kupowały "ASP.NET MVC 4. Zaawansowane programowanie", wybierały także:

  • ASP.NET MVC 4. Programowanie
  • ASP.NET 3.5. Programowanie

Dodaj do koszyka ASP.NET MVC 4. Zaawansowane programowanie

Spis treści

ASP.NET MVC 4. Zaawansowane programowanie -- spis treści

O autorze (17)

O recenzencie technicznym (19)

CZĘŚĆ I. WPROWADZENIE DO ASP.NET MVC 4 (21)

Rozdział 1. Zagadnienia ogólne (23)

  • Krótka historia programowania witryn WWW (23)
    • Tradycyjna technologia ASP.NET Web Forms (23)
    • Co poszło nie tak z ASP.NET Web Forms? (25)
  • Programowanie witryn WWW - stan obecny (25)
    • Standardy sieciowe oraz REST (26)
    • Programowanie zwinne i sterowane testami (26)
    • Ruby on Rails (27)
    • Sinatra (27)
    • Node.js (28)
  • Najważniejsze zalety ASP.NET MVC (28)
    • Architektura MVC (28)
    • Rozszerzalność (29)
    • Ścisła kontrola nad HTML i HTTP (29)
    • Łatwość testowania (30)
    • Zaawansowany system routingu (30)
    • Zbudowany na najlepszych częściach platformy ASP.NET (30)
    • Nowoczesne API (31)
    • ASP.NET MVC jest open source (31)
  • Kto powinien korzystać z ASP.NET MVC? (31)
    • Porównanie z ASP.NET Web Forms (31)
    • Migracja z Web Forms do MVC (32)
    • Porównanie z Ruby on Rails (32)
    • Porównanie z MonoRail (32)
  • Co nowego w ASP.NET MVC 4? (33)
  • Podsumowanie (33)

Rozdział 2. Pierwsza aplikacja MVC (35)

  • Przygotowanie stacji roboczej (35)
  • Tworzenie nowego projektu ASP.NET MVC (36)
    • Dodawanie pierwszego kontrolera (38)
    • Przedstawiamy ścieżki (40)
  • Generowanie stron WWW (41)
    • Tworzenie i generowanie widoku (41)
    • Dynamiczne dodawanie treści (43)
  • Tworzenie prostej aplikacji wprowadzania danych (45)
    • Przygotowanie sceny (45)
    • Projektowanie modelu danych (46)
    • Łączenie metod akcji (47)
    • Budowanie formularza (49)
    • Obsługa formularzy (51)
    • Dodanie kontroli poprawności (54)
    • Kończymy (60)
  • Podsumowanie (61)

Rozdział 3. Wzorzec MVC (63)

  • Historia MVC (63)
  • Wprowadzenie do wzorca MVC (64)
    • Budowa modelu domeny (64)
    • Implementacja MVC w ASP.NET (65)
    • Porównanie MVC z innymi wzorcami (65)
    • Przedstawiam wzorzec Smart UI (65)
  • Modelowanie domeny (68)
    • Przykładowy model domeny (69)
    • Wspólny język (69)
    • Agregaty i uproszczenia (70)
    • Definiowanie repozytoriów (71)
  • Budowanie luźno połączonych komponentów (73)
    • Wykorzystanie wstrzykiwania zależności (73)
    • Przykład specyficzny dla MVC (75)
    • Użycie kontenera wstrzykiwania zależności (75)
  • Zaczynamy testy automatyczne (76)
    • Zadania testów jednostkowych (77)
    • Zadania testów integracyjnych (84)
  • Podsumowanie (84)

Rozdział 4. Najważniejsze cechy języka (85)

  • Utworzenie przykładowego projektu (85)
  • Użycie automatycznie implementowanych właściwości (86)
  • Użycie inicjalizatorów obiektów i kolekcji (89)
  • Użycie metod rozszerzających (91)
    • Stosowanie metod rozszerzających do interfejsów (93)
    • Tworzenie filtrujących metod rozszerzających (95)
  • Użycie wyrażeń lambda (97)
  • Automatyczne wnioskowanie typów (100)
  • Użycie typów anonimowych (100)
  • Wykonywanie zapytań LINQ (102)
    • Opóźnione zapytania LINQ (105)
  • Użycie metod asynchronicznych (107)
    • Użycie słów kluczowych async i await (108)
  • Podsumowanie (109)

Rozdział 5. Praca z silnikiem Razor (111)

  • Tworzenie projektu (111)
    • Definiowanie modelu (111)
    • Definiowanie kontrolera (112)
    • Tworzenie widoku (113)
  • Korzystanie z obiektów modelu (114)
  • Praca z układami (116)
    • Tworzenie układu (116)
    • Stosowanie układu (118)
    • Użycie pliku ViewStart (119)
    • Użycie układów współdzielonych (119)
  • Użycie wyrażeń Razor (123)
    • Wstawianie wartości danych (124)
    • Przypisanie wartości atrybutu (125)
    • Użycie konstrukcji warunkowych (127)
    • Wyliczanie tablic i kolekcji (129)
    • Praca z przestrzenią nazw (132)
  • Podsumowanie (132)

Rozdział 6. Ważne narzędzia wspierające MVC (133)

  • Tworzenie przykładowego projektu (134)
    • Utworzenie klas modelu (134)
    • Dodanie kontrolera (135)
    • Dodanie widoku (136)
  • Użycie Ninject (136)
    • Zrozumienie problemu (137)
    • Zaczynamy korzystać z Ninject (139)
    • Konfiguracja wstrzykiwania zależności na platformie MVC (141)
    • Tworzenie łańcucha zależności (144)
    • Definiowanie wartości właściwości i parametrów (146)
    • Użycie łączenia warunkowego (148)
  • Testy jednostkowe w Visual Studio (149)
    • Tworzenie projektu testów jednostkowych (150)
    • Tworzenie testów jednostkowych (151)
    • Uruchamianie testów (nieudane) (154)
    • Implementacja funkcji (155)
    • Testowanie i poprawianie kodu (156)
  • Użycie Moq (157)
    • Zrozumienie problemu (158)
    • Dodawanie Moq do projektu Visual Studio (159)
    • Dodanie obiektu imitacyjnego do testu jednostkowego (160)
    • Tworzenie obiektu imitacji (161)
    • Tworzenie bardziej skomplikowanych obiektów Mock (163)
  • Podsumowanie (166)

Rozdział 7. SportsStore - kompletna aplikacja (167)

  • Zaczynamy (168)
    • Tworzenie rozwiązania i projektów w Visual Studio (168)
    • Dodawanie referencji (169)
    • Konfigurowanie kontenera DI (171)
    • Uruchamiamy aplikację (172)
  • Tworzenie modelu domeny (173)
    • Tworzenie abstrakcyjnego repozytorium (174)
    • Tworzenie imitacji repozytorium (174)
  • Wyświetlanie listy produktów (175)
    • Dodawanie kontrolera (176)
    • Dodawanie widoku (177)
    • Konfigurowanie domyślnej ścieżki (178)
    • Uruchamianie aplikacji (179)
  • Przygotowanie bazy danych (179)
    • Tworzenie bazy danych (180)
    • Definiowanie schematu bazy danych (181)
    • Dodawanie danych do bazy (182)
    • Tworzenie kontekstu Entity Framework (183)
    • Tworzenie repozytorium produktów (184)
  • Dodanie stronicowania (186)
    • Wyświetlanie łączy stron (188)
    • Ulepszanie adresów URL (195)
  • Dodawanie stylu (196)
    • Definiowanie wspólnej zawartości w pliku układu (197)
    • Dodanie stylów CSS (197)
    • Tworzenie widoku częściowego (199)
  • Podsumowanie (200)

Rozdział 8. SportsStore - nawigacja (201)

  • Dodawanie kontrolek nawigacji (201)
    • Filtrowanie listy produktów (201)
    • Ulepszanie schematu URL (203)
    • Budowanie menu nawigacji po kategoriach (207)
    • Poprawianie licznika stron (214)
  • Budowanie koszyka na zakupy (216)
    • Definiowanie encji koszyka (217)
    • Tworzenie przycisków koszyka (221)
    • Implementowanie kontrolera koszyka (222)
    • Wyświetlanie zawartości koszyka (224)
  • Podsumowanie (227)

Rozdział 9. SportsStore - ukończenie koszyka na zakupy (229)

  • Użycie dołączania danych (229)
    • Tworzenie własnego łącznika modelu (229)
  • Kończenie budowania koszyka (234)
    • Usuwanie produktów z koszyka (234)
    • Dodawanie podsumowania koszyka (234)
  • Składanie zamówień (237)
    • Rozszerzanie modelu domeny (237)
    • Dodawanie procesu zamawiania (238)
    • Implementowanie mechanizmu przetwarzania zamówień (241)
    • Rejestrowanie implementacji (243)
    • Zakończenie pracy nad kontrolerem koszyka (244)
    • Wyświetlanie informacji o błędach systemu kontroli poprawności (248)
    • Wyświetlanie strony podsumowania (249)
  • Podsumowanie (249)

Rozdział 10. SportsStore - administracja (251)

  • Dodajemy zarządzanie katalogiem (251)
    • Tworzenie kontrolera CRUD (251)
    • Tworzenie nowego pliku układu (253)
    • Implementowanie widoku listy (255)
    • Edycja produktów (260)
    • Tworzenie nowych produktów (271)
    • Usuwanie produktów (272)
  • Podsumowanie (275)

Rozdział 11. SportsStore - bezpieczeństwo i ostatnie usprawnienia (277)

  • Zabezpieczanie funkcji administracyjnych (277)
    • Realizacja uwierzytelniania z użyciem filtrów (278)
    • Tworzenie dostawcy uwierzytelniania (280)
    • Tworzenie kontrolera AccountController (281)
    • Tworzenie widoku (283)
  • Przesyłanie zdjęć (286)
    • Rozszerzanie bazy danych (286)
    • Rozszerzanie modelu domeny (287)
    • Tworzenie interfejsu użytkownika do przesyłania plików (288)
    • Zapisywanie zdjęć do bazy danych (289)
    • Implementowanie metody akcji GetImage (290)
    • Wyświetlanie zdjęć produktów (292)
  • Podsumowanie (293)

CZĘŚĆ II. ASP.NET MVC 4 - SZCZEGÓŁOWY OPIS (295)

Rozdział 12. Przegląd projektu MVC (297)

  • Korzystanie z projektów MVC z Visual Studio (297)
    • Przedstawienie konwencji MVC (301)
  • Debugowanie aplikacji MVC (302)
    • Tworzenie projektu (302)
    • Uruchamianie debugera Visual Studio (304)
    • Przerywanie pracy aplikacji przez debuger Visual Studio (306)
    • Użycie opcji Edit and Continue (310)
  • Podsumowanie (313)

Rozdział 13. Routing URL (315)

  • Tworzenie projektu routingu (316)
  • Wprowadzenie do wzorców URL (318)
  • Tworzenie i rejestrowanie prostej ścieżki (319)
    • Użycie prostej ścieżki (324)
  • Definiowanie wartości domyślnych (325)
  • Użycie statycznych segmentów adresu URL (327)
  • Definiowanie własnych zmiennych segmentów (331)
    • Użycie własnych zmiennych jako parametrów metod akcji (334)
    • Definiowanie opcjonalnych segmentów URL (335)
    • Definiowanie ścieżek o zmiennej długości (337)
    • Definiowanie priorytetów kontrolerów na podstawie przestrzeni nazw (339)
  • Ograniczenia ścieżek (342)
    • Ograniczanie ścieżki z użyciem wyrażeń regularnych (342)
    • Ograniczanie ścieżki do zbioru wartości (343)
    • Ograniczanie ścieżek z użyciem metod HTTP (343)
    • Definiowanie własnych ograniczeń (344)
  • Routing żądań dla plików dyskowych (346)
    • Konfiguracja serwera aplikacji (347)
    • Definiowanie ścieżek dla plików na dysku (349)
  • Pomijanie systemu routingu (350)
  • Podsumowanie (351)

Rozdział 14. Zaawansowane funkcje routingu (353)

  • Przygotowanie projektu (353)
  • Generowanie wychodzących adresów URL w widokach (354)
    • Użycie systemu routingu do wygenerowania wychodzącego adresu URL (354)
    • Użycie innych kontrolerów (357)
    • Przekazywanie dodatkowych parametrów (358)
    • Definiowanie atrybutów HTML (360)
    • Generowanie w pełni kwalifikowanych adresów URL w łączach (360)
    • Generowanie adresów URL (nie łączy) (361)
    • Generowanie wychodzących adresów URL w metodach akcji (362)
    • Generowanie adresu URL na podstawie wybranej ścieżki (363)
  • Dostosowanie systemu routingu (364)
    • Tworzenie własnej implementacji RouteBase (364)
    • Tworzenie własnego obiektu obsługi ścieżki (368)
  • Korzystanie z obszarów (369)
    • Tworzenie obszaru (369)
    • Wypełnianie obszaru (371)
    • Rozwiązywanie problemów z niejednoznacznością kontrolerów (373)
    • Generowanie łączy do akcji z obszarów (374)
  • Najlepsze praktyki schematu adresów URL (375)
    • Twórz jasne i przyjazne dla człowieka adresy URL (375)
    • GET oraz POST - wybierz właściwie (376)
  • Podsumowanie (376)

Rozdział 15. Kontrolery i akcje (377)

  • Wprowadzenie do kontrolerów (377)
    • Przygotowanie projektu (377)
    • Tworzenie kontrolera z użyciem interfejsu IController (378)
    • Tworzenie kontrolera przez dziedziczenie po klasie Controller (379)
  • Odczytywanie danych wejściowych (380)
    • Pobieranie danych z obiektów kontekstu (380)
    • Użycie parametrów metod akcji (382)
  • Tworzenie danych wyjściowych (383)
    • Wyniki akcji (385)
    • Zwracanie kodu HTML przez generowanie widoku (388)
    • Przekazywanie danych z metody akcji do widoku (391)
    • Wykonywanie przekierowań (394)
    • Zwracanie błędów i kodów HTTP (399)
  • Podsumowanie (401)

Rozdział 16. Filtry (403)

  • Użycie filtrów (403)
    • Wprowadzenie do czterech podstawowych typów filtrów (404)
    • Dołączanie filtrów do kontrolerów i metod akcji (405)
  • Tworzenie projektu (406)
  • Użycie filtrów autoryzacji (407)
    • Użycie własnego filtra autoryzacji (409)
    • Użycie wbudowanego filtra autoryzacji (409)
  • Użycie filtrów wyjątków (410)
    • Tworzenie filtra wyjątku (411)
    • Użycie filtra wyjątków (412)
    • Użycie widoku w celu reakcji na wyjątek (414)
    • Użycie wbudowanego filtra wyjątków (417)
  • Użycie filtrów akcji (419)
    • Implementacja metody OnActionExecuting (420)
    • Implementacja metody OnActionExecuted (421)
  • Używanie filtra wyniku (423)
    • Użycie wbudowanych klas filtrów akcji i wyniku (424)
  • Użycie innych funkcji filtrów (425)
    • Filtrowanie bez użycia atrybutów (426)
    • Użycie filtrów globalnych (427)
    • Określanie kolejności wykonywania filtrów (429)
  • Użycie filtrów wbudowanych (431)
    • Użycie filtra RequireHttps (432)
    • Użycie filtra OutputCache (432)
  • Podsumowanie (435)

Rozdział 17. Rozszerzanie kontrolerów (437)

  • Tworzenie projektu (437)
  • Tworzenie własnej fabryki kontrolerów (439)
    • Przygotowanie kontrolera zapasowego (441)
    • Utworzenie klasy kontrolera (442)
    • Implementacja innych metod interfejsu (442)
    • Rejestrowanie własnej fabryki kontrolerów (442)
  • Wykorzystanie wbudowanej fabryki kontrolerów (443)
    • Nadawanie priorytetów przestrzeniom nazw (444)
    • Dostosowywanie sposobu tworzenia kontrolerów w DefaultControllerFactory (445)
  • Tworzenie własnego obiektu wywołującego akcje (447)
  • Użycie wbudowanego obiektu wywołującego akcje (449)
    • Użycie własnych nazw akcji (450)
    • Selekcja metod akcji (451)
  • Poprawianie wydajności z użyciem specjalizowanych kontrolerów (456)
    • Użycie kontrolerów bezstanowych (456)
    • Użycie kontrolerów asynchronicznych (458)
  • Podsumowanie (463)

Rozdział 18. Widoki (465)

  • Tworzenie własnego silnika widoku (465)
    • Tworzenie przykładowego projektu (467)
    • Tworzenie własnej implementacji IView (468)
    • Tworzenie implementacji IViewEngine (468)
    • Rejestrowanie własnego silnika widoku (470)
    • Testowanie silnika widoku (470)
  • Korzystanie z silnika Razor (472)
    • Tworzenie przykładowego projektu (472)
    • Sposób generowania widoków przez Razor (473)
    • Konfigurowanie wyszukiwania lokalizacji widoków (475)
  • Dodawanie dynamicznych treści do widoku Razor (477)
    • Zastosowanie sekcji (478)
    • Użycie widoków częściowych (483)
    • Użycie akcji podrzędnych (486)
  • Podsumowanie (488)

Rozdział 19. Metody pomocnicze (489)

  • Tworzenie przykładowego projektu (489)
  • Tworzenie własnej metody pomocniczej (491)
    • Tworzenie wewnętrznej metody pomocniczej HTML (491)
    • Tworzenie zewnętrznej metody pomocniczej HTML (492)
    • Zarządzanie kodowaniem ciągów tekstowych w metodzie pomocniczej (496)
  • Użycie wbudowanych metod pomocniczych (500)
    • Przygotowania do obsługi formularzy (500)
    • Określenie ścieżki używanej przez formularz (507)
    • Użycie metod pomocniczych do wprowadzania danych (508)
    • Tworzenie znaczników select (513)
  • Podsumowanie (515)

Rozdział 20. Szablonowe metody pomocnicze (517)

  • Przegląd przykładowego projektu (517)
  • Używanie szablonowych metod pomocniczych (519)
    • Generowanie etykiety i wyświetlanie elementów (522)
    • Użycie szablonowych metod pomocniczych dla całego modelu (525)
  • Użycie metadanych modelu (527)
    • Użycie metadanych do sterowania edycją i widocznością (528)
    • Użycie metadanych dla etykiet (530)
    • Użycie metadanych wartości danych (531)
    • Użycie metadanych do wybierania szablonu wyświetlania (533)
    • Dodawanie metadanych do klasy zaprzyjaźnionej (535)
    • Korzystanie z parametrów typów złożonych (536)
  • Dostosowywanie systemu szablonowych metod pomocniczych (538)
    • Tworzenie własnego szablonu edytora (538)
    • Tworzenie szablonu ogólnego (539)
    • Wymiana szablonów wbudowanych (540)
  • Podsumowanie (541)

Rozdział 21. Metody pomocnicze URL i Ajax (543)

  • Przegląd i przygotowanie projektu (543)
  • Tworzenie podstawowych łączy i adresów URL (545)
  • Nieprzeszkadzający Ajax (547)
    • Tworzenie widoku formularza synchronicznego (547)
    • Włączanie i wyłączanie nieprzeszkadzających wywołań Ajax (549)
  • Użycie nieprzeszkadzających formularzy Ajax (550)
    • Przygotowanie kontrolera (550)
    • Tworzenie formularza Ajax (552)
    • Sposób działania nieprzeszkadzających wywołań Ajax (553)
  • Ustawianie opcji Ajax (554)
    • Zapewnienie kontrolowanej degradacji (554)
    • Informowanie użytkownika o realizowanym żądaniu Ajax (556)
    • Wyświetlanie pytania przed wysłaniem żądania (557)
  • Tworzenie łączy Ajax (558)
    • Zapewnienie kontrolowanej degradacji dla łączy (559)
  • Korzystanie z funkcji wywołania zwrotnego w Ajaksie (560)
  • Wykorzystanie JSON (562)
    • Dodanie obsługi JSON do kontrolera (562)
    • Przetwarzanie JSON w przeglądarce (564)
    • Przygotowanie danych do kodowania (565)
    • Wykrywanie żądań Ajax w metodach akcji (567)
  • Podsumowanie (570)

Rozdział 22. Dołączanie modelu (571)

  • Przygotowanie projektu (571)
  • Użycie dołączania modelu (573)
  • Użycie domyślnego łącznika modelu (575)
    • Dołączanie typów prostych (575)
    • Dołączanie typów złożonych (578)
    • Dołączanie tablic i kolekcji (584)
  • Jawne wywoływanie dołączania modelu (589)
    • Obsługa błędów dołączania modelu (590)
  • Dostosowanie systemu dołączania modelu (591)
    • Tworzenie własnego dostawcy wartości (591)
    • Tworzenie własnego łącznika modelu (594)
    • Rejestracja własnego łącznika modelu (596)
  • Podsumowanie (597)

Rozdział 23. Kontrola poprawności modelu (599)

  • Tworzenie projektu (599)
  • Jawna kontrola poprawności modelu (602)
    • Wyświetlenie użytkownikowi błędów podczas kontroli poprawności (603)
  • Wyświetlanie komunikatów kontroli poprawności (604)
    • Wyświetlanie komunikatów kontroli poprawności poziomu właściwości (608)
  • Użycie alternatywnych technik kontroli poprawności (608)
    • Kontrola poprawności w łączniku modelu (609)
    • Definiowanie zasad poprawności za pomocą metadanych (610)
    • Definiowanie modeli samokontrolujących się (616)
  • Użycie kontroli poprawności po stronie klienta (618)
    • Aktywowanie i wyłączanie kontroli poprawności po stronie klienta (618)
    • Użycie kontroli poprawności po stronie klienta (619)
    • Jak działa kontrola poprawności po stronie klienta? (620)
  • Wykonywanie zdalnej kontroli poprawności (621)
  • Podsumowanie (624)

Rozdział 24. Paczki i tryby wyświetlania (625)

  • Domyślne biblioteki skryptów (625)
  • Tworzenie przykładowej aplikacji (627)
  • Zarządzanie skryptami i stylami (630)
    • Profilowanie wczytywania skryptów i arkuszy stylów (630)
  • Używanie paczek stylów i skryptów (632)
    • Stosowanie paczek (635)
    • Używanie sekcji script (637)
    • Profilowanie wprowadzonych zmian (638)
  • Przygotowanie aplikacji dla urządzeń mobilnych (640)
    • Aplikacja standardowa (641)
    • Użycie widoków i układów przeznaczonych dla urządzeń mobilnych (642)
    • Tworzenie własnych trybów wyświetlania (643)
  • Podsumowanie (646)

Rozdział 25. Web API (647)

  • Zrozumienie Web API (647)
  • Tworzenie aplikacji Web API (648)
    • Tworzenie modelu i repozytorium (648)
    • Tworzenie kontrolera Home (650)
    • Utworzenie widoku i CSS (651)
  • Tworzenie kontrolera API (653)
    • Testowanie kontrolera API (655)
  • Jak działa kontroler API? (656)
    • Jak wybierana jest akcja kontrolera API? (657)
    • Mapowanie metod HTTP na metody akcji (657)
  • Tworzenie kodu JavaScript wykorzystującego interfejs Web API (658)
    • Tworzenie funkcji podstawowych (659)
    • Dodanie obsługi edycji nowych rezerwacji (661)
    • Dodanie obsługi usuwania rezerwacji (663)
    • Dodanie obsługi tworzenia rezerwacji (664)
  • Podsumowanie (665)

Rozdział 26. Wdrażanie aplikacji (667)

  • Przygotowanie aplikacji do dystrybucji (668)
    • Wykrywanie błędów widoku (668)
    • Wyłączanie trybu debugowania (670)
    • Usunięcie nieużywanych ciągów tekstowych połączenia (670)
  • Przygotowanie do użycia Windows Azure (671)
    • Tworzenie witryny internetowej i bazy danych (672)
    • Przygotowanie bazy danych do zdalnej administracji (674)
    • Tworzenie schematu bazy danych (674)
  • Wdrażanie aplikacji (676)
  • Podsumowanie (680)

Skorowidz (681)

Dodaj do koszyka ASP.NET MVC 4. Zaawansowane programowanie

Code, Publish & WebDesing by CATALIST.com.pl



(c) 2005-2021 CATALIST agencja interaktywna, znaki firmowe należą do wydawnictwa Helion S.A.