Muutke küpsiste eelistusi

Building Web Applications with Visual Studio 2017: Using .NET Core and Modern JavaScript Frameworks 1st ed. [Pehme köide]

4.50/5 (4 hinnangut Goodreads-ist)
, ,
  • Formaat: Paperback / softback, 393 pages, kõrgus x laius: 254x178 mm, kaal: 8062 g, 113 Illustrations, color; 3 Illustrations, black and white; XXXIII, 393 p. 116 illus., 113 illus. in color., 1 Paperback / softback
  • Ilmumisaeg: 09-Jul-2017
  • Kirjastus: APress
  • ISBN-10: 1484224779
  • ISBN-13: 9781484224779
Teised raamatud teemal:
  • Pehme köide
  • Hind: 63,99 €*
  • * saadame teile pakkumise kasutatud raamatule, mille hind võib erineda kodulehel olevast hinnast
  • See raamat on trükist otsas, kuid me saadame teile pakkumise kasutatud raamatule.
  • Kogus:
  • Lisa ostukorvi
  • Tasuta tarne
  • Lisa soovinimekirja
Building Web Applications with Visual Studio 2017: Using .NET Core and Modern JavaScript Frameworks 1st ed.Suurem pilt
  • Formaat: Paperback / softback, 393 pages, kõrgus x laius: 254x178 mm, kaal: 8062 g, 113 Illustrations, color; 3 Illustrations, black and white; XXXIII, 393 p. 116 illus., 113 illus. in color., 1 Paperback / softback
  • Ilmumisaeg: 09-Jul-2017
  • Kirjastus: APress
  • ISBN-10: 1484224779
  • ISBN-13: 9781484224779
Teised raamatud teemal:
Püsilink: https://www.kriso.ee/db/9781484224779.html
Märksõnad:
Learn how to build web applications from three Microsoft MVPs. After building the data application layer using Entity Framework Core and a RESTful service using ASP.NET Core, you will then build the client side web application three ways: first, using ASP.NET Core, then using Angular 2, and, finally, using React.  You will be able to compare and contrast these UI frameworks and select the best one for your needs.

.NET Core is a complete rewrite of the popular .NET and its related frameworks. While many concepts are similar between .NET Core and the .NET 4.6 framework, there are revolutionary changes as well, including updates to Entity Framework Core and ASP.NET Core. The first section of this book covers the three main parts of building applications with C#: Entity Framework, ASP.NET Core Services, and ASP.NET Core Web Applications. 



There is also an explosion in popularity of JavaScript frameworks for client side development, and the authors cover two of the most popular UI frameworks. Start with TypeScript for developing clean JavaScript, along with a client side build tool such as Gulp, Grunt, and WebPack. Using the same data access layer and RESTful service from the .NET Core application, you can rebuild the UI using Angular 2. Then, repeat the process using React, for a true comparison of building client side applications using ASP.NET Core, Angular 2, and React. 



What You'll Learn











Understand the fundamentals of .NET Core and what that means to the traditional .NET developer

Build a data access layer with Entity Framework Core, a RESTful service with ASP.NET Core MVC, and a website with ASP.NET Core MVC and Bootstrap

Automate many build tasks with client side build utilities







Who This Book Is For

