Web, HTTP and Services

Option Strict On

Imports System.Net.Http
Imports System.Net.Http.Json
Imports Microsoft.AspNetCore.Builder
Imports Microsoft.AspNetCore.Hosting
Imports Microsoft.AspNetCore.Http
Imports Microsoft.Extensions.DependencyInjection
Imports Microsoft.Extensions.Hosting

Module MinimalApiDemo

    Sub Main(args As String())
        RunAsync(args).GetAwaiter().GetResult()
    End Sub

    Async Function RunAsync(args As String()) As Task
        Dim builder = WebApplication.CreateBuilder(args)
        builder.WebHost.UseUrls("http://127.0.0.1:0")
        builder.Configuration("Logging:LogLevel:Default") = "None"
        builder.Services.AddSingleton(Of BookStore)()
        Dim app = builder.Build()

        app.MapGet("/books", Function(store As BookStore) store.All())
        app.MapGet("/books/{isbn}",
                   Function(isbn As String, store As BookStore) As IResult
                       Dim book As BookDto = store.Find(isbn)
                       Return If(book Is Nothing, Results.NotFound(), Results.Ok(book))
                   End Function)
        app.MapPost("/books",
                    Function(book As BookDto, store As BookStore) As IResult
                        store.Add(book)
                        Return Results.Created("/books/" & book.Isbn, book)
                    End Function)

        Await app.StartAsync()
        Dim address As String = Hosting.ServerAddress(app)
        Console.WriteLine("listening on loopback: " & address.StartsWith("http://127.0.0.1:").ToString())

        Using client As New HttpClient With {.BaseAddress = New Uri(address)}
            Dim all = Await client.GetFromJsonAsync(Of List(Of BookDto))("/books")
            Console.WriteLine("GET /books -> " & all.Count & " book(s), first = " & all(0).Title)

            Dim created = Await client.PostAsJsonAsync("/books", New BookDto With {.Isbn = "9780131103627", .Title = "Types and Tables", .Year = 1988})
            Console.WriteLine("POST /books -> " & CInt(created.StatusCode) & " " & created.StatusCode.ToString() & ", Location = " & created.Headers.Location.ToString())

            Dim found = Await client.GetAsync("/books/9780131103627")
            Console.WriteLine("GET known -> " & CInt(found.StatusCode) & " " & Await found.Content.ReadAsStringAsync())

            Dim missing = Await client.GetAsync("/books/0000000000000")
            Console.WriteLine("GET unknown -> " & CInt(missing.StatusCode) & " " & missing.StatusCode.ToString())
        End Using

        Await app.StopAsync()
    End Function

End Module

listening on loopback: True
GET /books -> 1 book(s), first = Shelf Basics
POST /books -> 201 Created, Location = /books/9780131103627
GET known -> 200 {"isbn":"9780131103627","title":"Types and Tables","year":1988}
GET unknown -> 404 NotFound

Option Strict On

Imports System.ComponentModel.DataAnnotations
Imports System.Net.Http
Imports System.Net.Http.Json
Imports System.Text.Json
Imports Microsoft.AspNetCore.Builder
Imports Microsoft.AspNetCore.Hosting
Imports Microsoft.AspNetCore.Http
Imports Microsoft.AspNetCore.Mvc
Imports Microsoft.Extensions.Configuration
Imports Microsoft.Extensions.DependencyInjection
Imports Microsoft.Extensions.Hosting

Public Class NewBook
    <Required, StringLength(13, MinimumLength:=10)>
    Public Property Isbn As String = ""

    <Required>
    Public Property Title As String = ""

    <Range(1450, 2100)>
    Public Property Year As Integer
End Class

