vault backup: 2024-11-16 23:02:23

2024-11-16 23:02:23 +03:30
parent e3da7b414c
commit db574288c5
19 changed files with 328 additions and 376 deletions
@@ -6,12 +6,14 @@
 	https://www.w3schools.com/html/default.asp
 - **CSS:** Understand how to style your webpage with CSS to make it visually appealing.
 	https://www.w3schools.com/css/default.asp
 - JavaScript
 	https://www.w3schools.com/js/default.asp
 ![[Pasted image 20241022115013.png]]
 ---
-# Part 2: Introduction to .NET and C#
+# Part 2: Introduction to .NET and `C#`
 https://www.w3schools.com/cs/cs_properties.php
 **Topics Covered:**
@@ -1,268 +1,143 @@
-# Meeting Agenda
+# Part 0: Roadmap of this Session
 ## The Practice
 ## Reviewing Last Meeting
 ## Explanation of Middleware 
 ## Routing 
 ### How to change the default routing
 ### Attribute Based Routing 
 ### Action Parameters 
 ### Query Parameters
 ## Different Kinds of Routing
 ## Show Roadmap 
 ### how far we've come
 ### the github projecet
 ### Ask ALI to talk about DI a bit
 ## Getting Started with MVC Projects 
 - [x] Directory Structure: Detailed explanation of the MVC directory 
 - [x] (Controllers, Views, Models, wwwroot) and the role of Program.cs in  configuration. 
 - [x] Routing and Controllers: Custom routing, attribute routing, and  handling various HTTP requests. 
 - [x] Actions in Controllers: Exploring different return types and handling  different HTTP requests. 
 ## Controllers and Routing
 - [x] Routing Basics: Attribute-based routing and custom route parameters. 
 - [x] Controller Actions: How to handle different return types like JSON, HTML, and redirect results.
 - [x] The address can contain static parts 
 - [ ] How to set the Default Page in ASP 
 ---
-## Have a talk about the projects and practices...
+# Part 1: Understanding Models in ASP.NET Core MVC
 ## Give me feedback...
 Models are a fundamental part of the MVC architecture, representing the data structure and logic of your application. They interact with the database and contain properties that hold data and methods that implement business logic.
 ### **Model Structure and Purpose**
-# Actual Content
+- **Data Representation**: Models define the structure of data (often aligning with database tables).
-## **0. Middleware and Request Pipeline**
+- **Data Handling**: Models encapsulate data manipulation logic, like validation and relationships.
-![[Pasted image 20241105101014.png]]
+- **Data Transport**: Models pass data between the controller and the view.
 ![[Pasted image 20241105111037.png]]
-![[Pasted image 20241105111022.png]]
+In ASP.NET Core MVC, models are typically located in a **Models** folder, and each model represents a specific data entity, like `Product`, `Customer`, or `Order`.
 ## **1. Routing in ASP.NET Core MVC**
 Routing is a mechanism to map incoming HTTP requests to specific controller actions. Understanding routing is crucial for managing URL patterns and making your app user-friendly and SEO-optimized.
 ### **Basic Routing Structure**
 Routes in ASP.NET Core are configured in `Program.cs` (or `Startup.cs` in earlier versions) using the `app.MapControllerRoute` method, which defines how URLs map to controllers and actions.
 ### **Steps and Key Concepts in Routing**
 1. **Define a Default Route** The default route defines the basic URL pattern that ASP.NET Core will follow.
 ```c#
 app.MapControllerRoute(name: "default", pattern: "{controller=Home}/{action=Index}/{id?}");
 ```
 - **Pattern**: 
 	- `{controller=Home}/{action=Index}/{id?}`:
 	- `{controller=Home}`: Specifies the controller, defaulting to `Home`.
 	- `{action=Index}`: Specifies the action method, defaulting to `Index`.
 	- `{id?}`: Optional parameter for passing an `id`.
 1. **Attribute Routing** Define routes directly within the controller using attributes. This is useful when each action needs a unique route.
 ```c#
 [Route("products")] 
 public class ProductsController : Controller 
 {     
 	[HttpGet("all")]
 	public IActionResult GetAllProducts() { /*...*/ }      
 	[HttpGet("{id}")]     
 	public IActionResult GetProductById(int id) { /*...*/ } 
 }
 ```
 1. **Custom Route Parameters and Constraints** You can add custom parameters and enforce constraints directly in the route to manage data types and URL patterns.
 ```c#
 app.MapControllerRoute(name: "custom", pattern: "{controller=Products}/{action=List}/{id:int:min(1)}");
 ```
 - **Constraints**: `{id:int:min(1)}` ensures `id` is an integer greater than or equal to 1.
 - Other constraints include `bool`, `datetime`, `guid`, `minlength(x)`, `maxlength(x)`, and custom regular expressions.
 1. **Setting Default Actions Based on Controller** To give specific controllers a unique default action, create additional routes before the default route.
 ```c#
 app.MapControllerRoute(name: "gallery", pattern: "Gallery/{action=Main}/{id?}",defaults: new { controller = "Gallery" });  
 app.MapControllerRoute(name: "default", pattern: "{controller=Home}/{action=Index}/{id?}");
 ```
 1. **SEO-Friendly and Readable URLs** For user-friendly URLs, use meaningful route names instead of parameters. This is particularly useful for e-commerce or content-heavy sites.    
 ```c#
 app.MapControllerRoute(name: "productDetail", pattern: "products/details/{id:int}/{name}");
 ```
 This structure allows URLs like `/products/details/10/laptop`, which is clear and keyword-rich.
 ---