Intermediate to advanced .NET developers
About the Authors xix
About the Technical Reviewer xxi
Acknowledgments xxiii
Introduction xxv
Part I Visual Studio 2017 and .NET Core
1(208)
Chapter 1 Introducing Entity Framework Core
3(46)
The SpyStore Database
4(1)
Installing Visual Studio 2017 and .NET Core
5(3)
Installing Visual Studio
5(1)
Installing the .NET Core SDKs
6(2)
The NET Core Command Line Interface (CLI)
8(1)
Creating and Configuring the Solution and Projects
8(5)
Creating the Solution and Projects
8(3)
Changes to the Project Files
11(1)
Updating the Target Framework
11(2)
Working with NuGet Packages
13(1)
Manually Restoring Packages
13(1)
Adding the Project References
14(1)
Adding Entity Framework Core
14(3)
Adding EF Packages to the SpyStore.DAL Project
14(2)
Installing/Updating Packages Using the SpyStore.DALcsproj File
16(1)
Adding EF Packages to the SpyStoraModels Project
16(1)
Adding Packages to the SpyStore.DAL.Tests Project
17(1)
Building the Foundation
17(9)
Understanding the DbContext Class
17(5)
Building the Base Entity Class
22(2)
Adding the Category Model Class
24(2)
Adding the Categories DbSet
26(1)
Migrations
26(5)
Executing EF NET CLI Commands
27(1)
Creating the First Migration
27(2)
Applying the Migration
29(1)
Creating Migration SQL Scripts
30(1)
Understanding CRUD Operations Using Entity Framework
31(3)
Creating Records
31(1)
Reading Records
31(1)
Updating Records
32(1)
Deleting Records
33(1)
Unit Testing EF Core
34(7)
Creating the CategoryTests Class
34(3)
Testing EF CRUD Operations
37(4)
Adding the Core Repository Interface and Base Class
41(6)
Adding the IRepo Interface
41(2)
Adding the Base Repository
43(3)
Adding the Category Repository
46(1)
Summary
47(2)
Chapter 2 Building the Data Access Layer with Entity Framework Core
49(34)
The SpyStore Database
49(1)
Navigation Properties and Foreign Keys
50(1)
Handling Display Names
51(1)
Mixing EF with Stored Procedures and Functions
51(1)
Finishing the Model Classes
52(6)
Updating the Category Model
52(1)
Adding the Product Model
52(1)
Adding the Shopping Cart Record Model
53(1)
Adding the Order Model
54(1)
Adding the Order Detail Model
54(1)
Adding the Customer Model
55(1)
Updating the StoreContext
56(2)
Updating the Database to Match the Model
58(1)
Creating the Migration
58(1)
Deploying the Migration
58(1)
Adding the Stored Procedure and User Defined Function
58(2)
Adding a New Migration
59(1)
Implementing the Up() Method
59(1)
Implementing the Down() Method
60(1)
Updating the Database
60(1)
Adding the OrderTotal Calculated Field
60(1)
Updating the Order Class
60(1)
Making OrderTotal a Computed Column
60(1)
Adding a New Migration and Update the Database
61(1)
Automating the Migrations
61(1)
Adding the View Models
62(2)
The Product with Category View Model
62(1)
The Order Detail with Product Info View Model
63(1)
The Order with OrderDetails View Model
63(1)
The Cart Record with Product Info View Model
64(1)
Completing the Repositories
64(11)
Extending the Interfaces
64(3)
Adding/Updating the Repositories
67(8)
Initializing the Database with Data
75(6)
Creating Sample Data
76(2)
Using the Sample Data
78(2)
Using the Initializer in Tests
80(1)
Creating NuGet Packages for the Data Access Library
81(1)
Setting the NuGet Properties
81(1)
Creating the NuGet Packages
81(1)
Summary
82(1)
Chapter 3 Building the RESTful Service with ASP.NET Core MVC Services
83(36)
Introducing the MVC Pattern
83(1)
The Model
83(1)
The View
83(1)
The Controller
84(1)
Introducing ASP.NET Core MVC Web API
84(3)
ASP.NET Core and NET Core
84(1)
Dependency Injection
85(1)
Determining the Runtime Environment
85(1)
Routing
86(1)
Creating the Solution and the Core MVC Project
87(5)
Adding the Package Source for the Data Access Layer
90(1)
Updating and Adding NuGet Packages
90(1)
The ASP.NET Core "Super" Packages
91(1)
MVC Projects and Files
92(10)
The Program.cs File
92(1)
The appsettings.json File(s)
93(1)
The runtimeconfig.template.json File
94(1)
The Startup.cs File
94(6)
The Controllers Folder
100(1)
The wwwroot Folder
100(1)
The web.config File
101(1)
The launchsettings.json File
101(1)
Controllers and Actions
102(6)
Controllers
102(1)
Actions
102(2)
An Example Controller
104(4)
Exception Filters
108(2)
Creating the SpyStoreExceptionFilter
108(2)
Adding the Exception Filter for All Actions
110(1)
Building the Controllers
110(8)
The Category Controller
111(1)
The Customer Controller
112(1)
The Search Controller
113(1)
The Orders Controller
113(1)
The Product Controller
114(1)
The Shopping Cart Controller
115(3)
Using the Combined Solution
118(1)
The Unit Test Solution
118(1)
Summary
118(1)
Chapter 4 Introducing ASP.NET Core MVC Web Applications
119(38)
Introducing the "V" in ASP.NET Core MVC
119(1)
Creating the Solution and the Core MVC Project
120(3)
Updating and Adding NuGet Packages
122(1)
Routing Revisited
123(1)
The Route Table
123(1)
URL Templates and Default Values
123(1)
MVC Web Applications Projects and Files
124(5)
The Program.cs File
124(1)
The appsettings.json File
124(1)
The Startup.cs File
124(2)
The Controllers Folder
126(1)
The Views Folder
126(1)
The wwwroot Folder
126(3)
Controllers, Actions, and Views
129(6)
ViewResults
129(1)
Views
130(3)
Layouts
133(1)
Partial Views
134(1)
Sending Data to Views
134(1)
Package Management with Bower
135(2)
Updating and Adding Bower Packages
136(1)
Bower Execution
136(1)
Bundling and Minification
137(5)
The BundlerMinifier Project
137(1)
Configuring Bundling and Minification
137(2)
Visual Studio Integration
139(2)
.NET Core CLI Integration
141(1)
Creating the Web Service Locator
142(1)
Creating the IWebServiceLocator Interface
142(1)
Creating the WebServiceLocator Class
142(1)
Adding the WebServiceLocator Class to the Dl Container
143(1)
Creating the WebAPICalls Class to Call the Web API Service
143(8)
Creating the IWebApiCalls Interface
143(1)
Creating the Base Class Code
144(4)
Creating the WebApiCalls Class
148(3)
Adding WebApiCalls Class to the Dl Container
151(1)
Adding the Fake Authentication
151(3)
Building the Authentication Helper
151(1)
Adding the AuthHelper Class to the Dl Container
152(1)
Creating the Action Filter for the Fake Authentication
152(2)
Adding the Action Filter for All Actions
154(1)
Adding the View Models
154(2)
Summary
156(1)
Chapter 5 Building the SpyStore Application with ASP.NET Core MVC
157(52)
Tag Helpers
157(7)
Enabling Tag Helpers
159(1)
The Form Tag Helper
160(1)
The Anchor Tag Helper
160(1)
The Input Tag Helper
160(1)
The TextArea Tag Helper
161(1)
The Select Tag Helper
161(1)
The Validation Tag Helpers
162(1)
The Link and Script Tag Helpers
163(1)
The Image Tag Helper
163(1)
The Environment Tag Helper
163(1)
Custom Tag Helpers
163(1)
Building the Controllers
164(12)
The Products Controller
165(3)
The Orders Controller
168(2)
The Shopping Cart Controller
170(6)
Validation
176(7)
Server Side Validation
176(4)
Client Side Validation
180(2)
Updating the View Models
182(1)
View Components
183(4)
Building the Server Side Code
183(3)
Building the Client Side Code
186(1)
Invoking View Components
186(1)
Invoking View Components as Custom Tag Helpers
186(1)
Updating and Adding the Views
187(18)
The ViewImports File
187(1)
The Shared Views
187(8)
The Cart Views
195(5)
The Orders Views
200(3)
The Products Views
203(2)
Running the Application
205(2)
Using Visual Studio 2017
205(1)
Using the .NET Command Line Interface (CLI)
206(1)
Using the Combined Solutions
206(1)
Summary
207(2)
Part II Client-Side Tooling and JavaScript Frameworks
209(180)
Chapter 6 JavaScript Application Tools
211(30)
What Tools Are We Covering?
211(1)
Node.js
212(8)
Manually Installing Node.js
212(1)
Installing Node using the Chocolatey Package Manager
213(1)
Setting Up Visual Studio to Use the Latest Version of Node
213(1)
Getting Started with Node.js
214(1)
Introduction to NPM
215(2)
Saving Project Dependencies
217(1)
Executable Packages
218(2)
Installing Packages Locally vs. Globally
220(1)
Bower
220(7)
Bower and Visual Studio
222(1)
Installing Bower Prerequisites
222(1)
Installing Git
222(1)
Installing Bower
222(1)
Using Bower
223(1)
Installing Bower Packages
223(1)
Installing Bower Packages Using Visual Studio
224(3)
Gulp
227(6)
Installing Gulp
228(1)
Copying Files Using Gulp
229(1)
Dependencies in Gulp
230(1)
Task Runner Explorer Within Visual Studio
231(1)
Gulp Conclusion
232(1)
Module Loaders
233(7)
What Is a Module
234(1)
SystemJS
235(2)
WebPack
237(3)
Summary
240(1)
Chapter 7 Introduction to Typescript
241(40)
Why Typescript?
241(1)
TypeScript Basics
242(37)
An Overview of TypeScript Syntax
242(11)
Implementing a Basic TypeScript Application
253(1)
Setting Up a Sample Project
254(3)
Working with TypeScript Files
257(2)
NPM Packages
259(2)
Adding TypeScript
261(18)
Summary
279(2)
Chapter 8 Angular 2
281(48)
Creating a New Visual Studio Core Project
281(7)
Project Files
284(1)
Setting Up the Startup Class
284(2)
NPM Install
286(1)
Gulp Setup
287(1)
Typescript Setup
287(1)
Main SpyStore App Component Setup
288(5)
Creating the Root index.html Page
289(2)
Creating the Root App Component
291(1)
Creating the App Module
292(1)
Creating the Angular Bootstrap
292(1)
Core Concepts
293(10)
Application Initialization
293(1)
Components
294(1)
Services
295(2)
Templating
297(3)
Routing
300(3)
Building the SpyStore Angular App
303(25)
Adding Routing
303(3)
Connecting to Services
306(5)
Route Parameters
311(2)
Search Page
313(3)
Product Details Page
316(4)
Cart Page
320(6)
Checkout
326(2)
Summary
328(1)
Chapter 9 React
329(60)
Solution Overview
329(1)
Creating a New Visual Studio Core Project
330(2)
Project Files
332(1)
Setting Up the Startup Class
333(1)
NPM Packages
334(3)
TypeScript Setup
337(1)
Initial Project Folder
338(4)
WebPack
342(9)
Introduction to React
351(37)
Components
351(4)
Application Organization
355(1)
Models
356(1)
Services
357(4)
Initial Components
361(1)
Routing
362(3)
App Component
365(4)
CategoryLinks Component
369(2)
Products Component
371(5)
ProductDetail Component
376(4)
Cart Component
380(4)
CartRecord Component
384(3)
Additional Thoughts
387(1)
Summary
388(1)
Index 389
An international speaker, Microsoft MVP, ASPInsider, MCSD, CSM, and CSP, and a passionate member of the developer community, Phil Japikse has been working with .NET since the first betas, developing software for over 30 years, and heavily involved in the agile community since 2005. Phil is co-author of best selling "C# and the .NET 4.6 Framework", the Lead Director for the Cincinnati .NET Users Group and the Cincinnati Software Architect Group, co-hosts the Hallway Conversations podcast, founded the Cincinnati Day of Agile, and volunteers for the National Ski Patrol. Phil is also a published author with LinkedIn Learning. During the day, Phil works as an Enterprise Consultant and Agile Coach for large to medium firms throughout the US. Phil enjoys to learn new tech and is always striving to improve his craft. You can follow Phil on his blog, or on Twitter @skimedic.



