Скачать или смотреть Understanding the MVC Controller in ASP.NET

Dive into the world of ASP.NET MVC and learn about its controllers, including the role of dependency injection and how to manage context objects effectively.
---
This video is based on the question https://stackoverflow.com/q/63926257/ asked by the user 'Alisson Fabiano' ( https://stackoverflow.com/u/14198884/ ) and on the answer https://stackoverflow.com/a/63926740/ provided by the user 'Travis J' ( https://stackoverflow.com/u/1026459/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Trying to understand the controller of MVC

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding the MVC Controller in ASP.NET: A Beginner's Guide

If you're new to C# and the MVC (Model-View-Controller) framework in ASP.NET, you might find yourself confused about certain aspects of its architecture, particularly the controller. One common point of confusion for beginners arises from understanding how controllers manage data contexts. In this guide, we'll take a step-by-step look at what happens inside an MVC controller, especially focusing on the line where the context is defined. By the end, you'll have a clearer understanding of how these components fit together in your application.

The MVC Architecture

Before diving into specific lines of code, let’s briefly discuss what MVC architecture is and its purpose. MVC is a design pattern that separates an application into three interconnected components:

Model: Represents the data and the business logic of the application.

View: Displays the data (the UI) to the user.

Controller: Acts as an intermediary between the model and the view, handling user input and updating the model and view accordingly.

In an ASP.NET MVC application, when a user makes a request, it is routed to the appropriate controller based on the request URL.

An Example MVC Controller

Let's break down the code snippet you posted to understand its elements:

[[See Video to Reveal this Text or Code Snippet]]

Line Breakdown

Class Declaration: public class CategoriasController : Controller

This line declares a public controller class that inherits from the base Controller class provided by ASP.NET MVC. It typically signifies that this class is responsible for handling web requests for a specific area of your application, in this case, "Categorias" (Categories).

Private Variable: private readonly ApplicationDbContext _context;

Here, we are defining a private variable named _context of type ApplicationDbContext. This line may be confusing for beginners, but understanding it is crucial.

What is _context?

Variable/Field: _context is a private field. This means it's a variable associated with the instance of CategoriasController that won't be accessed outside of this class.

Type: It's of type ApplicationDbContext. Essentially, this class represents a session with the database, allowing you to query or save data.

Read-Only: The readonly modifier implies that _context can only be assigned at declaration or within the constructor. This is an important aspect of maintaining the integrity of your application's data context.

Dependency Injection Explained

Constructor: public CategoriasController(ApplicationDbContext context) {...}

This is the constructor for CategoriasController. When an instance of this controller is created, ASP.NET uses dependency injection (DI) to pass a fully instantiated ApplicationDbContext to it.

Inversion of Control: Dependency Injection aims to reduce the tight coupling between classes. Instead of the controller creating its own context (which would reduce flexibility), the context is provided to it. This pattern, known as inversion of control, allows your application to manage dependencies more effectively.

Summary of Functionality

Once the controller is instantiated and its context set up, it can use _context to interact with the database. Here's a brief summary of the overall workflow in this controller setup:

Request Handling: A specific URL hits the CategoriasController class based on defined routing rules.

Instantiation: The framework instantiates the class using reflection and sets _context using the DI container defined in global.asax.cs.

Action Method Call: The appropriate action method is called on the controller, allowing it to process the request and produce a response.

Conclusion

Underst