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

This commit is contained in:
2024-11-16 23:02:23 +03:30
parent e3da7b414c
commit db574288c5
19 changed files with 328 additions and 376 deletions
+3 -1
View File
@@ -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:**
+103 -228
View File
@@ -1,268 +1,143 @@
# Meeting Agenda
## 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
# Part 0: Roadmap of this Session
## 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...
## Give me feedback...
# Part 1: Understanding Models in ASP.NET Core MVC
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
## **0. Middleware and Request Pipeline**
![[Pasted image 20241105101014.png]]
![[Pasted image 20241105111037.png]]
- **Data Representation**: Models define the structure of data (often aligning with database tables).
- **Data Handling**: Models encapsulate data manipulation logic, like validation and relationships.
- **Data Transport**: Models pass data between the controller and the view.
![[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.
# 2. Properties in Models and Object-Oriented Programming (OOP) in `C#`
### **Basic Routing Structure**
To understand how models work, lets cover key OOP concepts in C#, which is essential for defining and managing models in ASP.NET Core MVC.
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.
### **Properties in C#**
### **Steps and Key Concepts in Routing**
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.
Heres an example of a basic `Product` model with properties:
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?}");
public class Product {
public int Id { get; set; }
// Auto-implemented property
public decimal Price { get; set; }
```
- **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
- **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. Lets use the `Product` model as our example.
```c#
public class Product
{
[HttpGet("all")]
public IActionResult GetAllProducts() { /*...*/ }
[HttpGet("{id}")]
public IActionResult GetProductById(int id) { /*...*/ }
public int Id { get; set; }
public string Name { get; set; }
public decimal Price { get; set; }
}
```
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.
1. **Create a Controller Action** In your controller, create an action that will pass the model data to the view.
```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**
Controllers are central in ASP.NET Core MVC and handle requests, retrieve data, and determine how its returned to the client.
### **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 HomeController : Controller
{
public IActionResult Index()
public class ProductsController : Controller {
public IActionResult Details()
{
return View();
var product = new Product{
Id = 1,
Name = "Laptop",
Price = 1500.00m
};
// Pass the model to the view
return View(product);
}
}
}
```
1. **Handling HTTP Methods with Attributes** Controllers use HTTP attributes like `[HttpGet]`, `[HttpPost]`, `[HttpPut]`, and `[HttpDelete]` to specify which HTTP methods they handle.
In this example, the `Details` action creates an instance of `Product` and passes it to the view using `View(product);`.
```c#
[HttpPost]
public IActionResult CreateProduct(Product product)
{
//Handle POST request
return RedirectToAction("Index");
}
3. **Strongly-Typed Views** When passing a model to a view, its 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>
```
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.
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 class ProductsController : Controller
{
private readonly IProductRepository _repository;
public ProductsController(IProductRepository repository)
public IActionResult List() {
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)
{
_repository = repository;
<li>@product.Name - @product.Price</li>
}
}
}
```
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#
public IActionResult EditProduct(int id, string name) {
// Parameters are bound from the URL }
</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**
Heres 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, youll 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. |
+197 -122
View 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 {
public int Id { get; set; }
[Required]
[StringLength(50)]
public string Name { get; set; }
[Range(0, 10000)]
public decimal Price { get; set; }
}
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)}");
```
- **Required**: Ensures the property has a value.
- **StringLength**: Restricts the maximum length.
- **Range**: Limits the value to a specified range.
- **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.
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.
### **Summary**
```c#
app.MapControllerRoute(name: "gallery", pattern: "Gallery/{action=Main}/{id?}",defaults: new { controller = "Gallery" });
- **Models** represent data and business logic.
- **Properties** in models define data structure and encapsulate fields.
- **Controller-View Interaction**: Pass models to views using `View(model);`.
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}");
```
# 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
This structure allows URLs like `/products/details/10/laptop`, which is clear and keyword-rich.
---
## **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 its 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 string Name { get; set; }
public decimal Price { get; set; }
public string FormattedPrice => $"${Price:N2}";
public IActionResult Index()
{
return View();
}
}
```
Using a view model keeps the domain model (`Product`) separate, especially useful when the view requires additional fields or formatting.
### Using the View Model in the Controller and View
In the controller:
1. **Handling HTTP Methods with Attributes** Controllers use HTTP attributes like `[HttpGet]`, `[HttpPost]`, `[HttpPut]`, and `[HttpDelete]` to specify which HTTP methods they handle.
```c#
public IActionResult Details()
[HttpPost]
public IActionResult CreateProduct(Product product)
{
var product = new Product { Id = 1, Name = "Laptop", Price = 1500.00m };
var productViewModel = new ProductViewModel
//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
{
private readonly IProductRepository _repository;
public ProductsController(IProductRepository repository)
{
Id = product.Id,
Name = product.Name,
Price = product.Price
};
return View(productViewModel); }
_repository = repository;
}
}
}
```
In the view:
```c#
@model ProductViewModel <h2>Product Details</h2> <p>Product Name: @Model.Name</p> <p>Price: @Model.FormattedPrice</p>
```
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**
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.
- **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 models properties.
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#
public IActionResult UpdatePrice(int id, decimal price) { // id and price are bound from the query string or route data }
public IActionResult EditProduct(int id, string name) {
// Parameters are bound from the URL }
```
- **From Form Data**: For form submissions, model binding maps form inputs to model properties by matching the names.
---
## **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**
Heres 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, youll 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
File diff suppressed because one or more lines are too long
@@ -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",