“無法訪問已處置的背景關系實體。”從存盤庫呼叫方法時出錯-有解無憂

我正在嘗試從服務的存盤庫中呼叫方法。

背景關系、存盤庫和服務都被定義為范圍服務。

這是我首先呼叫的方法：

  public async void ReceiveWebhook(HttpContext httpContext)
    {
        // some unimportant checks here

        var productPurchaseRequest = new ProductPurchaseRequest
        {
            Amount = Convert.ToInt32(result?.Quantity),
            Timestamp = DateTime.Now,
            ProductType = productType,
            PaymentProviderOrderId = Convert.ToInt32(result?.OrderId),
            PaymentProviderProductId = Convert.ToInt32(result?.ProductId),
            PaymentProviderTransactionId = result?.TransactionId!,
            PaymentModel = PaymentModel.Subscription,
            PhoneNumber = result?.Passthrough!
            //todo: change payment model
        };
        var bought = await _productProvisioningRepository.PurchaseProduct(productPurchaseRequest);

    }

這是方法：PurchaseProduct()在存盤庫中：

    public async Task<bool> PurchaseProduct(ProductPurchaseRequest productPurchaseRequest)
    {
        await using var transactionScope = await _context.Database.BeginTransactionAsync();
        
        var query = from u in _context.signumid_user
            where u.PhoneNumber == productPurchaseRequest.PhoneNumber
            select u;
        
        var user = await query.FirstOrDefaultAsync();
        
        if (user == null)
        {
            return false;
            //todo: log user with phone number does not exist
        }
        
        try
        {
            var transaction = new Transaction
            {
                Timestamp = productPurchaseRequest.Timestamp,
                PaymentProviderOrderId = productPurchaseRequest.PaymentProviderOrderId,
                PaymentProviderProductId = productPurchaseRequest.PaymentProviderProductId,
                PaymentProviderTransactionId = productPurchaseRequest.PaymentProviderTransactionId
            };
            var transactionDb = await _context.signumid_transaction.AddAsync(transaction);
            await _context.SaveChangesAsync();

            var productEntry = new ProductEntry
            {
                Amount = productPurchaseRequest.Amount,
                ExpiryDate = productPurchaseRequest.Timestamp.AddMonths(1),
                PaymentModel = (int) PaymentModel.Subscription,
                ProductType = productPurchaseRequest.ProductType,
                UserId = 1
            };
            
            var productEntryDb = await _context.signumid_product_entry.AddAsync(productEntry);
            await _context.SaveChangesAsync();

            var transactionProductEntry = new Transaction_ProductEntry
            {
                TransactionId = transactionDb.Entity.Id,
                ProductEntryId = productEntryDb.Entity.Id
            };
            
            var transactionProductEntryDb = await _context.sisgnumid_transaction_product_entry.AddAsync(transactionProductEntry);
            await _context.SaveChangesAsync();

            //todo: check if everything is okay with database entries
            
            await transactionScope.CommitAsync();
            return true;
        }
        catch (Exception e)
        {
            // todo: add log
            Console.WriteLine(e);
            await transactionScope.RollbackAsync();
            return false;
        }
    }

這是 program.cs 檔案：

using System.Diagnostics;
using System.Reflection;
using System.Text.Json.Serialization;
using FluentMigrator.Runner;
using Hangfire;
using Hangfire.PostgreSql;
using Hangfire.SQLite;
using Hangfire.SqlServer;
using Microsoft.AspNetCore.Diagnostics.HealthChecks;
using Microsoft.AspNetCore.Http.Json;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.DataEncryption;
using Microsoft.Extensions.Diagnostics.HealthChecks;
using Newtonsoft.Json;
using Serilog;
using Serilog.Exceptions;
using Serilog.Exceptions.Core;
using Signumid.ExceptionMiddleware;
using Signumid.Global;
using Signumid.MigratorRunner;
using Signumid.ProductProvisioning;
using Signumid.ProductProvisioning.Migrations;

var builder = WebApplication.CreateBuilder(args);
var configurationBuilder = new ConfigurationBuilder()
    .SetBasePath(builder.Environment.ContentRootPath)
    .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
    .AddEnvironmentVariables();
var configurationRoot = configurationBuilder.Build();
ConfigureLogging(configurationRoot);

var applicationSettings = new Signumid.ApplicationSettings.ApplicationSettings();

configurationRoot.Bind(applicationSettings);

SignumIdGlobal.InitialiseApplicationSettings(applicationSettings);

// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

builder.Services.Configure<JsonOptions>(options =>
{
    options.SerializerOptions.PropertyNameCaseInsensitive = false;
    options.SerializerOptions.PropertyNamingPolicy = null;
    options.SerializerOptions.WriteIndented = true;
    options.SerializerOptions.Converters.Add(new JsonStringEnumConverter());
});

