Here's a refined version of the content:
SLHDotNetCore
│
├── SLHDotNetCore.ConsoleApp
│ ├── Program.cs
│ └── (Other files related to the console application)
│
├── SLHDotNetCore.RestApi
│ ├── Controllers
│ ├── Models
│ ├── DataAccess
│ └── (Other files related to the REST API)
│
└── (Other project folders)
- 2024-03-30: Microsoft SQL Server & Visual Studio Installation
- 2024-04-04: C# Basics & SQL Basics, VS Code Installation, Additional Tools (JetBrains DatGrip, Rider, Beyond Compare)
- 2024-04-09: Console Application Development
- 2024-04-10: Ado.Net CRUD Implementation
- 2024-04-22: Dapper CRUD Implementation
- 2024-04-23: EF Core Integration
- 2024-04-24: ASP.NET Core Web API Blog CRUD, Console App Folder Structure
- 2024-04-29: ASP.NET Core Web API Dapper CRUD Implementation
- 2024-05-01: ASP.NET Core Web API with Ado.Net CRUD, Dapper & Ado.Net Custom Services
- 2024-05-07: N-Layer Architecture, Burma Project API Discussion, JSON Data to API
- 2024-05-08: Console App CRUD via HttpClient API
- 2024-05-09: Console App CRUD via RestClient (RestSharp)
- 2024-05-13: Myanmar Proverbs API, Pizza API
- 2024-05-15: Query-based Pizza API with Dapper Service
- 2024-05-15: Console App CRUD via Refit, Introduction to Windows Forms
- 2024-05-15: .NET Framework vs .NET Core vs .NET, Windows Forms "Hello World"
- 2024-05-15: Windows Forms Blog - Create
- 2024-05-27: Windows Forms Blog - List
- 2024-05-28: Windows Forms Blog - Edit, Delete
- 2024-05-28: If Case, Switch Case, SQL Injection, N-Layer Architecture
- 2024-05-29: JavaScript Blog CRUD
- 2024-05-29: HTML + JavaScript Blog CRUD
- 2024-06-03: jQuery Plugins (SweetAlert, Notiflix)
- 2024-06-04: jQuery Plugins - DataTable, Date Picker, Ladda Button, iCheckbox, Custom Confirm Message
- 2024-06-10: Dependency Injection Concepts & Implementation
- 2024-06-11: JetBrains Rider Installation
- 2024-07-08: ASP.NET Core Minimal API CRUD, ASP.NET Core MVC Blog Operations (List, Create, Edit, Update, Delete)
- 2024-07-08: EF Core AsNoTracking
- 2024-07-31: ASP.NET Core MVC Ajax (Issues - Refer to 2024-08-18)
- 2024-08-03: ASP.NET Core Apex Chart - Pie Chart, Chart.js, HighCharts, CanvasJS, Text Log, DB Log Parts 1 & 2, Realtime SignalR Chat & Chart
- 2024-08-04: EF Core Database First Approach
- 2024-08-11: ASP.NET Core MVC with Admin LTE UI, Blazor Server & WebAssembly (Client + Server)
- 2024-08-18: ASP.NET Core MVC Ajax - V2
- Showcases CRUD operations using Ado.Net, Dapper, and EF Core.
- Built with ASP.NET Core Web API, integrating CRUD operations with Ado.Net, Dapper, and EF Core.
-
Code First Approach
-
Database First Approach
-
Commands to scaffold models from an existing database:
Scaffold-DbContext "Server=.;Database=DotNetTrainingBatch4;User ID=sa;Password=sasa@123;TrustServerCertificate=True;" Microsoft.EntityFrameworkCore.SqlServer -OutputDir Models -Context AppDbContext
Alternate command:
dotnet ef dbcontext scaffold "Server=.;Database=DotNetTrainingBatch4;User ID=sa;Password=sasa@123;TrustServerCertificate=True;" Microsoft.EntityFrameworkCore.SqlServer -o Models -c AppDbContext -f
- Blazor Server
- Blazor WebAssembly (Client + Server)
- Integrated with ASP.NET Core Web API.
- Model: Data Representation
- View: User Interface (UI)
- Controller: Handles user requests and returns appropriate views
- Optimizes read-only queries by disabling change tracking.
- Enables asynchronous updates on web pages.
- ViewBag, ViewData, TempData, Session: For sharing data between controllers and views.
- Manages class and service dependencies.
To clear your Git local cache:
git rm -r --cached .
git add .
git commit -am 'git cache cleared'
git push
- .NET Framework: Versions 1 to 4.8.1
- .NET Core: Versions 1 to 3.1
- .NET: Versions 5 to 9
- Use
select * from Tbl_Blog with (nolock)
for reading data without table locking in SQL Server. - Client-Server Communication:
- Client A sends updates to the server.
- Server broadcasts changes to all clients for synchronization.
This section details how to enable Cross-Origin Requests (CORS) in an ASP.NET Core application.
Add the CORS middleware by installing the Microsoft.AspNetCore.Cors
package.
dotnet add package Microsoft.AspNetCore.Cors
In ConfigureServices
, add CORS services and define a policy:
public void ConfigureServices(IServiceCollection services)
{
services.AddCors(options =>
{
options.AddPolicy("AllowSpecificOrigins",
builder =>
{
builder.WithOrigins("http://example.com", "http://www.contoso.com")
.AllowAnyHeader()
.AllowAnyMethod();
});
});
services.AddControllers();
}
In the Configure
method, apply the CORS policy:
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseHttpsRedirection();
app.UseRouting();
app.UseCors("AllowSpecificOrigins");
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
}
Enable CORS at the controller level using [EnableCors]
:
[ApiController]
[Route("[controller]")]
public class MyController : ControllerBase
{
[HttpGet]
[EnableCors("AllowSpecificOrigins")]
public IActionResult Get()
{
return Ok("CORS is enabled for this endpoint.");
}
}
- feat: New feature (e.g.,
feat: add user login functionality
). - fix: Bug fix (e.g.,
fix: resolve issue with user login
). - chore: Maintenance tasks (e.g.,
chore: update dependencies
). - docs: Documentation changes (e.g.,
docs: update README
). - style: Code formatting changes (e.g.,
style: format code
). - refactor: Code refactoring (e.g.,
refactor: streamline user flow
). - perf: Performance improvements (e.g.,
perf: optimize dashboard load
). - test: Adding or updating tests (e.g.,
test: add unit tests for login
). - build: Build system changes (e.g.,
build: update webpack
). - ci: CI configuration changes (e.g.,
ci: add GitHub Actions
). - revert: Reverting previous commits (e.g.,
revert: revert commit abc1234
). - merge: Merging branches (e.g.,
merge: merge branch 'feature-branch'
). - hotfix: Quick fixes for critical issues (e.g.,
hotfix: correct typo
).
feat: add search functionality to navbar
- `fix:
Middleware in ASP.NET Core handles HTTP requests and responses. Middleware components are executed in the order they are added to the request pipeline, making their order crucial for processing requests. Common middleware tasks include authentication, logging, and request/response modification.
public class SessionMiddleware
{
private readonly RequestDelegate _next;
public SessionMiddleware(RequestDelegate next)
{
_next = next;
}
public async Task InvokeAsync(HttpContext context)
{
if (context.Request.Path == "/" || context.Request.Path.ToString().ToLower() == "/login")
goto result;
string name = context.Session.GetString("name");
if (name == null)
{
context.Response.Redirect("/");
return;
}
result:
await _next(context);
}
}
To simplify adding the middleware to the pipeline, an extension method UseSessionMiddleware
is provided:
public static class SessionMiddlewareExtensions
{
public static IApplicationBuilder UseSessionMiddleware(this IApplicationBuilder builder)
{
return builder.UseMiddleware<SessionMiddleware>();
}
}
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
app.UseSession(); // Ensure session is added to the pipeline
app.UseSessionMiddleware();
app.Run(async (context) =>
{
await context.Response.WriteAsync(
$"Welcome, {context.Session.GetString("name") ?? "Guest"}!");
});
app.Run();
- SessionMiddleware: This middleware checks if the session contains a "name" value. If not, it redirects the user to the home page (
/
). It allows requests to proceed if they are to the root path or/Login
. - Extension Method: Simplifies the addition of the custom middleware to the application's request pipeline.
- Usage: The middleware is integrated into the application pipeline, affecting how requests are processed based on session state.
HttpContext
represents the context of an individual HTTP request, providing access to details like the request, response, user identity, session, and more. In ASP.NET Core, you can use IHttpContextAccessor
to access HttpContext
outside of controllers or middleware, such as in services or background tasks.
Here’s an example of using IHttpContextAccessor
:
public class MyService
{
private readonly IHttpContextAccessor _httpContextAccessor;
public MyService(IHttpContextAccessor httpContextAccessor)
{
_httpContextAccessor = httpContextAccessor;
}
public void DoSomething()
{
var context = _httpContextAccessor.HttpContext;
var userName = context.User.Identity.Name;
// Perform actions based on the user's identity
}
}
- Dependency Injection:
IHttpContextAccessor
is injected into the service, allowing access to the currentHttpContext
. - Accessing
HttpContext
: You can retrieve theHttpContext
via_httpContextAccessor.HttpContext
. - Usage Consideration: Ensure thread safety since
HttpContext
is only available in the scope of a request.