ASP.NET Fundamentals

Algemene omschrijving

In deze driedaagse training leren professionele webontwikkelaars geavanceerde ASP.NET Core-applicaties te ontwikkelen met behulp van .NET-hulpmiddelen en -technologieën.

Doelgroep

Deze training is bedoeld voor professionele webontwikkelaars die Microsoft Visual Studio gebruiken in een individuele of teamgebaseerde, kleine tot grote ontwikkelomgeving.

De training is geschikt voor kandidaten die interesse hebben in het ontwikkelen van geavanceerde webapplicaties, de weergegeven HTML volledig willen beheren en websites willen maken die de gebruikersomgeving, gegevenstoegang en applicatielogica van elkaar scheiden.

Leerdoelen

Na afloop van de training, heb jij de volgende kennis opgedaan:

• Begrip van de Microsoft Web Technology Stack en het kunnen kiezen welke technologie je wilt gebruiken bij het ontwikkelen van een programma.
• Een webapplicatie ontwerpen die aan een reeks zakelijke en functionele vereisten voldoet.
• Een website creëren met behulp van ASP.NET Core Razor Pages.
• Gebruikmaken van middleware en afhankelijkheidsinjectie in ASP.NET Core MVC-applicaties.
• Controllers in een MVC-toepassing gebruiken om gebruikersinteractie, -modellen en -weergaven te beheren.
• Webapplicaties creëren die de ASP.NET Core-routering gebruiken om een logische navigatiehiërarchie te bieden.
• Weergaven maken om gegevens in een MVC-toepassing weer te geven en te bewerken.
• MVC-modellen creëren die bedrijfslogica implementeren binnen methoden, eigenschappen en gebeurtenissen.
• Toegang krijgen tot een database vanuit een ASP.NET Core-programma met behulp van Entity Framework Core.
• JavaScript-code gebruiken om logica aan de clientzijde te implementeren om de reactiesnelheid van een ASP.NET-webapplicatie te verbeteren.

Voorkennis

Voordat jij deze training gaat volgen, raden wij aan dat je de volgende ervaring hebt:

• Ervaring met Microsoft Visual Studio en .NET.
• Kennis van programmeren in C# en concepten zoals lambda expressions, asynchrone programmering en LINQ.
• Enige ervaring met webontwikkeling met behulp van HTML, CSS en JavaScript.
• Inzicht in gangbare dataformaten zoals JSON en XML.

Onderwerpen

Module 1: Exploring ASP.NET Core

Microsoft ASP.NET Core web technologies can help you create and host dynamic, powerful, and extensible web applications. ASP.NET Core, is an open-source, cross-platform framework built on .NET, that allows you to build web applications. You can develop and run ASP.NET Core web applications on Windows, macOS, Linux, or any other platform that supports it. ASP.NET Core supports an agile, test-driven development cycle. It also allows you to use the latest HTML standards and front-end frameworks such as Angular, React, and more.

Lessons:

• Introducing Microsoft Web Technologies.
• Getting Started with Razor Pages in ASP.NET Core.
• Introducing ASP.NET Core MVC.

Lab 1: Exploring ASP.NET Core

• Exploring ASP.NET Core.

After completing this module, students will be able to:

• Understand the variety of technologies available in the Microsoft web stack.
• Describe the different programming models available for developers in ASP.NET.
• Describe the role of ASP.NET Core in the web technologies stack, and how to use ASP.NET Core to build web applications.

Module 2: Designing ASP.NET Core MVC Web Applications

Microsoft ASP.NET Core is a programming model that you can use to create powerful and complex web applications. However, all complex development projects, and large projects in particular, can be challenging and intricate to fully understand. Without a complete understanding of the purposes of a project, you cannot develop an effective solution to the customer’s problem. You need to know how to identify a set of business needs, and then make technology choices and plan the web application to meet those needs. The planning phase assures stakeholders that you understand their requirements and communicates the functionality of the web application, its user interface, structure, and data storage to the developers.

Lessons:

• Development Methodologies.
• Planning in the Project Design Phase.
• Choosing between Razor Pages and MVC.
• Designing Models, Controllers and Views.

Lab 1: Designing ASP.NET Core MVC Web Applications

• Designing ASP.NET Core MVC Web Applications.

After completing this module, students will be able to:

• Plan the overall architecture of an ASP.NET Core MVC web application and consider aspects such as state management.
• Plan the models, controllers, and views that are required to implement a given set of functional requirements.

Module 3: Using Razor Pages and Middleware

ASP.NET Core is a framework that allows us to build many kinds of applications. In this module we’ll first look in more detail at ASP.NET Razor Pages, as a quick way of building a web application that doesn’t require the complexity of the MVC model. Then we will look at middleware, which has a particular meaning in the context of the ASP.NET Core request pipeline, and potentially allows multiple separate requests to be handled in a completely different fashion and receive separate responses. You will learn how to leverage the ASP.NET Core framework to handle requests and responses via existing, and custom middleware, and how to configure services for use in middleware and throughout other parts of the application, such as controllers. We will also look at Services; classes that expose functionality which you can later use throughout different parts of the application. This is achieved without having to keep track of scope manually in each individual location, or instantiate any dependencies, by using Dependency Injection. Dependency Injection is a technique used by ASP.NET Core that allows us to add dependencies into the code without having to worry about instantiating objects, keeping them in memory, or passing along required dependencies.