-## **2. Controllers in ASP.NET Core MVC**
+# 2. Properties in Models and Object-Oriented Programming (OOP) in `C#`
-Controllers are central in ASP.NET Core MVC and handle requests, retrieve data, and determine how it’s returned to the client.
+To understand how models work, let’s cover key OOP concepts in C#, which is essential for defining and managing models in ASP.NET Core MVC.
-### **Controller Basics**
+### **Properties in C#**
- **Controller Naming**: Controllers usually end with "Controller" (e.g., `HomeController`, `ProductController`).
+Properties in C# provide a flexible way to access and modify the fields of a class. They use `get` and `set` accessors to control how data is read or assigned.
 - **Actions**: Methods within controllers are called action methods, typically returning a response to the user.
-### **Steps and Key Concepts in Controllers**
+Here’s an example of a basic `Product` model with properties:
-1. **Creating a Basic Controller** A controller inherits from the `Controller` base class and contains action methods.
+
 ```c#
 public class Product {
 public int Id { get; set; }
 // Auto-implemented property     
 public decimal Price { get; set; }
 ```
 - **Auto-implemented properties** (`Price`): Define a property without explicit backing fields, useful when no custom logic is needed.
 ### **Encapsulation and Access Modifiers**
 Encapsulation in OOP hides the internal state of an object and restricts access to its properties and methods. C# provides access modifiers like `public`, `private`, `protected`, and `internal` to control access.
 In ASP.NET Core MVC, models typically use **public properties** for easy access from other parts of the application (like controllers and views).
 ---
 # 3. Passing a Model to a View
 In ASP.NET Core MVC, data is passed from the controller to the view using models. You can pass a single model, a list of models, or even multiple models in complex scenarios.
 ### **Steps to Pass a Model from Controller to View**
 1. **Define the Model** First, define the model class. Let’s use the `Product` model as our example.
 ```c#
-public class HomeController : Controller 
+public class Product 
-{     
+{
-	public IActionResult Index()     
+	public int Id { get; set; }
-	{         
+	public string Name { get; set; }     
-		return View();     
+	public decimal Price { get; set; } 
 	} 
 }
 ```
-1. **Handling HTTP Methods with Attributes** Controllers use HTTP attributes like `[HttpGet]`, `[HttpPost]`, `[HttpPut]`, and `[HttpDelete]` to specify which HTTP methods they handle.
+1. **Create a Controller Action** In your controller, create an action that will pass the model data to the view.
 ```c# 
 [HttpPost] 
 public IActionResult CreateProduct(Product product) 
 {     
 //Handle POST request     
 	return RedirectToAction("Index"); 
 }
 ```
 3. **Using Dependency Injection in Controllers** Dependency injection is commonly used in ASP.NET Core to inject services (like a repository) into controllers, supporting clean code and testability.
 ```c#
-public class ProductsController : Controller 
+
-{     
+public class ProductsController : Controller {
-	private readonly IProductRepository _repository;
+	public IActionResult Details()
-    public ProductsController(IProductRepository repository)     
+	{
-    {         
+		var product = new Product{
-	    _repository = repository;     
+		Id = 1,
-	    } 
+		Name = "Laptop",
 		Price = 1500.00m
 	};
 // Pass the model to the view
 	return View(product);
 	}
-}
+ }
 ```
