ASP.NET

<a href="#" class="nav-link btn-link" @onclick="(()=>ShowDetails(app.Id))">

<a href="#" class="nav-link btn-link" @onclick="(()=>ShowDetails(app.Id))" @onclick:preventDefault>

namespace SimpleBol.Context.MongoDb
{
    internal class MongoDbContext : IDisposable
    {
        private IMongoDatabase _database { get; set; } = null!; // I upgraded this
        private MongoClient _client { get; set; } = null!; // I upgraded this to

        public void MongoDBContext()
        {

            // Grab the MongoDB Connection and Database
            var rootObject = AppSettingsJson.GetSettings();
            var dbConnection = rootObject?.Settings?.DbConnection;
            var connString = "mongodb://" + dbConnection?.User + ":" + dbConnection?.Pass + "@" + dbConnection?.Host;

            _client = new MongoClient(connString);
            _database = _client.GetDatabase(dbConnection?.Database);

        }

        // Simple Bol Database Models
        public IMongoCollection<ACCOUNTS> Accounts => _database.GetCollection<ACCOUNTS>("Accounts");

'Group the Store Invoices by Store to Average out the Freight/Shipping Margins
Dim gFreightInvoicesGrouped As List(Of AtdFreightInvoiceReport) = gFreightInvoicesAll _
.OrderBy(Function(ob) ob.FSTORECODE) _
.Where(Function(a) a.FSTORECODE <> String.Empty Or a.FSTORECODE.ToLower() <> "unknown") _
.GroupBy(Function(inv) inv.FSTORECODE).Select(Function(cl) New AtdFreightInvoiceReport() With {
    .FINVNO = cl.First().FINVNO,
    .FSTORECODE = cl.First().FSTORECODE,
    .FLOCATION = cl.First().FLOCATION,
    .FAMOUNT = cl.Sum(Function(x) x.FAMOUNT),
    .FSHIPCOST = cl.Sum(Function(x) x.FSHIPCOST),
    .FSHIPPRICE = cl.Sum(Function(x) x.FSHIPPRICE),
    .FMARGINPERCENT = AmCommon.CalculateShippingPercentageFormattedToString(cl.Sum(Function(x) x.FSHIPCOST), cl.Sum(Function(x) x.FAMOUNT)),
    .FREDFLAG = False
}).ToList()

<rule name="Redirect site A">
    <match url="^(.+)" />
    <conditions>
        <add input="{HTTP_HOST}" type="Pattern" pattern="^([^.]+)\.siteA\.com$" />
    </conditions>
    <action type="Rewrite" url="{C:1}/{R:1}" />
</rule>

public static class RewriteBuilderExtensions
{
    public static IApplicationBuilder UseMultiRewriter(
        this IApplicationBuilder app, 
        IReadOnlyList<(Func<HttpContext, bool> predicate, RewriteOptions options)> optionsMap)
    {
        ArgumentNullException.ThrowIfNull(app);
        ArgumentNullException.ThrowIfNull(optionsMap);
        return app.UseMiddleware<MultiRewriteMiddleware>(Options.Create(optionsMap));
    }
}

public static partial class MultiRewriteMiddlewareLoggingExtensions
{
    [LoggerMessage(EventId = 0, Level = LogLevel.Debug, Message = "Request did not match any rewrite rule set. Current url is {CurrentUrl}")]
    public static partial void MultiRewriteMiddlewareNoMatchingRules(this ILogger logger, string CurrentUrl);

    [LoggerMessage(EventId = 1, Level = LogLevel.Debug, Message = "Request is continuing in applying rules. Current url is {CurrentUrl}")]
    public static partial void MultiRewriteMiddlewareRequestContinueResults(this ILogger logger, string CurrentUrl);

    [LoggerMessage(EventId = 2, Level = LogLevel.Debug, Message = "Request is done processing. Location header '{Location}' with status code '{StatusCode}'.")]
    public static partial void MultiRewriteMiddlewareRequestResponseComplete(this ILogger logger, string Location, int StatusCode);

    [LoggerMessage(EventId = 3, Level = LogLevel.Debug, Message = "Request is done applying rules. Url was rewritten to {RewrittenUrl}")]
    public static partial void MultiRewriteMiddlewareRequestStopRules(this ILogger logger, string RewrittenUrl);
}

public class MultiRewriteMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IReadOnlyList<(Func<HttpContext, bool> predicate, RewriteOptions options)> _optionsMap;
    private readonly IFileProvider _fileProvider;
    private readonly ILogger _logger;
    
    public MultiRewriteMiddleware(
        RequestDelegate next,
        IWebHostEnvironment hostingEnvironment,
        ILoggerFactory loggerFactory,
        IOptions<IReadOnlyList<(Func<HttpContext, bool> predicate, RewriteOptions options)>> optionsMap)
    {
        ArgumentNullException.ThrowIfNull(next);
        ArgumentNullException.ThrowIfNull(optionsMap);

        _next = next;
        _optionsMap = optionsMap.Value;
        _fileProvider = _options.StaticFileProvider ?? hostingEnvironment.WebRootFileProvider;
        _logger = loggerFactory.CreateLogger<MultiRewriteMiddleware>();
    }
    
    public Task Invoke(HttpContext context)
    {
        ArgumentNullException.ThrowIfNull(context);
        
        var options = _optionsMap.Where(m => m.predicate(context)).Select(m => m.options).FirstOrDefault();
        if (options is null)
        {
            _logger.MultiRewriteMiddlewareNoMatchingRules(context.Request.GetEncodedUrl());
            return _next(context);
        }

        RewriteContext rewriteContext = new()
        {
            HttpContext = context,
            StaticFileProvider = _fileProvider,
            Logger = _logger,
            Result = RuleResult.ContinueRules
        };

        foreach (var rule in options.Rules)
        {
            rule.ApplyRule(rewriteContext);
                
            switch (rewriteContext.Result)
            {
                case RuleResult.ContinueRules:
                {
                    _logger.MultiRewriteMiddlewareRequestContinueResults(context.Request.GetEncodedUrl());
                    break;
                }
                case RuleResult.EndResponse:
                {
                    _logger.MultiRewriteMiddlewareRequestResponseComplete(
                        context.Response.Headers[HeaderNames.Location],
                        context.Response.StatusCode);
                    
                    return Task.CompletedTask;
                }
                case RuleResult.SkipRemainingRules:
                {
                    _logger.MultiRewriteMiddlewareRequestStopRules(context.Request.GetEncodedUrl());
                    return _next(context);
                }
                default:
                {
                    throw new ArgumentOutOfRangeException($"Invalid rule termination {rewriteContext.Result}");
                }
            }
        }
        
        return _next(context);
    }
}

RewriteOptions optionsA = new();
optionsA.AddIISUrlRewrite(env.ContentRootFileProvider, "RewritesSiteA.xml");
optionsA.AddRedirectToNonWww();

RewriteOptions optionsB = new();
optionsB.AddIISUrlRewrite(env.ContentRootFileProvider, "RewritesSiteB.xml");
optionsB.AddRedirectToNonWww();

List<(Func<HttpContext, bool> predicate, RewriteOptions options)> optionsMap = new()
{
    (context => context.Request.Host.Host == "siteA.com", optionsA),
    (context => true, optionsB)
};

app.UseMultiRewriter(optionsMap);

<input asp-for="Glycemie" class="form-control" step="0.01" />