ASP.NET Core 6 introduce un modello di hosting semplificato che può essere usato per implementare API leggere con dipendenze minime. Queste API minime riducono drasticamente il codice standard che devi scrivere per far funzionare le tue applicazioni ASP.NET Core 6.
Abbiamo discusso di come iniziare con le API minime in un articolo precedente. In questo articolo esploreremo aspetti più avanzati delle API minime, tra cui l'implementazione della registrazione, la lettura dal sistema di configurazione e l'uso dell'iniezione delle dipendenze.
Per utilizzare gli esempi di codice forniti in questo articolo, è necessario che Visual Studio 2022 sia installato nel sistema. Se non ne hai già una copia, puoi scaricare Visual Studio 2022 qui.
Crea un progetto API Web minimo ASP.NET Core in Visual Studio 2022
Innanzitutto, creiamo un progetto ASP.NET Core in Visual Studio 2022. Seguendo questi passaggi verrà creato un nuovo progetto ASP.NET Core Web API 6 in Visual Studio 2022:
- Avvia l'IDE di Visual Studio 2022.
- Fai clic su "Crea nuovo progetto".
- Nella finestra "Crea nuovo progetto", seleziona "API Web ASP.NET Core" dall'elenco dei modelli visualizzato.
- Fai clic su Avanti.
- Nella finestra "Configura il tuo nuovo progetto", specifica il nome e la posizione per il nuovo progetto.
- Facoltativamente, seleziona la casella di controllo "Posiziona soluzione e progetto nella stessa directory", a seconda delle tue preferenze.
- Fai clic su Avanti.
- Nella finestra "Informazioni aggiuntive" mostrata di seguito, deseleziona la casella di controllo "Usa controller..." poiché in questo esempio utilizzeremo API minime. Lascia il "Tipo di autenticazione" su "Nessuno" (impostazione predefinita).
- Assicurati che le caselle di controllo "Abilita Docker", "Configura per HTTPS" e "Abilita supporto API aperte" siano deselezionate poiché non utilizzeremo nessuna di queste funzioni qui.
- Fai clic su Crea.
Verrà creato un nuovo progetto API Web ASP.NET Core 6 in Visual Studio 2022. Utilizzeremo questo progetto per lavorare con un'API minima nelle sezioni successive di questo articolo.
Esegui un'API Web minima
Puoi far funzionare la tua API minima con poche righe di codice:
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
app.MapGet("/", () => "This is an example of a minimal API");
app.Run();
Configura più porte per un'API Web minima
Il frammento di codice seguente illustra come configurare la tua API minima per l'esecuzione su una porta specifica.
var app = WebApplication.Create(args);
app.MapGet("/", () => "Hello World!");
app.Run("http://localhost:5178");
Quando esegui l'applicazione e accedi a questo URL, dovresti vedere "Hello World!" messaggio visualizzato nel tuo browser web.
Puoi utilizzare più porte aggiungendo gli URL come mostrato nel seguente frammento di codice.
app.Urls.Add("http://localhost:5178");
app.Urls.Add("http://localhost:5179"); In questo caso, se accedi a uno di questi endpoint, lo stesso "Hello World!" verrà visualizzato il messaggio.
Puoi persino leggere la porta dall'ambiente come mostrato nello snippet di codice riportato di seguito.
var app = WebApplication.Create(args);
var port = Environment.GetEnvironmentVariable("PORT") ?? "5155";
app.MapGet("/", () => "Hello World!");
app.Run($"http://localhost:{port}");
Utilizza l'accesso a un'API Web minima
Puoi anche utilizzare l'accesso alle tue API minime. Ecco come puoi registrare i dati sulla console utilizzando Serilog:
var logger = new LoggerConfiguration()
.WriteTo.Console()
.CreateLogger();
È possibile utilizzare Serilog per creare registri che persistono anche i riavvii dell'applicazione. Serilog supporta la registrazione a un database, file, archiviazione cloud e altri target. Il frammento di codice seguente illustra come utilizzare Serilog in API minime.
var builder = WebApplication.CreateBuilder(args);
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.WriteTo.File("logs.txt", rollingInterval: RollingInterval.Day)
.CreateLogger();
Il seguente frammento di codice mostra come utilizzare l'accesso alla tua API minima.
app.MapGet("/", (ILoggerFactory loggerFactory) => {
var logger = loggerFactory.CreateLogger("Start");
logger.LogInformation("Starting...");
return "Logging at work!";
}); Lettura dal sistema di configurazione in un'API minima
Puoi anche leggere dal sistema di configurazione nella tua API minima. Il seguente frammento di codice mostra come ottenere questo risultato.
var app = WebApplication.Create(args);
var message = app.Configuration["TextMessage"] ?? "This is a default message.";
app.MapGet("/", () => message);
app.Run();
Utilizza l'inserimento delle dipendenze in un'API Web minima
Se desideri utilizzare un'istanza HttpClient per connetterti a una risorsa remota, puoi utilizzare l'inserimento delle dipendenze come mostrato nello snippet di codice riportato di seguito.
app.MapGet("/", (IHttpClientFactory httpClientFactory) => "Inside HttpGet method"); Ricordarsi di aggiungere HttpClient al contenitore utilizzando il codice seguente.
builder.Services.AddHttpClient();
Puoi anche sfruttare l'iniezione di dipendenza in un metodo HttpPost. Il frammento di codice seguente mostra come passare un'istanza di IHttpClientFactory come parametro al metodo HttpPost.
app.MapPost("/", (IHttpClientFactory httpClientFactory) =>
{
var client = httpClientFactory.CreateClient();
return Results.Ok();
}); Inietta una classe personalizzata in un'API Web minima
Puoi anche iniettare un'istanza di una classe personalizzata nella tua API minima. Per illustrare questo, implementiamo due tipi:l'interfaccia IAuthorRepository e la classe AuthorRepository. Utilizzeremo questi tipi per implementare l'inserimento delle dipendenze nella nostra API minima.
Crea un nuovo file chiamato IAuthorRepository.cs e inserisci il seguente codice:
public interface IAuthorRepository
{
public List<Author> GetAuthors();
public Author GetAuthor(int id);
}
La classe AuthorRepository implementa l'interfaccia IAuthorRepository come mostrato di seguito.
public class AuthorRepository: IAuthorRepository
{
private readonly List<Author> _authors;
public AuthorRepository()
{
_authors = new List<Author>
{
new Author
{
Id = 1,
FirstName = "Joydip",
LastName = "Kanjilal"
},
new Author
{
Id = 2,
FirstName = "Steve",
LastName = "Smith"
},
new Author
{
Id = 3,
FirstName = "Julie",
LastName = "Lerman"
},
new Author
{
Id = 4,
FirstName = "Simon",
LastName = "Bisson"
}
};
}
public List<Author> GetAuthors()
{
return _authors;
}
public Author GetAuthor(int id)
{
return _authors.Find(x=> x.Id == id);
}
}
Inietta un'interfaccia personalizzata in un'API Web minima
Il frammento di codice seguente illustra come inserire un'istanza dell'interfaccia IAuthorRepository.
app.MapGet("api/author/{id:int}", async (IAuthorRepository authorRepository, HttpContext httpContext) =>
{
var id = int.Parse((string)httpContext.Request.RouteValues["id"]);
var author = authorRepository.GetAuthor(id);
if (author == null)
{
return Results.NotFound();
}
return Results.Ok(author);
}); Infine, .NET 6 include una nuova fantastica funzionalità, le direttive using globali. Per sfruttare gli using globali, crea un nuovo file denominato Usings.cs e sposta lì tutte le tue istruzioni using. Puoi usare questa funzionalità con le tue API ASP.NET Core 6 o minime.
Avrò altro da dire sulle API minime (come lavorare con sicurezza e middleware) in un prossimo post qui.