Kevin Grossnicklaus At one point in his career Kevin was the youngster on most development teams.  He got his start developing with Visual Studio and managed .NET code during the early beta cycles in 2001.  In 2009, Kevin started his own software product development firm called ArchitectNow (www.architectnow.net).  At ArchitectNow, Kevin and his team specialize in a wide variety of tools while delivering applications across a variety of cloud and mobile platforms.   Born in rural Nebraska, Kevin has spent the last 20 years in St. Louis, Missouri where he lives with his wife Lynda and their three daughters: Alexis, Emily, and Hanna. He is an avid guitar player, fly fisherman, home brewer, and gamer (including everything from retro arcade games, to board games, to role playing games).  When not spending time on any of those hobbies he waits patiently for a second season of Firefly.



Ben Dewey is a former Microsoft MVP, and published author with over 18 years of experience writing applications and continually striving to create SOLID applications of the highest craftsmanship while paying special attention to clean User Experiences (UX). Ben is currently Creative Director at Tallan, Inc. and consults regularly in New York City and around the country on web- and cloud-based technologies. He has also worked to deploy numerous high-quality, engaging apps to the Windows Store. When hes not consulting, Ben is busy training, mentoring, blogging, and speaking at various conferences and community events around the country. Outside of work, Ben spends most of his time playing with his three young kids, working around the house, or, if its windy, kite surfing. You can find Ben online on Twitter (@bendewey), StackOverflow, GitHub, or on his blog at http://bendewey.com/.