-1. **Defining Action Parameters** Parameters passed to action methods are automatically bound from the URL or query string. Use model binding to parse complex objects from the request body.
+In this example, the `Details` action creates an instance of `Product` and passes it to the view using `View(product);`.
 3. **Strongly-Typed Views** When passing a model to a view, it’s common to make the view "strongly typed" to enable IntelliSense and compile-time checking.
    - Open or create a view for your action (like `Details.cshtml`).
    - At the top of the view, specify the model type with the `@model` directive.
 ```
@model Product  <h2>Product Details</h2> <p>Product Name: @Model.Name</p> <p>Price: @Model.Price</p>
 ```
 In this example:
 - `@model Product` specifies that the view expects a `Product` model.
 - `@Model.Name` and `@Model.Price` retrieve properties of the `Product` instance.
 ### **Passing a List of Models**
 To pass a collection of models, define the controller action to return a list and set the view model type accordingly.
 ```c#
-public IActionResult EditProduct(int id, string name) {     
+public IActionResult List() {
-// Parameters are bound from the URL }
+	var products = new List<Product> {
 		new Product { Id = 1, Name = "Laptop", Price = 1500.00m },         new Product { Id = 2, Name = "Smartphone", Price = 800.00m }     
 	}; 
    return View(products); }
 ```
 In the `List.cshtml` view:
 ```c#
@model IEnumerable<Product>  
 	<h2>Product List</h2> 
 	<ul>
 	@foreach (var product in Model)
 	{
 	         <li>@product.Name - @product.Price</li>
    }
    </ul>
 ```
 This example uses `IEnumerable<Product>` as the model type to handle a list of `Product` objects.
 ---
 ## **3. Return Types in Controllers**
 Return types in ASP.NET Core MVC actions define how data is sent back to the client. Different return types offer flexibility for returning views, JSON, status codes, and redirects.
 ### **Common Return Types**
 1. **ViewResult** (`View()`)
    - Renders a Razor View.
    - Typically used in MVC applications where HTML is returned.
 `public IActionResult Index() {     return View(); }`
 1. **PartialViewResult** (`PartialView()`)
    - Renders a partial view, commonly used in AJAX requests.
 ```c#
 public IActionResult ProductListPartial() {     return PartialView("_ProductListPartial"); }
 ```
 2. **JsonResult** (`Json()`)
    - Returns JSON data, used often in API responses or AJAX calls.
 ```c#
 public JsonResult GetProductJson(int id) {     return Json(new { id, name = "Sample Product" }); }
 ```
 3. **ContentResult** (`Content()`)
    - Returns raw content like plain text or HTML.
 ```c#
 public ContentResult GetPlainText() 
 {     
 	return Content("Plain Text Content"); 
 }
 ```
 4. **FileResult** (`File()`)
    - Used to send files as a response, such as for downloading PDFs or images.
 ```c#
 public FileResult DownloadFile() {     byte[] fileBytes = System.IO.File.ReadAllBytes("sample.pdf");     return File(fileBytes, "application/pdf", "sample.pdf"); }
 ```
 5. **RedirectToActionResult** (`RedirectToAction()`)
 - Redirects to a different action.
 ```c#
 public IActionResult RedirectToHome() 
 {     
 	return RedirectToAction("Index", "Home"); 
 }
 ```    
 6. **StatusCodeResult** and **ObjectResult**
    - `StatusCodeResult`: Sends HTTP status codes like `404`, `500`.
    - `ObjectResult`: Often used in APIs to return a model or object with a status code.
 ```c#
 public IActionResult NotFoundResult() 
 {     
 	return StatusCode(404); 
 }
 ```
 7. **ChallengeResult** and **SignOutResult**
    - `ChallengeResult`: Used to trigger authentication challenges.
    - `SignOutResult`: Logs out the user.
 ```c#
 public IActionResult SignOutUser() { return SignOut(); }
 ```
 ---
 ## **Putting It All Together: A Complete Flow**
 Here’s how you can use routing, controllers, and return types together to create an application with clear structure and varied responses.
 1. **Configure Routing** in `Program.cs` with both default and custom routes.
 2. **Define Controllers** for different areas of the application, organizing actions based on functionality and HTTP methods.
 3. **Handle Different Requests and Return Types**:
    - For UI, use `ViewResult` or `PartialViewResult`.
    - For API endpoints, use `JsonResult` and `ObjectResult`.
    - Redirect or return status codes based on user actions.
 By mastering routing, controllers, and return types in this way, you’ll be able to create well-structured ASP.NET Core MVC applications that respond appropriately to a wide variety of requests. This roadmap provides a full foundation, allowing you to expand into more complex scenarios as you gain experience.
 | Return Type      | Description                                       |
 | ---------------- | ------------------------------------------------- |
 | `Ok()`           | Returns 200 OK with optional content.             |
 | `NotFound()`     | Returns 404 Not Found.                            |
 | `BadRequest()`   | Returns 400 Bad Request.                          |
 | `Unauthorized()` | Returns 401 Unauthorized.                         |
 | `Forbid()`       | Returns 403 Forbidden.                            |
 | `Created()`      | Returns 201 Created with a URI for the new item.  |
 | `NoContent()`    | Returns 204 No Content, typically for DELETE/PUT. |
 | `Redirect()`     | Redirects to another URL.                         |
 | `Content()`      | Returns plain text or other content.              |
 | `Json()`         | Returns JSON data.                                |
 | `File()`         | Returns a file.                                   |