Lessons:

• Using Razor Pages.
• Configuring Middleware.
• Configuring Services.

Lab 1: Using Razor Pages and Middleware

• Using Razor Pages and Middleware.

After completing this module, students will be able to:

• Build a simple web application using Razor Pages.
• Use existing middleware to set up an ASP.NET Core application.
• Understand the basic principles behind Dependency Injection, and how it is used in ASP.NET Core.

Module 4: Developing Controllers

ASP.NET Core MVC is a framework for building web applications by using the Model-View-Controller (MVC) architectural pattern. The Controller is essentially responsible for processing a web request by interacting with the model and then passing the results to the view. The model represents the business layern, and may include data objects, application logic, and business rules. The View uses the data that it receives from the controller to produce the HTML or other output that is sent back to the browser. In this module we will focus on developing controllers, specialized classes which are central to MVC applications. Understanding how controllers work is crucial to being able to create the appropriate model objects, manipulate them, and pass them to the appropriate views. Controllers have several methods that are called ‘actions’. When an MVC application receives a request, it finds which controller and action should handle the request. It determines this by using Uniform Resource Locator (URL) routing; another very important concept necessary for developing MVC applications. We will also see how to maximize the reuse of code in controllers by writing action filters.

Lessons:

• Writing Controllers and Actions.
• Configuring Routes.
• Writing Action Filters.

Lab 1: Developing Controllers

• Developing Controllers.

After completing this module, students will be able to:

• Add a controller to a web application that responds to user actions that are specified in the project design.
• Add routes to the ASP.NET Core routing engine and ensure that URLs are user-friendly in an MVC web application.
• Write code in action filters that runs before or after a controller action.

Module 5: Developing Views

Views are one of the three major components of the Model-View-Controller (MVC) programming model. You can define the user interface for your web application by creating views; a combination of HTML markup and C# code that runs on a web server. To create a view, you need to know how to write the HTML markup and C# code and use the various helper classes that are built into MVC. You also need to know how to create partial views and view components, which render sections of HTML that can be reused in your web application. We will also look in more detail at Razor markup syntax for embedding .NET based code into webpages.

Lessons:

• Creating Views with Razor Syntax.
• Using HTML Helpers and Tag Helpers.
• Reusing Code in Views.

Lab 1: Developing Views

• Developing Views.

After completing this module, students will be able to:

• Create an MVC view and add Razor markup to it to display data to users.
• Use HTML helpers and tag helpers in a view.
• Reuse Razor markup in multiple locations throughout an application.

Module 6: Developing Models

Most web applications interact with various types of data or objects. An e-commerce application, for example, manages products, shopping carts, customers, and orders. A social networking application might help manage users, status updates, comments, photos, and videos. A blog is used to manage blog entries, comments, categories, and tags. When you write a Model-View-Controller (MVC) web application, you create an MVC model to model the data for your web application. Within this model, you create a model class for each type of object. The model class describes the properties of each type of object and can include business logic that matches business processes. Therefore, the model is a fundamental building-block in an MVC application. We will also look at validation of user input.

Lessons:

• Creating MVC Models.
• Working with Forms.
• Validating User Input.

Lab 1: Developing Models

• Developing Models.

After completing this module, students will be able to:

• Add a model to an MVC application and write code in it to implement the business logic.
• Use display and edit data annotations.
• Validate user input with data annotations.

Module 7: Using Entity Framework Core in ASP.NET Core

Web applications often require a data store for dynamic information, for example to create a web application that changes continually in response to user input, administrative actions, and publishing events. The data store is usually a database, but other types of data stores are also used. In Model-View-Controller (MVC) applications, you can create a model that implements data access logic and business logic. Alternatively, you can separate business logic from data access logic by using a repository class that a controller can use to read from or write to an underlying data store. When you write an ASP.NET application you can use the Entity Framework Core (EF Core) and Language Integrated Query (LINQ) technologies, which make data access code very quick to write and simple to understand. In this module, you will see how to build a database-driven website in ASP.NET Core using Entity Framework.

Lessons:

• Introduction to Entity Framework Core.
• Working with Entity Framework Core.
• Using Entity Framework Core Database Providers.

Lab 1: Using Entity Framework Core in ASP.NET Core

• Using Entity Framework Core in ASP.NET Core.

After completing this module, students will be able to:

• Connect an application to a database to access and store data.
• Explain EF Core.
• Work with Entity Framework Core.

Module 8: Using Layouts, CSS and JavaScript in ASP.NET Core

While building web applications, you should apply a consistent look and feel to the application. You would typically include consistent header and footer sections and navigation controls in all the views. Microsoft ASP.NET Core uses special templates called layouts to achieve this, along with cascading style sheets (CSS) to enhance the appearance and usability of your web application. You can also create interactive HTML elements by using JavaScript to provide client-side code in your web application, along with client-side JavaScript libraries.

Lessons:

• Using Layouts.
• Using CSS.
• Using JavaScript.

Lab 1: Using Layouts, CSS and JavaScript in ASP.NET Core

• Using Layouts, CSS and JavaScript in ASP.NET Core.

After completing this module, students will be able to:

• Apply a consistent layout to ASP.NET Core MVC applications.
• Add JavaScript code to your web application.
• Use CSS stylesheets.