m-lamonaca/dev-notes
1
0
Fork 0
mirror of https://github.com/m-lamonaca/dev-notes.git synced 2025-04-06 10:56:41 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Simplify REST API Notes

Browse source
This commit is contained in:
Marcello 2021-11-09 14:51:42 +01:00
parent 1fad5ca3bd
commit c939822755
1 changed files with 41 additions and 256 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

297
DotNet/ASP.NET/REST API.md
View file

@ -1,181 +1,5 @@
# ASP .NET REST API # ASP .NET REST API
## Startup class
- Called by `Program.cs`
```cs
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
namespace <Namespace>
{
public class Startup
{
public Startup(IConfiguration configuration)
{
Configuration = configuration;
}
public IConfiguration Configuration { get; }
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers(); // controllers w/o views
//or
services.AddControllersWithViews(); // MVC Controllers
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseHttpsRedirection();
app.UseRouting();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
}
}
}
```
## DB Context (EF to access DB)
NuGet Packages to install:
- `Microsoft.EntityFrameworkCore`
- `Microsoft.EntityFrameworkCore.Tools`
- `Microsoft.EntityFrameworkCore.Design` *or* `Microsoft.EntityFrameworkCore.<db_provider>.Design`
- `Microsoft.EntityFrameworkCore.<db_provider>`
In `AppDbContext.cs`:
```cs
using <Namespace>.Model;
using Microsoft.EntityFrameworkCore;
namespace <Namespace>.Repo
{
public class AppDbContext : DbContext
{
public AppDbContext(DbContextOptions<ProjectContext> options) : base(options)
{
}
//DBSet<TEntity> represents the collection of all entities in the context, or that can be queried from the database, of a given type
public DbSet<Entity> entities { get; set; }
}
}
```
In `appsettings.json`:
```json
{
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft": "Warning",
"Microsoft.Hosting.Lifetime": "Information"
}
},
"AllowedHosts": "*",
"ConnectionStrings": {
"CommanderConnection" : "Server=<server>;Database=<database>;UID=<user>;Pwd=<password>"
}
}
```
In `Startup.cs`:
```cs
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
// SqlServer is the db used in this example
services.AddDbContext<CommanderContext>(option => option.UseSqlServer(Configuration.GetConnectionString("CommanderConnection")));
services.AddControllers();
}
```
### Migrations
- Mirroring of model in the DB.
- Will create & update DB Schema if necessary
In Package Manager Shell:
```ps1
add-migrations <migration_name>
update-database # use the migrations to modify the db
```
## Repository
In `IEntityRepo`:
```cs
using <Namespace>.Model;
using System.Collections.Generic;
namespace <Namespace>.Repository
{
public interface IEntityRepo
{
IEnumerable<Entity> SelectAll();
Entity SelectOneById(int id);
...
}
}
```
In `EntityRepo`:
```cs
using <Namespace>.Model;
using System.Collections.Generic;
namespace <Namespace>.Repo
{
public class EntityRepo : IEntityRepo
{
private readonly AppDbContext _context;
public EntityRepo(AppDbContext context)
{
_context = context;
}
public IEnumerable<Entity> SelectAll()
{
return _context.Entities.ToList(); // linq query (ToList()) becomes sql query
}
public Entity SelectOneById(int id)
{
return _context.Entities.FirstOrDefault(p => p.Id == id);
}
...
}
}
```
## Data Transfer Objects (DTOs) ## Data Transfer Objects (DTOs)
A **DTO** is an object that defines how the data will be sent and received over the network (usually as JSON). A **DTO** is an object that defines how the data will be sent and received over the network (usually as JSON).
@ -202,13 +26,13 @@ public void ConfigureServices(IServiceCollection services)
} }
``` ```
In `Entity<CrudOperation>DTO.cs`: In `EntityDTO.cs`:
```cs ```cs
namespace <Namespace>.DTOs namespace <Namespace>.DTOs
{ {
// define the data to be serialized in JSON (can differ from model) // define the data to be serialized in JSON (can differ from model)
public class EntityCrudOpDTO // e.g: EntityReadDTO, ... public class EntityDTO
{ {
// only properties to be serialized // only properties to be serialized
} }
@ -228,7 +52,7 @@ namespace <Namespace>.Profiles
{ {
public EntitiesProfile() public EntitiesProfile()
{ {
CreateMap<Entity, EntityCrudOpDTO>(); // map entity to it's DTO CreateMap<Entity, EntityDTO>(); // map entity to it's DTO
} }
} }
} }
@ -236,69 +60,40 @@ namespace <Namespace>.Profiles
## Controller (No View) ## Controller (No View)
Uses [Dependency Injection](https://en.wikipedia.org/wiki/Dependency_injection) to receive a suitable implementation of `IEntityRepo`,
### Service Lifetimes
- `AddSingleton`: same for every request
- `AddScoped`: created once per client
- `Transient`: new instance created every time
In `Startup.cs`:
```cs ```cs
// This method gets called by the runtime. Use this method to add services to the container. [Route("api/endpoint")]
public void ConfigureServices(IServiceCollection services) [ApiController]
public class EntitiesController : ControllerBase // MVC controller w/o view
{ {
services.AddControllers(); private readonly ICommandRepo _repo;
services.AddScoped<IEntityRepo, EntityRepo>(); // map the interface to its implementation, needed for dependency injection private readonly IMapper _mapper; // AutoMapper class
}
```
### Request Mappings public EntitiesController(IEntityRepo repository, IMapper mapper)
```cs
using <App>.Model;
using <App>.Repo;
using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
namespace <App>.Controllers
{
[Route("api/endpoint")]
[ApiController]
public class EntitiesController : ControllerBase // MVC controller w/o view
{ {
private readonly ICommandRepo _repo; _repo = repository;
private readonly IMapper _mapper; // AutoMapper class _mapper = mapper
}
public EntitiesController(IEntityRepo repository, IMapper mapper) // injection og the dependency [HttpGet] // GET api/endpoint
public ActionResult<IEnumerable<EntityDTO>> SelectAllEntities()
{
var results = _repo.SelectAll();
return Ok(_mapper.Map<EntityDTO>(results));
}
[HttpGet("{id}")] // GET api/endpoint/{id}
public ActionResult<EntityDTO> SelectOneEntityById(int id)
{
var result = _repo.SelectOneById(id);
if(result != null)
{ {
_repo = repository; // transform entity to it's DTO
_mapper = mapper return Ok(_mapper.Map<EntityDTO>(result));
} }
[HttpGet] // GET api/endpoint return NotFound();
public ActionResult<IEnumerable<EntityCrudOpDTO>> SelectAllEntities()
{
var results = _repo.SelectAll();
return Ok(_mapper.Map<EntityCrudOpDTO>(results)); // return an action result OK (200) with the results
}
// default binding source: [FromRoute]
[HttpGet("{id}")] // GET api/endpoint/{id}
public ActionResult<EntityCrudOpDTO> SelectOneEntityById(int id)
{
var result = _repo.SelectOneById(id);
if(result != null)
{
return Ok(_mapper.Map<EntityCrudOp>(result)); // transform entity to it's DTO
}
return NotFound(); // ActionResult NOT FOUND (404)
}
} }
} }
``` ```
@ -306,31 +101,21 @@ namespace <App>.Controllers
## Controller (With View) ## Controller (With View)
```cs ```cs
using <App>.Model; [Route("api/endpoint")]
using Microsoft.AspNetCore.Mvc; [ApiController]
using System; public class EntitiesController : Controller
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
namespace <App>.Controllers
{ {
[Route("api/endpoint")] private readonly AppDbContext _db;
[ApiController]
public class EntitiesController : Controller public EntitiesController(AppDbContext db)
{ {
private readonly AppDbContext _db; _db = db;
}
public EntitiesController(AppDbContext db) [HttpGet]
{ public IActionResult SelectAll()
_db = db; {
} return Json(new { data = _db.Entities.ToList() }); // json view
[HttpGet]
public IActionResult SelectAll()
{
return Json(new { data = _db.Entities.ToList() }); // json view
}
} }
} }
``` ```