@@ -1,164 +1,239 @@
 ## **7. Model Validation**
-ASP.NET Core MVC provides model validation, which helps ensure that data received from the user is valid.
+## **0. Middleware and Request Pipeline**
 ![[Pasted image 20241105101014.png]]
 ![[Pasted image 20241105111037.png]]
-### Example: Data Annotations
+![[Pasted image 20241105111022.png]]
 ## **1. Routing in ASP.NET Core MVC**
 Routing is a mechanism to map incoming HTTP requests to specific controller actions. Understanding routing is crucial for managing URL patterns and making your app user-friendly and SEO-optimized.
 ### **Basic Routing Structure**
 Routes in ASP.NET Core are configured in `Program.cs` (or `Startup.cs` in earlier versions) using the `app.MapControllerRoute` method, which defines how URLs map to controllers and actions.
 ### **Steps and Key Concepts in Routing**
 1. **Define a Default Route** The default route defines the basic URL pattern that ASP.NET Core will follow.
 ```c#
-public class Product {
+app.MapControllerRoute(name: "default", pattern: "{controller=Home}/{action=Index}/{id?}");
-	public int Id { get; set; }
+```
-	[Required]
+- **Pattern**: 
-	[StringLength(50)]
+	- `{controller=Home}/{action=Index}/{id?}`:
-	public string Name { get; set; }
+	- `{controller=Home}`: Specifies the controller, defaulting to `Home`.
-	[Range(0, 10000)]
+	- `{action=Index}`: Specifies the action method, defaulting to `Index`.
-	public decimal Price { get; set; } 
+	- `{id?}`: Optional parameter for passing an `id`.
-	}
+1. **Attribute Routing** Define routes directly within the controller using attributes. This is useful when each action needs a unique route.
 ```c#
 [Route("products")] 
 public class ProductsController : Controller 
 {     
 	[HttpGet("all")]
 	public IActionResult GetAllProducts() { /*...*/ }      
 	[HttpGet("{id}")]     
 	public IActionResult GetProductById(int id) { /*...*/ } 
 }
 ```
 1. **Custom Route Parameters and Constraints** You can add custom parameters and enforce constraints directly in the route to manage data types and URL patterns.
 ```c#
 app.MapControllerRoute(name: "custom", pattern: "{controller=Products}/{action=List}/{id:int:min(1)}");
 ```
- **Required**: Ensures the property has a value.
+- **Constraints**: `{id:int:min(1)}` ensures `id` is an integer greater than or equal to 1.
- **StringLength**: Restricts the maximum length.
+- Other constraints include `bool`, `datetime`, `guid`, `minlength(x)`, `maxlength(x)`, and custom regular expressions.
 - **Range**: Limits the value to a specified range.
-Validation errors are automatically displayed in views if you include `@Html.ValidationMessageFor` for each property or `@Html.ValidationSummary()` to show all errors.
+1. **Setting Default Actions Based on Controller** To give specific controllers a unique default action, create additional routes before the default route.
 ```c#
 app.MapControllerRoute(name: "gallery", pattern: "Gallery/{action=Main}/{id?}",defaults: new { controller = "Gallery" });  
-### **Summary**
+app.MapControllerRoute(name: "default", pattern: "{controller=Home}/{action=Index}/{id?}");
 ```
 1. **SEO-Friendly and Readable URLs** For user-friendly URLs, use meaningful route names instead of parameters. This is particularly useful for e-commerce or content-heavy sites.    
 ```c#
 app.MapControllerRoute(name: "productDetail", pattern: "products/details/{id:int}/{name}");
 ```
- **Models** represent data and business logic.
+This structure allows URLs like `/products/details/10/laptop`, which is clear and keyword-rich.
 - **Properties** in models define data structure and encapsulate fields.
 - **Controller-View Interaction**: Pass models to views using `View(model);`.
 # Side Notes
 catchall in routing
 appsettings.json
 query parameters 
 apply the teaching techniques 
 Razor View Engine 
 how to optimize the projects code
 Talk about lists C# 
 how to return custom view 
 assign C# variable and use it 
 ViewBag.... is a dynamic
 ViewBag.myName...
 hot reload...
 	what actually is viweBag, viewData
 Layouts..
 _ViewStart 
 _Shared 
 _MyLayout cshtml
 RenderBody
 RenderSection (required... )
 _ViewImports
 HtmlHelper / TagHelper 
 partial view 
 How to pass data to partial views
 Models and Model Types 
 1. Binding Models
 2. Application Models
 3. View Models
 https://learn.microsoft.com/en-us/aspnet/core/mvc/views/razor?view=aspnetcore-8.0
 ---
