ASP.

NET Core Guide Notes

1. Fundamentals of ASP.NET Core

ASP.NET Core is a cross-platform framework for building web applications and APIs.

Key components:

- Controller: Handles HTTP requests.

- Middleware: Processing components that run request-response cycles.

- Views: Razor-based templates to render HTML responses.

- Program.cs: The entry point where the application is configured and started.

2. Controllers and Views

Controllers handle incoming requests and return views or JSON responses.

Example Controller:

```csharp

public class HomeController : Controller

public IActionResult Index() => View();

```

Example View (`Index.cshtml`):

```html

<h1>Welcome to ASP.NET Core!</h1>

Page 1
 ASP.NET Core Guide Notes

```

3. Dependency Injection (DI)

DI allows the automatic provision of services, promoting loose coupling.

Register services in `Startup.cs`:

```csharp

public void ConfigureServices(IServiceCollection services)

services.AddTransient<IMyService, MyService>();

```

Inject the service in the controller:

```csharp

public class HomeController : Controller

private readonly IMyService _myService;

public HomeController(IMyService myService) => _myService = myService;

```

4. Routing

Page 2
 ASP.NET Core Guide Notes

Routing defines URL patterns and their mappings to controllers and actions.

Example route in `Startup.cs`:

```csharp

public void Configure(IApplicationBuilder app)

app.UseRouting();

app.UseEndpoints(endpoints =>

endpoints.MapControllerRoute(

name: "default",

pattern: "{controller=Home}/{action=Index}/{id?}");

});

```

5. Model Binding

Model binding maps form data or route data to model properties.

Example model:

```csharp

public class Person

public string Name { get; set; }

Page 3
 ASP.NET Core Guide Notes

public int Age { get; set; }

```

Controller action to bind the model:

```csharp

public IActionResult Submit(Person person)

// Use the person object

return View();

```

6. Working with Models

Models define the structure and validation logic of data.

Data Annotations for validation:

```csharp

public class Person

[Required]

public string Name { get; set; }

[Range(18, 120)]

Page 4
 ASP.NET Core Guide Notes

public int Age { get; set; }

```

7. Views and Razor Syntax

Razor syntax allows embedding server-side code into HTML.

Example Razor code for displaying a model:

```csharp

<h1>@Model.Name</h1>

<p>Age: @Model.Age</p>

```

8. Working with Forms

Use HTML form elements with Razor to capture user input.

```html

<form asp-action="Submit">

<input asp-for="Name" />

<input asp-for="Age" />

<button type="submit">Submit</button>

</form>

```

Page 5
 ASP.NET Core Guide Notes

9. Validation

ASP.NET Core uses Data Annotations and ModelState validation.

Example in controller:

```csharp

public IActionResult Submit(Person person)

if (!ModelState.IsValid)

return View(person);

// Proceed if valid

return RedirectToAction("Success");

```

10. Data Annotations and Custom Validation

Data Annotations provide built-in validation like `[Required]`, `[Range]`, etc.

Custom Validation example:

```csharp

public class Person

Page 6
 ASP.NET Core Guide Notes

[CustomValidation(typeof(PersonValidator))]

public int Age { get; set; }

public class PersonValidator : ValidationAttribute

public override bool IsValid(object value)

int age = (int)value;

return age >= 18 && age <= 120;

```

11. Database First Approach (EF Core)

EF Core allows using existing databases to generate models and perform CRUD operations.

Example DbContext:

```csharp

public class ApplicationDbContext : DbContext

public DbSet<Person> Persons { get; set; }

```

Page 7
 ASP.NET Core Guide Notes

12. CRUD Operations with EF Core

CRUD operations:

Create:

```csharp

context.Persons.Add(new Person { Name = "John", Age = 25 });

context.SaveChanges();

```

Read:

```csharp

var person = context.Persons.Find(1);

```

Update:

```csharp

person.Name = "Updated Name";

context.SaveChanges();

```

Delete:

```csharp

var person = context.Persons.Find(1);

context.Persons.Remove(person);

Page 8
 ASP.NET Core Guide Notes

context.SaveChanges();

```

13. Handling Requests and Responses