MigratorRunner.MigrateDatabase(builder.Services,
    SignumIdGlobal.ApplicationSettings.ProductProvisioningApplicationSettings.ConnectionString,
    SignumIdGlobal.ApplicationSettings.ProductProvisioningApplicationSettings.DatabaseProvider,
    Assembly.GetAssembly(typeof(InitialMigration)));


builder.Services.AddScoped<ProductProvisioningContext>();
builder.Services.AddScoped<ProductProvisioningRepository>();
builder.Services.AddScoped<ProductProvisioningService>();


ConfigureHangfire(builder.Services);
ConfigureHealthCheck(builder.Services);

builder.Services.AddCors(options =>
    options.AddPolicy("CorsPolicy",
        corsPolicyBuilder =>
        {
            corsPolicyBuilder
                .AllowAnyMethod()
                .AllowAnyHeader()
                .AllowCredentials()
                .SetIsOriginAllowed(_ => true)
                .WithExposedHeaders("Content-Disposition", "Content-Length");
        }));

builder.Services.AddAuthorization();

var app = builder.Build();
// Configure hangfire to use the new JobActivator we defined.

// Use the previously configured CorsPolicy policy
app.UseCors("CorsPolicy");

app.ConfigureExceptionHandler();
// Configure the HTTP request pipeline.
app.UseSwagger();
app.UseSwaggerUI();

app.UseHttpsRedirection();

app.MapHealthChecks("/v/1/health/basic");
app.MapHealthChecks("/v/1/health/simplified",
    new HealthCheckOptions
    {
        ResponseWriter = async (context, report) =>
        {
            context.Response.ContentType = "application/json";
            await context.Response.WriteAsync(JsonConvert.SerializeObject(new
            {
                status = report.Status.ToString(),
                monitors = report.Entries.Select(e => new
                    {key = e.Key, value = Enum.GetName(typeof(HealthStatus), e.Value.Status)})
            }));
        }
    }
).RequireHost(SignumIdGlobal.ApplicationSettings.ProductProvisioningApplicationSettings.HealthCheckHosts);

app.MapGet("/v/1/signer/getAvailableSignatures",
    (string phoneNumber, int productType, ProductProvisioningService service) => service.RetrieveRemainingProductAmountForUser(phoneNumber, productType));

app.MapGet("/v/1/signer/generatePayLink",
    (string phoneNumber, int quantity, int productId, ProductProvisioningService service) => service.GeneratePayLink(phoneNumber, quantity, productId));

app.MapPost("/v/1/signer/receiveWebhook",  
    (HttpContext context, ProductProvisioningService service) =>  service.ReceiveWebhook(context));

app.UseAuthorization();

app.UseHangfireDashboard();
GlobalConfiguration.Configuration
    .UseActivator(new HangfireActivator(app.Services));


var runner = app.Services.GetRequiredService<IMigrationRunner>();
// Execute the migrations
runner.MigrateUp();

app.Run();

static void ConfigureLogging(IConfigurationRoot configuration)
{
    try
    {
        Serilog.Debugging.SelfLog.Enable(msg => Debug.WriteLine(msg));
        Serilog.Debugging.SelfLog.Enable(Console.Error);
        // Impossible to set with appsettings:
        // https://stackoverflow.com/questions/58587661/json-configuration-for-serilog-exception-destructurers/58622735#58622735
        // https://github.com/RehanSaeed/Serilog.Exceptions/issues/58
        var loggingConfiguration = new LoggerConfiguration()
            .Enrich
            .WithExceptionDetails(new DestructuringOptionsBuilder().WithDefaultDestructurers())
            .ReadFrom
            .Configuration(configuration);

        Log.Logger = loggingConfiguration
            .CreateLogger();
    }
    catch (Exception e)
    {
        Serilog.Debugging.SelfLog.Enable(msg => Debug.WriteLine(msg));
        Serilog.Debugging.SelfLog.Enable(Console.Error);
        Log.Logger = new LoggerConfiguration()
            .WriteTo.Console()
            .MinimumLevel.Debug() // set to minimal in serilog
            .CreateLogger();
        Log.Debug(e,
            "Unable to import serilog configuration from appsettings.json, logging only to console. Error: {@Ex}", e);
    }

    var currentDomain = AppDomain.CurrentDomain;
    currentDomain.UnhandledException  = UnhandledExceptionHandler;
}

static void UnhandledExceptionHandler(object sender, UnhandledExceptionEventArgs args)
{
    var e = (Exception) args.ExceptionObject;
    Log.Fatal(e, "Unhandled exception caught : {@error}", e);
    Log.Fatal("Runtime terminating: {0}", args.IsTerminating);
}