-## **5. View Models vs. Domain Models**
+## **2. Controllers in ASP.NET Core MVC**
-In some cases, the data needed by a view might be a combination of several models or require custom formatting. A **View Model** is a class specifically created to supply the view with only the necessary data.
+Controllers are central in ASP.NET Core MVC and handle requests, retrieve data, and determine how it’s returned to the client.
-### Creating a View Model
+### **Controller Basics**
 - **Controller Naming**: Controllers usually end with "Controller" (e.g., `HomeController`, `ProductController`).
 - **Actions**: Methods within controllers are called action methods, typically returning a response to the user.
 ### **Steps and Key Concepts in Controllers**
 1. **Creating a Basic Controller** A controller inherits from the `Controller` base class and contains action methods.
 ```c#
-public class ProductViewModel 
+public class HomeController : Controller 
-{ 
+{     
-	public int Id { get; set; }
+	public IActionResult Index()     
-	public string Name { get; set; }
+	{         
-	public decimal Price { get; set; }
+		return View();     
-	public string FormattedPrice => $"${Price:N2}"; 
+	} 
 }
 ```
-Using a view model keeps the domain model (`Product`) separate, especially useful when the view requires additional fields or formatting.
+1. **Handling HTTP Methods with Attributes** Controllers use HTTP attributes like `[HttpGet]`, `[HttpPost]`, `[HttpPut]`, and `[HttpDelete]` to specify which HTTP methods they handle.
-
+    
-### Using the View Model in the Controller and View
+```c# 
-
+[HttpPost] 
-In the controller:
+public IActionResult CreateProduct(Product product) 
-
+{     
-
+    //Handle POST request     
 	return RedirectToAction("Index"); 
 }
 ```
 3. **Using Dependency Injection in Controllers** Dependency injection is commonly used in ASP.NET Core to inject services (like a repository) into controllers, supporting clean code and testability.
 ```c#
-public IActionResult Details() 
+public class ProductsController : Controller 
-{
+{     
-	var product = new Product { Id = 1, Name = "Laptop", Price = 1500.00m };
+	private readonly IProductRepository _repository;
-	var productViewModel = new ProductViewModel 
+    public ProductsController(IProductRepository repository)     
-	{ 
+    {         
-		Id = product.Id,
+	    _repository = repository;     
-		Name = product.Name,
+	    } 
-		Price = product.Price
+	}
-	};      
+}
 	return View(productViewModel); }
 ```
-In the view:
+1. **Defining Action Parameters** Parameters passed to action methods are automatically bound from the URL or query string. Use model binding to parse complex objects from the request body.
-
+    
 ```c#
-@model ProductViewModel  <h2>Product Details</h2> <p>Product Name: @Model.Name</p> <p>Price: @Model.FormattedPrice</p>
+public IActionResult EditProduct(int id, string name) {     
 // Parameters are bound from the URL }
 ```
 View models allow you to tailor data specifically for the view, improving separation of concerns and maintainability.
 ---
-## **6. Model Binding in ASP.NET Core MVC**
+## **3. Return Types in Controllers**
-Model binding is a feature in ASP.NET Core that automatically maps HTTP request data to action parameters, making it easier to pass user inputs to models.
+Return types in ASP.NET Core MVC actions define how data is sent back to the client. Different return types offer flexibility for returning views, JSON, status codes, and redirects.
- **From URL or Query String**: If the action expects a model parameter and the URL includes a query string, model binding will automatically populate the model’s properties.
+### **Common Return Types**
 1. **ViewResult** (`View()`)
    - Renders a Razor View.
    - Typically used in MVC applications where HTML is returned.
 `public IActionResult Index() {     return View(); }`
 1. **PartialViewResult** (`PartialView()`)
    - Renders a partial view, commonly used in AJAX requests.
 ```c#
 public IActionResult ProductListPartial() {     return PartialView("_ProductListPartial"); }
 ```
 2. **JsonResult** (`Json()`)
    - Returns JSON data, used often in API responses or AJAX calls.
 ```c#
-public IActionResult UpdatePrice(int id, decimal price) {     // id and price are bound from the query string or route data }
+public JsonResult GetProductJson(int id) {     return Json(new { id, name = "Sample Product" }); }
 ```
 3. **ContentResult** (`Content()`)
    - Returns raw content like plain text or HTML.
 ```c#
 public ContentResult GetPlainText() 
 {     
 	return Content("Plain Text Content"); 
 }
 ```
 4. **FileResult** (`File()`)
    - Used to send files as a response, such as for downloading PDFs or images.
 ```c#
 public FileResult DownloadFile() {     byte[] fileBytes = System.IO.File.ReadAllBytes("sample.pdf");     return File(fileBytes, "application/pdf", "sample.pdf"); }
 ```