<ApiController>
<Route("api/[controller]")>
Public Class BooksController
    Inherits ControllerBase

    Private ReadOnly _store As BookStore

    Public Sub New(store As BookStore)
        _store = store
    End Sub

    <HttpGet>
    Public Function GetAll() As IEnumerable(Of BookDto)
        Return _store.All()
    End Function

    <HttpGet("{isbn}")>
    Public Function GetOne(isbn As String) As ActionResult(Of BookDto)
        Dim book As BookDto = _store.Find(isbn)
        If book Is Nothing Then
            Return NotFound()
        End If
        Return book
    End Function

    <HttpPost>
    Public Function Create(newBook As NewBook) As ActionResult(Of BookDto)
        Dim book As New BookDto With {.Isbn = newBook.Isbn, .Title = newBook.Title, .Year = newBook.Year}
        _store.Add(book)
        Return CreatedAtAction(NameOf(GetOne), New With {.isbn = book.Isbn}, book)
    End Function
End Class

Module ControllersDemo

    Sub Main(args As String())
        RunAsync(args).GetAwaiter().GetResult()
    End Sub

    Async Function RunAsync(args As String()) As Task
        Dim builder = WebApplication.CreateBuilder(args)
        builder.WebHost.UseUrls("http://127.0.0.1:0")
        builder.Configuration("Logging:LogLevel:Default") = "None"
        builder.Services.AddSingleton(Of BookStore)()
        builder.Services.AddControllers()
        Dim app = builder.Build()
        app.MapControllers()
        Await app.StartAsync()

        Using client As New HttpClient With {.BaseAddress = New Uri(Hosting.ServerAddress(app))}
            Dim all = Await client.GetFromJsonAsync(Of List(Of BookDto))("/api/books")
            Console.WriteLine("GET /api/books -> " & all.Count & " book(s)")

            Dim ok = Await client.PostAsJsonAsync("/api/books", New NewBook With {.Isbn = "9780131103627", .Title = "Types and Tables", .Year = 1988})
            Console.WriteLine("POST valid -> " & CInt(ok.StatusCode) & ", Location = " & ok.Headers.Location.AbsolutePath)

            Dim bad = Await client.PostAsJsonAsync("/api/books", New NewBook With {.Isbn = "123", .Title = "", .Year = 3000})
            Console.WriteLine("POST invalid -> " & CInt(bad.StatusCode) & " " & bad.Content.Headers.ContentType.MediaType)
            Using problem As JsonDocument = JsonDocument.Parse(Await bad.Content.ReadAsStringAsync())
                Console.WriteLine(problem.RootElement.GetProperty("title").GetString())
                For Each field In problem.RootElement.GetProperty("errors").EnumerateObject().OrderBy(Function(p) p.Name)
                    Console.WriteLine("  " & field.Name & ": " & field.Value(0).GetString())
                Next
            End Using

            Dim missing = Await client.GetAsync("/api/books/0000000000000")
            Console.WriteLine("GET unknown -> " & CInt(missing.StatusCode))
        End Using
        Await app.StopAsync()
    End Function

End Module

GET /api/books -> 1 book(s)
POST valid -> 201, Location = /api/Books/9780131103627
POST invalid -> 400 application/problem+json
One or more validation errors occurred.
  Isbn: The field Isbn must be a string with a minimum length of 10 and a maximum length of 13.
  Title: The Title field is required.
  Year: The field Year must be between 1450 and 2100.
GET unknown -> 404

app.MapGet("/hello/{name}", AddressOf Hello)

Program.vb(14,13): error BC30518: Overload resolution failed because no accessible 'MapGet' can be called with these arguments:

app.MapGet("/search", Function(<FromQuery(Name:="q")> term As String) term)

Program.vb(10,40): error BC36634: Attributes cannot be applied to parameters of lambda expressions.

app.MapGet("/page", Function(Optional page As Integer = 1) page.ToString())

Program.vb(9,38): error BC33010: 'Lambda' parameters cannot be declared 'Optional'.

Option Strict On

Module DelegateProbe
    Sub Main()
        Dim a As [Delegate] = Async Function() As Task(Of String)
                                  Await Task.Delay(1)
                                  Return "x"
                              End Function
        Dim s As [Delegate] = Function() "x"
        Dim t As Func(Of Task(Of String)) = Async Function() As Task(Of String)
                                                Await Task.Delay(1)
                                                Return "x"
                                            End Function
        For Each d As [Delegate] In {a, s, t}
            Console.WriteLine(d.GetType().Name & " | Method.ReturnType = " & d.Method.ReturnType.Name & " | Invoke = " & d.GetType().GetMethod("Invoke").ReturnType.Name & " | IsPublic = " & d.GetType().IsPublic.ToString())
        Next
    End Sub
