Projects in ASP.NET Core 2.0

Set up the Windows environment with Visual Studio for an ASP.NET Core 2.0 app, then explore the lifecycle, middleware, MVC, Razor pages, tag helpers, and Bootstrap integration.

Install visual studio community and enable web development with C#; install the asp.net core templates and create an empty net core web app to explore razor pages and mvc.

Trace the shift from ASP.NET 4.6 to ASP.NET Core 2.0, highlighting cross-platform runtime, MVC, Web API, and Razor Pages, and examining the simplified startup and middleware architecture.

Discover the structure of an ASP.NET Core 2.0 app, from solution layout and dependencies to program startup, middleware, and the dependency injection lifecycle.

Explore the lifecycle of an ASP.NET Core 2.0 application by stepping through program and startup, configuring environment, dependency injection, configuration files, middleware, and logging to understand startup flow.

Explains the middleware pipeline in ASP.NET Core 2.0, showing how requests flow through startup configuration, how MVC is added, and how the order of components controls execution.

Create an asp.net core mvc app by manually adding a home controller and index view, organize folders for controllers and views, and set up routing.

Add a Razor page to an ASP.NET Core 2.0 project, create a page model, pass an id with on get, and render data via the model.

Compare traditional HTML helpers with tag helpers by building the same form in a Razor page, and observe how tag helpers produce clean, HTML-like output.

Integrate bootstrap into an ASP.NET Core project by installing bootstrap via bower, configuring bower.json with jquery, adding static files middleware, and linking bootstrap CSS and JS in razor pages.

Explore ASP.NET Core 2.0 essentials, including environment setup with Visual Studio Community Edition and the shift from previous versions, templates for plain, MVC, and Razor pages, plus middleware and Bootstrap.

Build a Razor Pages contact form that sends emails to a Gmail account, using on post/get handlers, tag helpers, and a mail-sending package.

Enable less secure apps and disable two-step verification in Gmail, then create a Razor Pages project and install the MailKit NuGet package to send email from a contact form.

Build a backend mail send workflow by creating a contact model, handling post requests, and composing a MIME message to be sent via an SMTP client.

Build a two-column HTML form using tag helpers in ASP.NET Core 2.0, binding name, email, and message to a model for post and mail sending.

Submit a contact form in an ASP.NET Core 2.0 Razor Pages project and verify email delivery to Gmail, then troubleshoot postback, redirects, and message persistence using view data.

Develop a Razor Pages contact form in ASP.NET Core 2.0 that submits and sends email to Gmail using MailKit package. It covers tag helpers, form submission, and SMTP-based email delivery.

Build a rest api with get endpoints, use postman for feedback, implement versioned routing (v1 and v2), handle optional parameters, and return complex types via IActionResult in json.

Set up a core 2.0 web api project, explore a values controller, and test the api with Postman to observe json responses and binding behavior.

Add a produces attribute to specify application/xml for get methods and configure xml formatters in startup with input and output formatters to enable xml responses and test via postman.

Configure startup to map media types for SML and JSON, enabling users to dictate return formats in a RESTful ASP.NET Core 2.0 API.

Build and test a date API in ASP.NET Core 2.0 by adding a date controller, versioning routes, and handling optional parameters with basic binding.

Learn how to return complex objects via ASP.NET Core 2.0 by binding models, creating a payload class, and using status codes like 200, 400, and 501 in restful APIs.

Master building an api module that handles posts data, returns dates and complex types, leverages routing and query strings, enables versioning, uses status codes, and negotiates json or xml responses.

Build a database-driven shopping cart project that uses the in-city framework, populates orders, enables editing cart items, and presents a dynamic three-column product layout with images.

Create a new ASP.NET Core MVC project, scaffold an entity framework database, and configure a shopping cart data layer with cart, product, order, and order details models.

Define the data layer by implementing orders and order details with id, price, paid, and collections, then build the database context and configure DbContext for dependency injection.

Demonstrates creating a products controller in ASP.NET Core 2.0, wiring a shopping cart context, seeding initial products, and redirecting from home to the products index.

Create and wire a cart controller with add to cart, expand, and total price logic to support checkout messaging.

Finish the cart controller by implementing remove by product id and handling item existence, then implement checkout to compute total and create order details for saving.

Implement a products layout in an ASP.NET Core 2.0 project by configuring a shared layout, building products and cart views, and enabling add-to-cart actions.

Learn to implement a cart view in an ASP.NET Core 2.0 project: build a dynamic table showing product name, price, quantity, and total, with remove actions, checkout, and bootstrap styling.

Fix image path issues in the products view by matching image names to the static images folder. Validate cart operations, product listing, and checkout in an ASP.NET Core 2.0 project.

Explore a database-driven shopping cart project using Entity Framework, with three-color product layouts and images, cart item editing, and a modular architecture supported by a dedicated database context.

Build an authorized web site with admin and user roles using the ASP.NET Identity framework. Implement database migrations and EF identity scripts, login and register flows to manage role-based access.

Build an authentication site in ASP.NET Core 2.0 by adding a blank database, integrating Entity Framework Core tools, and configuring the connection string for migrations.

Configure ASP.NET Core 2.0 identity with entity framework by creating application user and db context, wiring services in startup, and preparing database migrations using the default connection string.

Execute migrations in an ASP.NET Core 2.0 project by creating and applying migration scripts with dotnet ef, then update the database to apply the changes.

Seed admin and user roles in the account controller and outline get and post registration actions with anonymous access, anti-forgery, and view model integration.

Implement registration flow by creating users with email as username and granting the first user admin. Assign roles, sign in, and redirect locally after successful registration.

Discover how to build add user methods in an ASP.NET Core 2.0 project, including get initialization and post submission with admin authorization, user creation, role assignment, and redirect flows.

Explore the ASP.NET Core 2.0 login flow by implementing get and post login actions, clearing external cookies, validating models, signing in with Remember Me, and handling errors.

complete the account controller by implementing logout, signing out the user, and redirecting to the home index; handle identity errors and prepare a login partial and home view wiring.

Create the home view by leveraging a reusable form template, build a nav bar with user greeting, and display admin controls using the user manager and role checks.

Finish the remaining account views by implementing the registration form using a reusable pattern, wiring identity, user manager, and roles. Run and test authentication with admin and user roles.

Create a database to store users and roles with entity framework, generate migrations via dotnet ef, and implement ASP.NET Identity for login, registration, and role-based access in the account controller.

Explore core 2 differences and four projects—from razor pages forms with Gmail submission to a web API returning time—then a shopping cart with entity framework and identity-driven authentication.