- **From Form Data**: For form submissions, model binding maps form inputs to model properties by matching the names.
+5. **RedirectToActionResult** (`RedirectToAction()`)
 - Redirects to a different action.
 ```c#
 public IActionResult RedirectToHome() 
 {     
 	return RedirectToAction("Index", "Home"); 
 }
 ```    
 6. **StatusCodeResult** and **ObjectResult**
    - `StatusCodeResult`: Sends HTTP status codes like `404`, `500`.
    - `ObjectResult`: Often used in APIs to return a model or object with a status code.
 ```c#
 public IActionResult NotFoundResult() 
 {     
 	return StatusCode(404); 
 }
 ```
 7. **ChallengeResult** and **SignOutResult**
    - `ChallengeResult`: Used to trigger authentication challenges.
    - `SignOutResult`: Logs out the user.
 ```c#
 public IActionResult SignOutUser() { return SignOut(); }
 ```
 ---
 ## **Putting It All Together: A Complete Flow**
 Here’s how you can use routing, controllers, and return types together to create an application with clear structure and varied responses.
 1. **Configure Routing** in `Program.cs` with both default and custom routes.
 2. **Define Controllers** for different areas of the application, organizing actions based on functionality and HTTP methods.
 3. **Handle Different Requests and Return Types**:
    - For UI, use `ViewResult` or `PartialViewResult`.
    - For API endpoints, use `JsonResult` and `ObjectResult`.
    - Redirect or return status codes based on user actions.
 By mastering routing, controllers, and return types in this way, you’ll be able to create well-structured ASP.NET Core MVC applications that respond appropriately to a wide variety of requests. This roadmap provides a full foundation, allowing you to expand into more complex scenarios as you gain experience.
-What is Business Logic
+
 | Return Type      | Description                                       |
 | ---------------- | ------------------------------------------------- |
 | `Ok()`           | Returns 200 OK with optional content.             |
 | `NotFound()`     | Returns 404 Not Found.                            |
 | `BadRequest()`   | Returns 400 Bad Request.                          |
 | `Unauthorized()` | Returns 401 Unauthorized.                         |
 | `Forbid()`       | Returns 403 Forbidden.                            |
 | `Created()`      | Returns 201 Created with a URI for the new item.  |
 | `NoContent()`    | Returns 204 No Content, typically for DELETE/PUT. |
 | `Redirect()`     | Redirects to another URL.                         |
 | `Content()`      | Returns plain text or other content.              |
 | `Json()`         | Returns JSON data.                                |
 | `File()`         | Returns a file.                                   |
@@ -9,45 +9,45 @@ build_property.EnforceExtendedAnalyzerRules =
 build_property._SupportedPlatformList = Linux,macOS,Windows
 build_property.RootNamespace = Wiki
 build_property.RootNamespace = Wiki
-build_property.ProjectDir = E:\TheCircle\TheCircleDocs\TheCircleProjects\ASP\02\Wiki\
+build_property.ProjectDir = E:\TheOrder\ASP.NET\ASP.NET\Repo\Sessions\Session02\Projects\Wiki\
 build_property.RazorLangVersion = 6.0
 build_property.SupportLocalizedComponentNames = 
 build_property.GenerateRazorMetadataSourceChecksumAttributes = 
-build_property.MSBuildProjectDirectory = E:\TheCircle\TheCircleDocs\TheCircleProjects\ASP\02\Wiki
+build_property.MSBuildProjectDirectory = E:\TheOrder\ASP.NET\ASP.NET\Repo\Sessions\Session02\Projects\Wiki
 build_property._RazorSourceGeneratorDebug = 
-[E:/TheCircle/TheCircleDocs/TheCircleProjects/ASP/02/Wiki/Views/Home/Index.cshtml]
+[E:/TheOrder/ASP.NET/ASP.NET/Repo/Sessions/Session02/Projects/Wiki/Views/Home/Index.cshtml]
 build_metadata.AdditionalFiles.TargetPath = Vmlld3NcSG9tZVxJbmRleC5jc2h0bWw=
 build_metadata.AdditionalFiles.CssScope = 