End Module

VB$AnonymousDelegate_2`1 | Method.ReturnType = Task`1 | Invoke = Task`1 | IsPublic = False
VB$AnonymousDelegate_2`1 | Method.ReturnType = String | Invoke = String | IsPublic = False
Func`1 | Method.ReturnType = Task`1 | Invoke = Task`1 | IsPublic = True

Option Strict On

Imports System.Net.Http
Imports System.Net.Http.Json
Imports Microsoft.AspNetCore.Builder
Imports Microsoft.AspNetCore.Hosting
Imports Microsoft.AspNetCore.Http
Imports Microsoft.AspNetCore.Http.HttpResults
Imports Microsoft.AspNetCore.Mvc
Imports Microsoft.Extensions.Configuration
Imports Microsoft.Extensions.DependencyInjection
Imports Microsoft.Extensions.Hosting

Public Class SearchOptions
    <FromQuery(Name:="q")>
    Public Property Term As String = ""

    <FromQuery>
    Public Property Page As Integer = 1
End Class

Public NotInheritable Class Handlers
    Private Sub New()
    End Sub

    ' A named method can carry binding attributes on its parameters.
    Public Shared Function Search(<FromQuery(Name:="q")> term As String,
                                  <FromQuery> Optional limit As Integer = 10) As String
        Return "term=" & term & " limit=" & limit
    End Function

    Public Shared Function Paged(<AsParameters> options As SearchOptions) As String
        Return "term=" & options.Term & " page=" & options.Page
    End Function

    Public Shared Function Lookup(isbn As String, store As BookStore) As Results(Of Ok(Of BookDto), NotFound)
        Dim book As BookDto = store.Find(isbn)
        If book Is Nothing Then
            Return TypedResults.NotFound()
        End If
        Return TypedResults.Ok(book)
    End Function
End Class

Public NotInheritable Class LoggingFilter
    Implements IEndpointFilter

    Public Function InvokeAsync(context As EndpointFilterInvocationContext,
                                [next] As EndpointFilterDelegate) As ValueTask(Of Object) Implements IEndpointFilter.InvokeAsync
        Return New ValueTask(Of Object)(RunAsync(context, [next]))
    End Function

    Private Shared Async Function RunAsync(context As EndpointFilterInvocationContext,
                                           [next] As EndpointFilterDelegate) As Task(Of Object)
        Console.WriteLine("  filter: before")
        Dim result As Object = Await [next](context)
        Console.WriteLine("  filter: after, result = " & result.ToString())
        Return result
    End Function
End Class

Module HandlersDemo

    Sub Main(args As String())
        RunAsync(args).GetAwaiter().GetResult()
    End Sub

    Async Function RunAsync(args As String()) As Task
        Dim builder = WebApplication.CreateBuilder(args)
        builder.WebHost.UseUrls("http://127.0.0.1:0")
        builder.Configuration("Logging:LogLevel:Default") = "None"
        builder.Services.AddSingleton(Of BookStore)()
        Dim app = builder.Build()

        ' AddressOf alone does not convert to the Delegate parameter of MapGet: wrap it.
        app.MapGet("/search", New Func(Of String, Integer, String)(AddressOf Handlers.Search))
        app.MapGet("/paged", New Func(Of SearchOptions, String)(AddressOf Handlers.Paged))
        app.MapGet("/typed/{isbn}", New Func(Of String, BookStore, Results(Of Ok(Of BookDto), NotFound))(AddressOf Handlers.Lookup))

        ' A route group shares a prefix.
        Dim api = app.MapGroup("/api/v1")
        api.MapGet("/ping", Function() "pong")

        ' The same asynchronous handler twice: handed over as a bare lambda, and held in a typed Func first.
        api.MapGet("/lambda",
                   Async Function() As Task(Of String)
                       Await Task.Delay(1)
                       Return "async lambda"
                   End Function)
        Dim typed As Func(Of Task(Of String)) =
            Async Function() As Task(Of String)
                Await Task.Delay(1)
                Return "typed Func"
            End Function
        api.MapGet("/typed-func", typed)

        ' An endpoint filter is a class: IEndpointFilter returns ValueTask(Of Object), which an Async method cannot return.
        api.MapGet("/filtered", Function() "body").AddEndpointFilter(New LoggingFilter())

        Await app.StartAsync()
        Using client As New HttpClient With {.BaseAddress = New Uri(Hosting.ServerAddress(app))}
            For Each path In {"/search?q=vb", "/search?q=vb&limit=3", "/paged?q=dotnet&page=2", "/typed/9780306406157", "/typed/1", "/api/v1/ping", "/api/v1/lambda", "/api/v1/typed-func", "/api/v1/filtered"}
                Dim response = Await client.GetAsync(path)
                Console.WriteLine(path & " -> " & CInt(response.StatusCode) & " " & Await response.Content.ReadAsStringAsync())
            Next
        End Using
        Await app.StopAsync()
    End Function

End Module

/search?q=vb -> 200 term=vb limit=10
/search?q=vb&limit=3 -> 200 term=vb limit=3
/paged?q=dotnet&page=2 -> 200 term=dotnet page=2
/typed/9780306406157 -> 200 {"isbn":"9780306406157","title":"Shelf Basics","year":2020}
/typed/1 -> 404
/api/v1/ping -> 200 pong
/api/v1/lambda -> 200
/api/v1/typed-func -> 200 typed Func
  filter: before
  filter: after, result = body
/api/v1/filtered -> 200 body

Option Strict On

Imports System.Net.Http
Imports Microsoft.AspNetCore.Builder
Imports Microsoft.AspNetCore.Hosting
Imports Microsoft.AspNetCore.Http
Imports Microsoft.Extensions.Configuration
Imports Microsoft.Extensions.DependencyInjection
Imports Microsoft.Extensions.Hosting
Imports Microsoft.Extensions.Options

Public Class ShelfOptions
    Public Const SectionName As String = "Shelf"
    Public Property LibraryName As String = "Unnamed"
    Public Property MaxLoans As Integer = 3
End Class

Public Interface IClock
    Function UtcNow() As DateTimeOffset
End Interface

Public NotInheritable Class FixedClock
    Implements IClock

    Public Function UtcNow() As DateTimeOffset Implements IClock.UtcNow
        Return New DateTimeOffset(2026, 10, 19, 12, 0, 0, TimeSpan.Zero)
    End Function
End Class

' Convention-based middleware: a constructor taking RequestDelegate and an InvokeAsync method.
Public NotInheritable Class StampMiddleware
    Private ReadOnly _next As RequestDelegate

    Public Sub New([next] As RequestDelegate)
        _next = [next]
    End Sub

    Public Async Function InvokeAsync(context As HttpContext, clock As IClock) As Task
        context.Response.Headers("X-Stamp") = clock.UtcNow().ToString("yyyy-MM-dd")
        Await _next(context)
    End Function
End Class

Module PipelineDemo

    Sub Main(args As String())
        RunAsync(args).GetAwaiter().GetResult()
    End Sub

    Async Function RunAsync(args As String()) As Task
        Dim builder = WebApplication.CreateBuilder(args)
        builder.WebHost.UseUrls("http://127.0.0.1:0")
        builder.Configuration("Logging:LogLevel:Default") = "None"
        builder.Configuration("Shelf:LibraryName") = "Central Library"
        builder.Services.Configure(Of ShelfOptions)(builder.Configuration.GetSection(ShelfOptions.SectionName))
        builder.Services.AddSingleton(Of IClock, FixedClock)()
        Dim app = builder.Build()

        ' Inline middleware: spell out the parameter types so the Func(Of Task) overload is chosen.
        app.Use(Async Function(context As HttpContext, [next] As Func(Of Task)) As Task
                    Console.WriteLine("  inline middleware: before " & context.Request.Path.Value)
                    Await [next]()
                    Console.WriteLine("  inline middleware: after, status " & context.Response.StatusCode)
                End Function)
        app.UseMiddleware(Of StampMiddleware)()

        app.MapGet("/info",
                   Function(options As IOptions(Of ShelfOptions), clock As IClock) As String
                       Return options.Value.LibraryName & " (max " & options.Value.MaxLoans & " loans) at " & clock.UtcNow().ToString("u")
                   End Function)

        Await app.StartAsync()
        Using client As New HttpClient With {.BaseAddress = New Uri(Hosting.ServerAddress(app))}
            Dim response = Await client.GetAsync("/info")
            Console.WriteLine("body:    " & Await response.Content.ReadAsStringAsync())
            Console.WriteLine("X-Stamp: " & response.Headers.GetValues("X-Stamp").First())
        End Using
        Await app.StopAsync()
    End Function

End Module

  inline middleware: before /info
  inline middleware: after, status 200
body:    Central Library (max 3 loans) at 2026-10-19 12:00:00Z
X-Stamp: 2026-10-19

Option Strict On

Imports System.Net.Http
Imports Microsoft.AspNetCore.Builder
Imports Microsoft.AspNetCore.Hosting
Imports Microsoft.AspNetCore.Http
Imports Microsoft.Extensions.Configuration
Imports Microsoft.Extensions.DependencyInjection
Imports Microsoft.Extensions.Hosting

Module SessionDemo

    Sub Main(args As String())
        RunAsync(args).GetAwaiter().GetResult()
    End Sub

    Async Function RunAsync(args As String()) As Task
        Dim builder = WebApplication.CreateBuilder(args)
        builder.WebHost.UseUrls("http://127.0.0.1:0")
        builder.Configuration("Logging:LogLevel:Default") = "None"
        builder.Services.AddDistributedMemoryCache()
        builder.Services.AddSession()
        Dim app = builder.Build()
        app.UseSession()

        Dim hits As Integer = 0   ' application-wide state (Application("hits") in classic ASP)
        app.MapGet("/visit",
                   Function(context As HttpContext) As String
                       Dim own As Integer = If(context.Session.GetInt32("visits"), 0) + 1   ' per-visitor state (Session("visits"))
                       context.Session.SetInt32("visits", own)
                       hits += 1
                       Return "you: " & own & ", everyone: " & hits
                   End Function)
        Await app.StartAsync()

        Dim address As New Uri(Hosting.ServerAddress(app))
        Using ada As New HttpClient With {.BaseAddress = address}, grace As New HttpClient With {.BaseAddress = address}
            Console.WriteLine("ada:   " & Await ada.GetStringAsync("/visit"))
            Console.WriteLine("ada:   " & Await ada.GetStringAsync("/visit"))
            Console.WriteLine("grace: " & Await grace.GetStringAsync("/visit"))
            Console.WriteLine("ada:   " & Await ada.GetStringAsync("/visit"))
        End Using
        Await app.StopAsync()
    End Function

End Module

ada:   you: 1, everyone: 1
ada:   you: 2, everyone: 2
grace: you: 1, everyone: 3
ada:   you: 3, everyone: 4

Option Strict On

Imports System.Net.Http
Imports System.Text.Json
Imports Microsoft.AspNetCore.Builder
Imports Microsoft.AspNetCore.Hosting
Imports Microsoft.AspNetCore.Http
Imports Microsoft.Extensions.Configuration
Imports Microsoft.Extensions.DependencyInjection
Imports Microsoft.Extensions.Hosting

Module OpenApiDemo

    Sub Main(args As String())
        RunAsync(args).GetAwaiter().GetResult()
    End Sub

    Async Function RunAsync(args As String()) As Task
        Dim builder = WebApplication.CreateBuilder(args)
        builder.WebHost.UseUrls("http://127.0.0.1:0")
        builder.Configuration("Logging:LogLevel:Default") = "None"
        builder.Services.AddOpenApi()
        builder.Services.AddSingleton(Of BookStore)()
        Dim app = builder.Build()
        app.MapOpenApi()
        app.MapGet("/books/{isbn}",
                   Function(isbn As String, store As BookStore) As IResult
                       Dim book As BookDto = store.Find(isbn)
                       Return If(book Is Nothing, Results.NotFound(), Results.Ok(book))
                   End Function).WithName("GetBook")
        app.MapPost("/books", Function(book As BookDto, store As BookStore) As IResult
                                  store.Add(book)
                                  Return Results.Created("/books/" & book.Isbn, book)
                              End Function)
        Await app.StartAsync()

        Using client As New HttpClient With {.BaseAddress = New Uri(Hosting.ServerAddress(app))}
            Dim json As String = Await client.GetStringAsync("/openapi/v1.json")
            Using doc As JsonDocument = JsonDocument.Parse(json)
                Console.WriteLine("openapi = " & doc.RootElement.GetProperty("openapi").GetString())
                For Each path In doc.RootElement.GetProperty("paths").EnumerateObject()
                    For Each op In path.Value.EnumerateObject()
                        Console.WriteLine(op.Name.ToUpperInvariant() & " " & path.Name)
                    Next
                Next
                For Each entry In doc.RootElement.GetProperty("components").GetProperty("schemas").EnumerateObject()
                    Console.WriteLine("schema " & entry.Name & ": " & String.Join(", ", entry.Value.GetProperty("properties").EnumerateObject().Select(Function(p) p.Name)))
                Next
            End Using
        End Using
        Await app.StopAsync()
    End Function

End Module

openapi = 3.1.1
GET /books/{isbn}
POST /books
schema BookDto: isbn, title, year

Option Strict On

Imports System.Net.Http
Imports Microsoft.AspNetCore.Builder
Imports Microsoft.AspNetCore.Hosting
Imports Microsoft.Extensions.Configuration
Imports Microsoft.Extensions.DependencyInjection
Imports Microsoft.Extensions.Hosting

Module Program
    Sub Main(args As String())
        Dim builder = WebApplication.CreateBuilder(args)
        builder.WebHost.UseUrls("http://127.0.0.1:0")
        builder.Configuration("Logging:LogLevel:Default") = "None"
        builder.Services.AddRazorPages()
        Dim app = builder.Build()
        app.MapRazorPages()
        app.Start()
        Dim address = app.Urls.First()
        Using client As New HttpClient With {.BaseAddress = New Uri(address)}
            Dim r = client.GetAsync("/").GetAwaiter().GetResult()
            Console.WriteLine(CInt(r.StatusCode))
        End Using
        app.StopAsync().GetAwaiter().GetResult()
    End Sub
End Module

404

Option Strict On

Imports System.Net.Http
Imports System.Net.Http.Json
Imports Microsoft.AspNetCore.Builder
Imports Microsoft.AspNetCore.Http
Imports Microsoft.AspNetCore.TestHost
Imports Microsoft.Extensions.Configuration
Imports Microsoft.Extensions.DependencyInjection
Imports Microsoft.Extensions.Hosting

Module TestServerDemo

    Sub Main(args As String())
        RunAsync(args).GetAwaiter().GetResult()
    End Sub

    Async Function RunAsync(args As String()) As Task
        Dim builder = WebApplication.CreateBuilder(args)
        builder.WebHost.UseTestServer()          ' no socket is opened
        builder.Configuration("Logging:LogLevel:Default") = "None"
        builder.Services.AddSingleton(Of BookStore)()
        Dim app = builder.Build()
        app.MapGet("/books/{isbn}",
                   Function(isbn As String, store As BookStore) As IResult
                       Dim book As BookDto = store.Find(isbn)
                       Return If(book Is Nothing, Results.NotFound(), Results.Ok(book))
                   End Function)
        Await app.StartAsync()

        Using client As HttpClient = app.GetTestClient()
            Dim book = Await client.GetFromJsonAsync(Of BookDto)("/books/9780306406157")
            Console.WriteLine("in-process GET -> " & book.Title)
            Dim response = Await client.GetAsync("/books/0000000000000")
            Console.WriteLine("in-process GET unknown -> " & CInt(response.StatusCode))
            Console.WriteLine("BaseAddress = " & client.BaseAddress.ToString())
        End Using
        Await app.StopAsync()
    End Function

End Module

in-process GET -> Shelf Basics
in-process GET unknown -> 404
BaseAddress = http://localhost/

Option Strict On

Imports System.Net
Imports System.Net.Http
Imports System.Net.Sockets
Imports System.Threading
Imports Microsoft.AspNetCore.Builder
Imports Microsoft.AspNetCore.Hosting
Imports Microsoft.AspNetCore.Http
Imports Microsoft.Extensions.Configuration
Imports Microsoft.Extensions.DependencyInjection
Imports Microsoft.Extensions.Hosting

' A DelegatingHandler is the HttpClient pipeline's middleware.
Public NotInheritable Class CountingHandler
    Inherits DelegatingHandler

    Public Shared Attempts As Integer

    Protected Overrides Async Function SendAsync(request As HttpRequestMessage,
                                                 cancellationToken As CancellationToken) As Task(Of HttpResponseMessage)
        Dim n As Integer = Interlocked.Increment(Attempts)
        Dim response As HttpResponseMessage = Await MyBase.SendAsync(request, cancellationToken)
        Console.WriteLine("  attempt " & n & " -> " & CInt(response.StatusCode))
        Return response
    End Function
End Class

Public NotInheritable Class ShelfApiClient
    Private ReadOnly _http As HttpClient

    Public Sub New(http As HttpClient)
        _http = http
    End Sub

    Public Function GetTitleAsync() As Task(Of String)
        Return _http.GetStringAsync("title")
    End Function
End Class

Module FactoryDemo

    Private Function FreePort() As Integer
        Dim listener As New TcpListener(IPAddress.Loopback, 0)
        listener.Start()
        Dim port As Integer = CType(listener.LocalEndpoint, IPEndPoint).Port
        listener.Stop()
        Return port
    End Function

    Sub Main(args As String())
        RunAsync(args).GetAwaiter().GetResult()
    End Sub

    Async Function RunAsync(args As String()) As Task
        Dim port As Integer = FreePort()

        ' The flaky service: the first two calls answer 503, the third succeeds.
        Dim serverBuilder = WebApplication.CreateBuilder(args)
        serverBuilder.WebHost.UseUrls("http://127.0.0.1:" & port)
        serverBuilder.Configuration("Logging:LogLevel:Default") = "None"
        Dim server = serverBuilder.Build()
        Dim calls As Integer = 0
        server.MapGet("/title",
                      Function() As IResult
                          calls += 1
                          Return If(calls < 3, Results.StatusCode(503), Results.Text("Shelf Basics"))
                      End Function)
        Await server.StartAsync()

        ' The client side: Generic Host, typed client, resilience handler.
        Dim builder = Host.CreateApplicationBuilder(args)
        builder.Configuration("Logging:LogLevel:Default") = "None"
        builder.Services.AddTransient(Of CountingHandler)()
        Dim clientBuilder = builder.Services.AddHttpClient(Of ShelfApiClient)(
            Sub(client) client.BaseAddress = New Uri("http://127.0.0.1:" & port & "/"))
        ' Handlers run in registration order: the resilience handler first, so the counting handler sees every attempt.
        clientBuilder.AddStandardResilienceHandler(
            Sub(options)
                options.Retry.MaxRetryAttempts = 3
                options.Retry.Delay = TimeSpan.FromMilliseconds(20)
                options.Retry.UseJitter = False
            End Sub)
        clientBuilder.AddHttpMessageHandler(Of CountingHandler)()
        Using host As IHost = builder.Build()
            Dim api = host.Services.GetRequiredService(Of ShelfApiClient)()
            Console.WriteLine("title: " & Await api.GetTitleAsync())
        End Using
        Await server.StopAsync()
    End Function

End Module

  attempt 1 -> 503
  attempt 2 -> 503
  attempt 3 -> 200
title: Shelf Basics