UnitOfWork and Async calls - Abp Version 7.0.0 about aspnetboilerplate

[ismcagdas]

@pawelignaczak could you share your ABP version and format the code in the issue properly ?

[pawelignaczak]

Done

[ismcagdas]

Thanks. Is it possible for you to prepare a sample project with this problem ?

[pawelignaczak]

That would be difficult as the current project is big. Basically We get an event from remote server that triggers an async request with a new UoW: _unitOfWorkManager.Begin(TransactionScopeOption.RequiresNew).
The a chain of async requests are called. My latest findigs is that the any async bolerplate repo calls like:

                var     interdto = await base.CreateAsync(input);

or
var list=_interactionsRepository.GetAllListAsync()
or
var dataReader = await command.ExecuteReaderAsync();
if i use say :
var dataReader = command.ExecuteReader();
Then it does not happen.
But i cannot avoid using:
var interdto = await base.CreateAsync(input);

[pawelignaczak]

In fact i randomly get below error when try to call :
var interdto = await base.CreateAsync(input);

System.InvalidOperationException: „A second operation was started on this context instance before a previous operation completed. This is usually caused by different threads concurrently using the same instance of DbContext. For more information on how to avoid threading issues with DbContext, see https://go.microsoft.com/fwlink/?linkid=2097913.”

[ismcagdas]

Could you share your startup.cs ? Especially services.AddAbp block.

[pawelignaczak]

using System;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Castle.Facilities.Logging;
using Abp.AspNetCore;
using Abp.AspNetCore.Mvc.Antiforgery;
using Abp.Castle.Logging.Log4Net;
using AseeVT.Authentication.JwtBearer;
using AseeVT.Configuration;
using AseeVT.Identity;
using AseeVT.Web.Resources;
using Abp.AspNetCore.SignalR.Hubs;
using Abp.Dependency;
using Abp.Json;
using Microsoft.Extensions.Hosting;
using Newtonsoft.Json.Serialization;
using AseeVT.Hubs;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Authentication.Cookies;
using Microsoft.Extensions.Options;
using Microsoft.AspNetCore.Identity;
using log4net;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Globalization;
using Microsoft.AspNetCore.Localization;
using AseeVT.Web.Models.AzureKeyVault;
using Azure.Identity;
using Microsoft.Data.SqlClient.AlwaysEncrypted.AzureKeyVaultProvider;
using Microsoft.Data.SqlClient;
using System.Collections.Generic;

namespace AseeVT.Web.Startup
{
public class Startup
{
private readonly IWebHostEnvironment _hostingEnvironment;
private readonly IConfigurationRoot _appConfiguration;

    public Startup(IWebHostEnvironment env)
    {
        _hostingEnvironment = env;
        _appConfiguration = env.GetAppConfiguration();
    }

    public void ConfigureServices(IServiceCollection services)
    {
        var azureKeyVaultConfig = _appConfiguration.GetSection("AzureKeyVault").Get<AzureKeyVaultConfig>();
        
        var clientSecretCredential = new ClientSecretCredential(
                  azureKeyVaultConfig.TenantId, 
                  azureKeyVaultConfig.ClientId, 
                  azureKeyVaultConfig.ClientSecret ); 

        SqlColumnEncryptionAzureKeyVaultProvider azureKeyVaultProvider = new SqlColumnEncryptionAzureKeyVaultProvider(clientSecretCredential);
        SqlConnection.RegisterColumnEncryptionKeyStoreProviders(
            customProviders: new Dictionary<string, SqlColumnEncryptionKeyStoreProvider>(comparer: StringComparer.OrdinalIgnoreCase)
            {
                { SqlColumnEncryptionAzureKeyVaultProvider.ProviderName, azureKeyVaultProvider }
            });

        // MVC
        services.AddControllersWithViews(
                options =>
                {
                    options.Filters.Add(new AutoValidateAntiforgeryTokenAttribute());
                    options.Filters.Add(new AbpAutoValidateAntiforgeryTokenAttribute());
                }
            )
            .AddRazorRuntimeCompilation()
            .AddNewtonsoftJson(options =>
            {
                options.SerializerSettings.ContractResolver = new AbpMvcContractResolver(IocManager.Instance)
                {
                    NamingStrategy = new CamelCaseNamingStrategy()
                };
            });

        //services.ConfigureApplicationCookie(o =>
        //{
        //    o.ExpireTimeSpan = TimeSpan.FromHours(8);
        //    o.SlidingExpiration = false;
        //});

        services.AddSingleton<IPostConfigureOptions<SecurityStampValidatorOptions>, ConfigureSecurityStampValidatorOptionsService>();

        services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
        .AddCookie(options =>
        {
            options.ExpireTimeSpan = TimeSpan.FromMinutes(240);
            options.SlidingExpiration = false;
            options.AccessDeniedPath = "/Forbidden/";
        });

        IdentityRegistrar.Register(services);
        AuthConfigurer.Configure(services, _appConfiguration);

        services.AddScoped<IWebResourceManager, WebResourceManager>();

        var options = new JsonSerializerOptions
        {
            ReferenceHandler = ReferenceHandler.Preserve
        };

        services.AddSignalR(o =>
        {
            o.EnableDetailedErrors = true;

        }).AddJsonProtocol(options =>
        {
            options.PayloadSerializerOptions.ReferenceHandler = ReferenceHandler.Preserve;
        });

        // Configure Abp and Dependency Injection
        services.AddAbpWithoutCreatingServiceProvider<AseeVTWebMvcModule>(
            // Configure Log4Net logging
            options => options.IocManager.IocContainer.AddFacility<LoggingFacility>(
                f => f.UseAbpLog4Net().WithConfig(
                    _hostingEnvironment.IsDevelopment()
                        ? "log4net.config"
                        : "log4net.Production.config"
                    )
            )
        );

    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILoggerFactory loggerFactory)
    {
        //app.UsePathBase(new PathString("/app"));

        app.UseAbp(); // Initializes ABP framework.

        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
            //app.UseExceptionHandler("/Error");
        }
        else
        {
            app.UseExceptionHandler("/Error");
        }

        app.Use(async (context, next) =>
       {
           LogicalThreadContext.Properties["CorrelationId"] = context.TraceIdentifier;

           await next.Invoke();
       });

        app.UseStaticFiles();

        app.UseRouting();

        app.UseAuthentication();

        app.UseJwtTokenMiddleware();

        app.UseAuthorization();

        //app.UseSession();
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapHub<AbpCommonHub>("/signalr");
            endpoints.MapHub<AcdHub>("/signalr-acd");
            endpoints.MapControllerRoute("default", "{controller=Home}/{action=Index}/{id?}");
            endpoints.MapControllerRoute("defaultWithArea", "{area}/{controller=Home}/{action=Index}/{id?}");
        });
    }
}

}

[ismcagdas]

Thanks. This seems fine. Is it possible that your code has any async over sync usages ? If you are using Jetbrains Rider, you can find such usages in your code. If not, you can try to remove TransactionScopeOption.RequiresNew if there is no special reason to use it.

[pawelignaczak]

Well that's the point. We receive TCP events from other system and create an asyn event from it that process some actions on services. At the same time the services can be accessed from say frontend or SignalR.

[ismcagdas]

I mean only the code in your app, not how it is called outside from your app.