-[E:/TheCircle/TheCircleDocs/TheCircleProjects/ASP/02/Wiki/Views/Home/Person.cshtml]
+[E:/TheOrder/ASP.NET/ASP.NET/Repo/Sessions/Session02/Projects/Wiki/Views/Home/Person.cshtml]
 build_metadata.AdditionalFiles.TargetPath = Vmlld3NcSG9tZVxQZXJzb24uY3NodG1s
 build_metadata.AdditionalFiles.CssScope = 
-[E:/TheCircle/TheCircleDocs/TheCircleProjects/ASP/02/Wiki/Views/Home/Person2.cshtml]
+[E:/TheOrder/ASP.NET/ASP.NET/Repo/Sessions/Session02/Projects/Wiki/Views/Home/Person2.cshtml]
 build_metadata.AdditionalFiles.TargetPath = Vmlld3NcSG9tZVxQZXJzb24yLmNzaHRtbA==
 build_metadata.AdditionalFiles.CssScope = 
-[E:/TheCircle/TheCircleDocs/TheCircleProjects/ASP/02/Wiki/Views/Home/Privacy.cshtml]
+[E:/TheOrder/ASP.NET/ASP.NET/Repo/Sessions/Session02/Projects/Wiki/Views/Home/Privacy.cshtml]
 build_metadata.AdditionalFiles.TargetPath = Vmlld3NcSG9tZVxQcml2YWN5LmNzaHRtbA==
 build_metadata.AdditionalFiles.CssScope = 
-[E:/TheCircle/TheCircleDocs/TheCircleProjects/ASP/02/Wiki/Views/Shared/Error.cshtml]
+[E:/TheOrder/ASP.NET/ASP.NET/Repo/Sessions/Session02/Projects/Wiki/Views/Shared/Error.cshtml]
 build_metadata.AdditionalFiles.TargetPath = Vmlld3NcU2hhcmVkXEVycm9yLmNzaHRtbA==
 build_metadata.AdditionalFiles.CssScope = 
-[E:/TheCircle/TheCircleDocs/TheCircleProjects/ASP/02/Wiki/Views/Shared/_ValidationScriptsPartial.cshtml]
+[E:/TheOrder/ASP.NET/ASP.NET/Repo/Sessions/Session02/Projects/Wiki/Views/Shared/_ValidationScriptsPartial.cshtml]
 build_metadata.AdditionalFiles.TargetPath = Vmlld3NcU2hhcmVkXF9WYWxpZGF0aW9uU2NyaXB0c1BhcnRpYWwuY3NodG1s
 build_metadata.AdditionalFiles.CssScope = 
-[E:/TheCircle/TheCircleDocs/TheCircleProjects/ASP/02/Wiki/Views/_ViewImports.cshtml]
+[E:/TheOrder/ASP.NET/ASP.NET/Repo/Sessions/Session02/Projects/Wiki/Views/_ViewImports.cshtml]
 build_metadata.AdditionalFiles.TargetPath = Vmlld3NcX1ZpZXdJbXBvcnRzLmNzaHRtbA==
 build_metadata.AdditionalFiles.CssScope = 
-[E:/TheCircle/TheCircleDocs/TheCircleProjects/ASP/02/Wiki/Views/_ViewStart.cshtml]
+[E:/TheOrder/ASP.NET/ASP.NET/Repo/Sessions/Session02/Projects/Wiki/Views/_ViewStart.cshtml]
 build_metadata.AdditionalFiles.TargetPath = Vmlld3NcX1ZpZXdTdGFydC5jc2h0bWw=
 build_metadata.AdditionalFiles.CssScope = 
-[E:/TheCircle/TheCircleDocs/TheCircleProjects/ASP/02/Wiki/Views/Shared/_Layout.cshtml]
+[E:/TheOrder/ASP.NET/ASP.NET/Repo/Sessions/Session02/Projects/Wiki/Views/Shared/_Layout.cshtml]
 build_metadata.AdditionalFiles.TargetPath = Vmlld3NcU2hhcmVkXF9MYXlvdXQuY3NodG1s
 build_metadata.AdditionalFiles.CssScope = b-3c5kufsmdn