static void ConfigureHealthCheck(IServiceCollection services)
{
    if (SignumIdGlobal.ApplicationSettings.ProductProvisioningApplicationSettings.DatabaseProvider.Equals("SqlLite",
            StringComparison.InvariantCultureIgnoreCase))
    {
        services.AddHealthChecks()
            .AddSqlite(SignumIdGlobal.ApplicationSettings.ProductProvisioningApplicationSettings.ConnectionString);
    }
    else if (SignumIdGlobal.ApplicationSettings.ProductProvisioningApplicationSettings.DatabaseProvider.Equals(
                 "postgresql",
                 StringComparison.InvariantCultureIgnoreCase))
    {
        services.AddHealthChecks()
            .AddNpgSql(SignumIdGlobal.ApplicationSettings.ProductProvisioningApplicationSettings.ConnectionString);
    }
    else if (SignumIdGlobal.ApplicationSettings.ProductProvisioningApplicationSettings.DatabaseProvider.Equals(
                 "sqlserver",
                 StringComparison.InvariantCultureIgnoreCase))
    {
        services.AddHealthChecks()
            .AddSqlServer(SignumIdGlobal.ApplicationSettings.ProductProvisioningApplicationSettings.ConnectionString);
    }
    else
    {
        services.AddHealthChecks();
    }
}

static void ConfigureHangfire(IServiceCollection services)
{
    services.AddHangfire(configuration =>
    {
        configuration
            .SetDataCompatibilityLevel(CompatibilityLevel.Version_170)
            .UseSimpleAssemblyNameTypeSerializer()
            .UseRecommendedSerializerSettings();
    });

    if (SignumIdGlobal.ApplicationSettings.ProductProvisioningApplicationSettings.DatabaseProvider.Equals("SqlLite",
            StringComparison.InvariantCultureIgnoreCase))
    {
        GlobalConfiguration.Configuration.UseSQLiteStorage(SignumIdGlobal.ApplicationSettings
            .ProductProvisioningApplicationSettings
            .ConnectionString, new SQLiteStorageOptions
        {
            SchemaName = "product_provisioning"
        });
    }
    else if (SignumIdGlobal.ApplicationSettings.ProductProvisioningApplicationSettings.DatabaseProvider.Equals(
                 "postgresql",
                 StringComparison.InvariantCultureIgnoreCase))
    {
        GlobalConfiguration.Configuration.UsePostgreSqlStorage(
            SignumIdGlobal.ApplicationSettings.ProductProvisioningApplicationSettings.ConnectionString,
            new PostgreSqlStorageOptions
            {
                SchemaName = "product_provisioning"
            });
    }
    else if (SignumIdGlobal.ApplicationSettings.ProductProvisioningApplicationSettings.DatabaseProvider.Equals(
                 "sqlserver",
                 StringComparison.InvariantCultureIgnoreCase))
    {
        GlobalConfiguration.Configuration.UseSqlServerStorage(
            SignumIdGlobal.ApplicationSettings.ProductProvisioningApplicationSettings.ConnectionString,
            new SqlServerStorageOptions
            {
                SchemaName = "product_provisioning"
            });
    }

    services.AddHangfireServer();
}

當我宣告事務范圍時，方法的第一行出現錯誤。錯誤如下：

無法訪問已釋放的背景關系實體。此錯誤的一個常見原因是釋放從依賴注入中決議的背景關系實體，然后嘗試在應用程式的其他地方使用相同的背景關系實體。如果您在背景關系實體上呼叫“Dispose”或將其包裝在 using 陳述句中，則可能會發生這種情況。如果你使用依賴注入，你應該讓依賴注入容器負責處理背景關系實體。物件名稱：“ProductProvisioningContext”。

錯誤截圖

uj5u.com熱心網友回復：

您ReceiveWebhook的 is async void，將其更改為 return Task：

public async Task ReceiveWebhook(HttpContext httpContext)

否則 ASP.NET Core 不能等到處理結束，并將在處理程式完成之前完成請求（包括釋放創建的范圍和一次性依賴項，如資料庫背景關系）。

閱讀更多：

異步/等待 - 何時回傳任務與無效？
為什么 void async 到底是壞的？
異步任務與異步無效
Async/Await - 異步編程的最佳實踐

轉載請註明出處，本文鏈接：https://www.uj5u.com/net/464418.html

標籤：C＃。网实体框架 .net-core 数据库上下文

上一篇：Bootstrap絕對定位創建重疊布局

下一篇：EF核心。使用EF創建帶有視圖的MVC控制器時。創建沒有與表的每一列相關的輸入的創建（插入）視圖