Model Binding and ModelState validation handle incoming data and return appropriate responses.

Example controller:

```csharp

public IActionResult Submit(Person person)

if (!ModelState.IsValid)

return BadRequest(ModelState);

return Ok(person);

```

14. Sessions and Cookies

Sessions store data for the duration of a user session.

Example session:

```csharp

Page 9
 ASP.NET Core Guide Notes

HttpContext.Session.SetString("UserName", "JohnDoe");

```

Cookies store data that persists beyond the session:

```csharp

Response.Cookies.Append("UserName", "JohnDoe");

```

15. Uploading Files (Images)

File upload controller example:

```csharp

public IActionResult Upload(IFormFile file)

if (file != null)

var filePath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot/uploads", file.FileName);

using (var stream = new FileStream(filePath, FileMode.Create))

file.CopyTo(stream);

return Ok("File uploaded successfully.");

return BadRequest("File not uploaded.");

Page 10
 ASP.NET Core Guide Notes

```

16. State Management

TempData holds data for one request.

Example:

```csharp

TempData["Message"] = "This is a temp message.";

```

ViewData and ViewBag also manage short-term data:

```csharp

ViewBag.Message = "Hello from ViewBag!";

```

17. Working with Dependencies

DI is used to inject services.

Example:

```csharp

public class HomeController : Controller

private readonly IMyService _myService;

Page 11
 ASP.NET Core Guide Notes

public HomeController(IMyService myService) => _myService = myService;

```

18. Creating APIs in ASP.NET Core

Controllers with [ApiController]:

```csharp

[ApiController]

[Route("api/[controller]")]

public class ValuesController : ControllerBase

[HttpGet]

public IActionResult Get() => Ok(new { Name = "John", Age = 25 });

```

19. ASP.NET Core Middleware

Middleware pipeline:

```csharp

public void Configure(IApplicationBuilder app)

app.UseMiddleware<CustomMiddleware>();

app.UseRouting();

Page 12
 ASP.NET Core Guide Notes

app.UseEndpoints(endpoints => endpoints.MapControllers());

```

20. Configuration and Settings

AppSettings configuration:

```json

"Logging": {

"LogLevel": {

"Default": "Information"

```

21. Localization

Localization example:

```csharp

services.AddLocalization(options => options.ResourcesPath = "Resources");

```

22. Creating and Using Custom Middleware

Page 13
 ASP.NET Core Guide Notes

Custom Middleware example:

```csharp

public class CustomMiddleware

private readonly RequestDelegate _next;

public CustomMiddleware(RequestDelegate next) => _next = next;

public async Task Invoke(HttpContext context)

// Custom logic

await _next(context);

```

23. Authentication & Authorization

Authentication:

```csharp

services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)

.AddCookie();

```

Authorization:

```csharp

Page 14
 ASP.NET Core Guide Notes

services.AddAuthorization(options =>

options.AddPolicy("AdminOnly", policy => policy.RequireRole("Admin"));

});

```

24. Logging & Monitoring

Logging:

```csharp

services.AddLogging(builder => builder.AddConsole());

```

25. Caching

MemoryCache example:

```csharp

services.AddMemoryCache();

var cache = memoryCache.GetOrCreate("cacheKey", entry =>

entry.SlidingExpiration = TimeSpan.FromMinutes(5);

return "cached data";

});

```

Page 15
 ASP.NET Core Guide Notes

26. Security

XSS Protection and Content Security Policy:

```csharp

app.UseCspReportOnly(csp => csp.ScriptSources(s => s.Self()));

```

27. Exception Handling in ASP.NET Core

Custom Middleware for Exception Handling:

```csharp

public class CustomExceptionMiddleware

private readonly RequestDelegate _next;

public CustomExceptionMiddleware(RequestDelegate next) => _next = next;

public async Task Invoke(HttpContext context)

try

await _next(context);

catch (Exception ex)

context.Response.StatusCode = 500;

Page 16
 ASP.NET Core Guide Notes

await context.Response.WriteAsync("An error occurred.");

```

28. Dependency Injection (DI)

Registering services in `Startup.cs`:

```csharp

services.AddScoped<IMyService, MyService>();

```

Page 17