@@ -1,17 +1,17 @@
 {
  "format": 1,
  "restore": {
-    "E:\\TheCircle\\TheCircleDocs\\TheCircleProjects\\ASP\\02\\Wiki\\Wiki.csproj": {}
+    "E:\\TheOrder\\ASP.NET\\ASP.NET\\Repo\\Sessions\\Session02\\Projects\\Wiki\\Wiki.csproj": {}
  },
  "projects": {
-    "E:\\TheCircle\\TheCircleDocs\\TheCircleProjects\\ASP\\02\\Wiki\\Wiki.csproj": {
+    "E:\\TheOrder\\ASP.NET\\ASP.NET\\Repo\\Sessions\\Session02\\Projects\\Wiki\\Wiki.csproj": {
      "version": "1.0.0",
      "restore": {
-        "projectUniqueName": "E:\\TheCircle\\TheCircleDocs\\TheCircleProjects\\ASP\\02\\Wiki\\Wiki.csproj",
+        "projectUniqueName": "E:\\TheOrder\\ASP.NET\\ASP.NET\\Repo\\Sessions\\Session02\\Projects\\Wiki\\Wiki.csproj",
        "projectName": "Wiki",
-        "projectPath": "E:\\TheCircle\\TheCircleDocs\\TheCircleProjects\\ASP\\02\\Wiki\\Wiki.csproj",
+        "projectPath": "E:\\TheOrder\\ASP.NET\\ASP.NET\\Repo\\Sessions\\Session02\\Projects\\Wiki\\Wiki.csproj",
        "packagesPath": "C:\\Users\\LENOVO\\.nuget\\packages\\",
-        "outputPath": "E:\\TheCircle\\TheCircleDocs\\TheCircleProjects\\ASP\\02\\Wiki\\obj\\",
+        "outputPath": "E:\\TheOrder\\ASP.NET\\ASP.NET\\Repo\\Sessions\\Session02\\Projects\\Wiki\\obj\\",
        "projectStyle": "PackageReference",
        "fallbackFolders": [
          "C:\\Program Files (x86)\\Microsoft Visual Studio\\Shared\\NuGetPackages"
@@ -230,11 +230,11 @@
  "project": {
    "version": "1.0.0",
    "restore": {
-      "projectUniqueName": "E:\\TheCircle\\TheCircleDocs\\TheCircleProjects\\ASP\\02\\Wiki\\Wiki.csproj",
+      "projectUniqueName": "E:\\TheOrder\\ASP.NET\\ASP.NET\\Repo\\Sessions\\Session02\\Projects\\Wiki\\Wiki.csproj",
      "projectName": "Wiki",
-      "projectPath": "E:\\TheCircle\\TheCircleDocs\\TheCircleProjects\\ASP\\02\\Wiki\\Wiki.csproj",
+      "projectPath": "E:\\TheOrder\\ASP.NET\\ASP.NET\\Repo\\Sessions\\Session02\\Projects\\Wiki\\Wiki.csproj",
      "packagesPath": "C:\\Users\\LENOVO\\.nuget\\packages\\",
-      "outputPath": "E:\\TheCircle\\TheCircleDocs\\TheCircleProjects\\ASP\\02\\Wiki\\obj\\",
+      "outputPath": "E:\\TheOrder\\ASP.NET\\ASP.NET\\Repo\\Sessions\\Session02\\Projects\\Wiki\\obj\\",
      "projectStyle": "PackageReference",
      "fallbackFolders": [
        "C:\\Program Files (x86)\\Microsoft Visual Studio\\Shared\\NuGetPackages"
@@ -1,8 +1,8 @@
 {
  "version": 2,
-  "dgSpecHash": "PJ6EfvJ9NKlSFykOvE6RIi1tFLIcE5A9hW02dLCu0TC/8npfCCpTFbA4bA1qldPxj/xCXI1t1n6C81imG/YjBg==",
+  "dgSpecHash": "yJbRhM92p7chC/ssZXLS4dQkrtONSmBvzMqWTiPB1q4lzxPt9BwvbX1iHyUZObq4BKrrRzoCWzsSQ6536nnGQA==",
  "success": true,
-  "projectFilePath": "E:\\TheCircle\\TheCircleDocs\\TheCircleProjects\\ASP\\02\\Wiki\\Wiki.csproj",
+  "projectFilePath": "E:\\TheOrder\\ASP.NET\\ASP.NET\\Repo\\Sessions\\Session02\\Projects\\Wiki\\Wiki.csproj",
  "expectedPackageFiles": [
    "C:\\Users\\LENOVO\\.nuget\\packages\\microsoft.aspnetcore.authentication.negotiate\\6.0.22\\microsoft.aspnetcore.authentication.negotiate.6.0.22.nupkg.sha512",
    "C:\\Users\\LENOVO\\.nuget\\packages\\microsoft.aspnetcore.connections.abstractions\\6.0.22\\microsoft.aspnetcore.connections.abstractions.6.0.22.nupkg.sha512",