Routing w ASP.NET Core Web API to mechanizm, który odpowiada za przekierowywanie żądań HTTP do odpowiednich kontrolerów i akcji w aplikacji. Routing jest kluczowym elementem, który pomaga określić, która część kodu obsłuży dane żądanie HTTP. Oto jak działa routing w ASP.NET Core Web API:

Definicja tras (Routes): W aplikacji ASP.NET Core Web API definiuje się trasy (routes), które określają, jakie żądania HTTP mają być kierowane do określonych kontrolerów i akcji. Trasy przykładowo mogą być definiowane w pliku Startup.cs w metodzie Configure za pomocą obiektu IRouteBuilder.

Przykład definicji trasy:
```
app.UseEndpoints(endpoints =>
{
    endpoints.MapControllerRoute(
        name: "default",
        pattern: "api/{controller}/{action}/{id?}");
});
```
W powyższym przykładzie pattern określa schemat trasy. Wartości w nawiasach klamrowych, takie jak {controller}, {action}, {id?}, są zmiennymi, które mapują się na kontroler, akcję i opcjonalny identyfikator w adresie URL.
Mapowanie żądań: Kiedy aplikacja otrzymuje żądanie HTTP, routing przetwarza adres URL żądania i próbuje dopasować go do jednej z zdefiniowanych tras. Na podstawie dopasowania, routing określa, który kontroler i akcja mają obsłużyć żądanie.
Przekierowanie do kontrolera i akcji: Jeśli routing znajduje dopasowanie trasy, to przekierowuje żądanie do odpowiedniego kontrolera i akcji. Kontroler jest wybierany na podstawie wartości zmiennej {controller}, a akcja na podstawie zmiennej {action} w adresie URL.
Przekazanie parametrów: Jeśli w trasie zdefiniowano zmienne, takie jak {id}, wartości te są również pobierane z adresu URL i przekazywane jako parametry do akcji kontrolera.

Na przykład, dla adresu URL api/products/get/123, routing dopasuje trasę do kontrolera "ProductsController", akcji "Get" i przekaże parametr "123" jako identyfikator produktu do obsługi żądania.
Obsługa żądania: Kontroler i akcja obsługują żądanie, wykonują odpowiednie operacje i zwracają odpowiedź, która jest wysyłana z powrotem do klienta.

Routing w ASP.NET Core Web API jest potężnym narzędziem, które pozwala na definiowanie i zarządzanie, które części kodu będą obsługiwać różne rodzaje żądań HTTP. Dzięki temu możesz tworzyć interfejsy API, które są intuicyjne i zgodne z konwencjami adresów URL, co ułatwia klientom komunikację z Twoją aplikacją.

Sposoby konfiguracji

W ASP.NET Core Web API można definiować trasy (routes) na kilka różnych sposobów, w zależności od potrzeb i złożoności aplikacji. Oto najpopularniejsze metody definiowania tras w ASP.NET Core Web API:

Atrybuty na kontrolerach i akcjach:

Najprostszym i najpopularniejszym sposobem definiowania tras w ASP.NET Core Web API jest za pomocą atrybutów na poziomie kontrolerów i akcji. Możesz użyć atrybutu [Route] do określenia trasy dla danego kontrolera lub akcji.

Przykład:
```
[Route("api/[controller]")]
[ApiController]
public class ProductsController : ControllerBase
{
    [HttpGet]
    public IActionResult GetAllProducts()
    {
        // ...
    }

    [HttpGet("{id}")]
    public IActionResult GetProductById(int id)
    {
        // ...
    }
}
```
W powyższym przykładzie kontroler ProductsController ma prefiks "api/Products" w trasie, a akcja GetProductById ma dodatkowy segment {id} w trasie, co oznacza, że oczekuje ona na identyfikator produktu w adresie URL.
Mapowanie na poziomie konfiguracji:

W pliku Startup.cs można również zdefiniować trasy za pomocą metody UseEndpoints w Configure. Jest to bardziej rozbudowany sposób definiowania tras, który pozwala na bardziej zaawansowane konfiguracje tras.

Przykład:
```
app.UseEndpoints(endpoints =>
{
    endpoints.MapControllerRoute(
        name: "default",
        pattern: "api/{controller}/{action}/{id?}");
});
```
W tym przykładzie określamy domyślną trasę, która będzie odpowiadać wszystkim kontrolerom i akcjom w naszej aplikacji. Możemy również używać bardziej zaawansowanych technik, takich jak atrybuty routingu, aby dokładnie określić trasy dla poszczególnych kontrolerów i akcji.
Mapowanie na podstawie konwencji (Convention-based routing):

ASP.NET Core Web API oferuje również mapowanie na podstawie konwencji, gdzie nazwy kontrolerów i akcji są automatycznie mapowane na trasy. To podejście jest wygodne w przypadku prostych scenariuszy, ale może być mniej elastyczne w bardziej skomplikowanych przypadkach.

Przykład:
```
app.UseEndpoints(endpoints =>
{
    endpoints.MapControllers();
});
```
W tym przypadku MapControllers() automatycznie mapuje kontrolery i akcje na trasy oparte na konwencjach, takie jak "api/Products" dla kontrolera ProductsController.
Rozszerzenia routingu:

ASP.NET Core Web API umożliwia również tworzenie własnych rozszerzeń routingu, które pozwalają na bardziej zaawansowane i niestandardowe scenariusze routingu. Możesz dostosować zachowanie routingu zgodnie z własnymi wymaganiami.

Przykład:
```
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseRouting();
    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllerRoute(
            name: "custom",
            pattern: "myapi/{controller}/{action}/{id}");
    });
}
```
W powyższym przykładzie modyfikujemy zachowanie routingu, aby używać niestandardowej trasy "myapi/{controller}/{action}/{id}".

Wybór odpowiedniej metody definiowania tras w ASP.NET Core Web API zależy od specyfiki projektu i preferencji dewelopera. Atrybuty na kontrolerach i akcjach są często używane w prostych przypadkach, podczas gdy bardziej zaawansowane aplikacje mogą korzystać z bardziej elastycznych metod konfiguracji tras.

Materiały

Attribute Routing in ASP.NET Web API 2

Mastering Web API Attribute Routing in ASP.NET Core | .NET fullstack dev - 011