Stored procedures 如何在blazor服务器应用程序中简单地执行存储过程？

我正在使用存储库模式构建Blazor服务器应用程序，并试图从Razor组件页面执行存储过程

但是，运行时出现错误：

blazor.server.js:21[2021-03-29T02:03:38.207Z]错误：System.InvalidOperationException:无法为类型“ThePositionerBlazorServerDapperSyncfusion.Pages.DBProcessing.CalculateImportance”的属性“ICalculateImportanceService”提供值。没有类型为“ThePositionerBlazorServerDapperSyncfusion.Data.CalculateImportanceService”的注册服务

我不知道为什么会出错，因为我相信我注册了服务

以下是相关代码：

计算重要性。razor

@using ThePositionerBlazorServerDapperSyncfusion.Data
@page "/DBProcessing/calcultateitemImportance"
@inject CalculateImportanceService ICalculateImportanceService
@inject NavigationManager NavigationManager

<h1 style="text-align:center">@pagetitle</h1>

@code {

    public string pagetitle = "Calculate Importance";

    protected override async Task OnInitializedAsync()
    {
        // Kick off stored procedure to calculate importance
        await ICalculateImportanceService.CalculateImportance();
    }
}

@使用PositionerBlazorServerDapperSyncFusion.Data
@页面“/DBProcessing/CalcultateItem重要性”
@注入CalculateImportanceService ICalculateImportanceService
@注入NavigationManager NavigationManager
@页面标题
@代码{
公共字符串pagetitle=“计算重要性”；
受保护的重写异步任务OnInitializedAsync（）
{
//启动存储过程以计算重要性
等待ICalculateImportanceService.CalculateImportance（）；
}
}

ICalculateImportanceService.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using ThePositionerBlazorServerDapperSyncfusion.Data;

namespace ThePositionerBlazorServerDapperSyncfusion.Data
{
    public interface ICalculateImportanceService
    {
        Task<bool> CalculateImportance();
    }
}

using Dapper;
using Microsoft.Data.SqlClient;
using System;
using System.Collections.Generic;
using System.Data;
using System.Threading.Tasks;

namespace ThePositionerBlazorServerDapperSyncfusion.Data
{
    public class CalculateImportanceService : ICalculateImportanceService
    {
        private readonly SqlConnectionConfiguration _configuration;

        public CalculateImportanceService(SqlConnectionConfiguration configuration)
        {
            _configuration = configuration;
        }

        public async Task<bool> CalculateImportance()
        {
            using (var conn = new SqlConnection(_configuration.Value))
            {
                await conn.ExecuteAsync("CalculateTheItemImportance", commandType: CommandType.StoredProcedure);
            }
            return true;
        }
    }
}

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.HttpsPolicy;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using ThePositionerBlazorServerDapperSyncfusion.Data;
using Syncfusion.Blazor;

namespace ThePositionerBlazorServerDapperSyncfusion
{
    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        public void ConfigureServices(IServiceCollection services)
        {
            services.AddRazorPages();
            services.AddServerSideBlazor();
            //services.AddSingleton<WeatherForecastService>();
            //Syncfusion support
            services.AddSyncfusionBlazor();
            services.AddControllers().AddNewtonsoftJson();
            var sqlConnectionConfiguration = new SqlConnectionConfiguration(Configuration.GetConnectionString("SqlDBContext"));
            services.AddSingleton(sqlConnectionConfiguration);
            services.AddScoped<IApplicConfsService, ApplicConfsService>();
            services.AddScoped<IPOSSUMMARYService, POSSUMMARYService>();
            services.AddScoped<IPOSDETAILService, POSDETAILService>();
            services.AddScoped<IDESCRIPTIONTYPEService, DESCRIPTIONTYPEService>();
            services.AddScoped<IIMPService, IMPService>();
            services.AddScoped<IITEMCATEGORYService, ITEMCATEGORYService>();
            services.AddScoped<IKNOWDEPService, KNOWDEPService>();
            services.AddScoped<IMembersService, MembersService>();
            services.AddScoped<IPRDSRVService, PRDSRVService>();
            services.AddScoped<IPROCESSESService, PROCESSESService>();
            services.AddScoped<ITASKKNOService, TASKKNOService>();
            services.AddScoped<ITMPOVERLAPService, TMPOVERLAPService>();
            services.AddScoped<ITEXTUALService, TEXTUALService>();
            services.AddScoped<ITIMESCALEService, TIMESCALEService>();
            services.AddScoped<IWORKHIERService, WORKHIERService>();
            services.AddScoped<ICalculateImportanceService, CalculateImportanceService>();
            services.AddScoped<ICalculateFTEService, CalculateFTEService>();
        }
    }
}

使用系统；
使用System.Collections.Generic；
使用System.Threading.Tasks；
使用PositionerBlazorServerDapperSyncFusion.Data；
命名空间PositionerBlazorServerDapperSyncFusion.Data
{
公共接口ICalculateImportanceService
{
任务计算重要性（）；
}
}

CalculateImportanceService.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using ThePositionerBlazorServerDapperSyncfusion.Data;

namespace ThePositionerBlazorServerDapperSyncfusion.Data
{
    public interface ICalculateImportanceService
    {
        Task<bool> CalculateImportance();
    }
}

using Dapper;
using Microsoft.Data.SqlClient;
using System;
using System.Collections.Generic;
using System.Data;
using System.Threading.Tasks;

namespace ThePositionerBlazorServerDapperSyncfusion.Data
{
    public class CalculateImportanceService : ICalculateImportanceService
    {
        private readonly SqlConnectionConfiguration _configuration;

        public CalculateImportanceService(SqlConnectionConfiguration configuration)
        {
            _configuration = configuration;
        }

        public async Task<bool> CalculateImportance()
        {
            using (var conn = new SqlConnection(_configuration.Value))
            {
                await conn.ExecuteAsync("CalculateTheItemImportance", commandType: CommandType.StoredProcedure);
            }
            return true;
        }
    }
}

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.HttpsPolicy;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using ThePositionerBlazorServerDapperSyncfusion.Data;
using Syncfusion.Blazor;

namespace ThePositionerBlazorServerDapperSyncfusion
{
    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        public void ConfigureServices(IServiceCollection services)
        {
            services.AddRazorPages();
            services.AddServerSideBlazor();
            //services.AddSingleton<WeatherForecastService>();
            //Syncfusion support
            services.AddSyncfusionBlazor();
            services.AddControllers().AddNewtonsoftJson();
            var sqlConnectionConfiguration = new SqlConnectionConfiguration(Configuration.GetConnectionString("SqlDBContext"));
            services.AddSingleton(sqlConnectionConfiguration);
            services.AddScoped<IApplicConfsService, ApplicConfsService>();
            services.AddScoped<IPOSSUMMARYService, POSSUMMARYService>();
            services.AddScoped<IPOSDETAILService, POSDETAILService>();
            services.AddScoped<IDESCRIPTIONTYPEService, DESCRIPTIONTYPEService>();
            services.AddScoped<IIMPService, IMPService>();
            services.AddScoped<IITEMCATEGORYService, ITEMCATEGORYService>();
            services.AddScoped<IKNOWDEPService, KNOWDEPService>();
            services.AddScoped<IMembersService, MembersService>();
            services.AddScoped<IPRDSRVService, PRDSRVService>();
            services.AddScoped<IPROCESSESService, PROCESSESService>();
            services.AddScoped<ITASKKNOService, TASKKNOService>();
            services.AddScoped<ITMPOVERLAPService, TMPOVERLAPService>();
            services.AddScoped<ITEXTUALService, TEXTUALService>();
            services.AddScoped<ITIMESCALEService, TIMESCALEService>();
            services.AddScoped<IWORKHIERService, WORKHIERService>();
            services.AddScoped<ICalculateImportanceService, CalculateImportanceService>();
            services.AddScoped<ICalculateFTEService, CalculateFTEService>();
        }
    }
}

使用简洁；
使用Microsoft.Data.SqlClient；
使用制度；
使用System.Collections.Generic；
使用系统数据；
使用System.Threading.Tasks；
命名空间PositionerBlazorServerDapperSyncFusion.Data
{
公共类CalculateImportanceService:ICalculateImportanceService
{
专用只读SqlConnectionConfiguration\u配置；
公共CalculateImportanceService（SqlConnectionConfiguration配置）
{
_配置=配置；
}
公共异步任务CalculateImportance（）
{
使用（var conn=newsqlconnection（_configuration.Value））
{
等待conn.ExecuteAsync（“CalculateTheItemImportance”，commandType:commandType.StoredProcess）；
}
返回true；
}
}
}

Startup.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using ThePositionerBlazorServerDapperSyncfusion.Data;

namespace ThePositionerBlazorServerDapperSyncfusion.Data
{
    public interface ICalculateImportanceService
    {
        Task<bool> CalculateImportance();
    }
}

using Dapper;
using Microsoft.Data.SqlClient;
using System;
using System.Collections.Generic;
using System.Data;
using System.Threading.Tasks;

namespace ThePositionerBlazorServerDapperSyncfusion.Data
{
    public class CalculateImportanceService : ICalculateImportanceService
    {
        private readonly SqlConnectionConfiguration _configuration;

        public CalculateImportanceService(SqlConnectionConfiguration configuration)
        {
            _configuration = configuration;
        }

        public async Task<bool> CalculateImportance()
        {
            using (var conn = new SqlConnection(_configuration.Value))
            {
                await conn.ExecuteAsync("CalculateTheItemImportance", commandType: CommandType.StoredProcedure);
            }
            return true;
        }
    }
}

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.HttpsPolicy;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using ThePositionerBlazorServerDapperSyncfusion.Data;
using Syncfusion.Blazor;

namespace ThePositionerBlazorServerDapperSyncfusion
{
    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        public void ConfigureServices(IServiceCollection services)
        {
            services.AddRazorPages();
            services.AddServerSideBlazor();
            //services.AddSingleton<WeatherForecastService>();
            //Syncfusion support
            services.AddSyncfusionBlazor();
            services.AddControllers().AddNewtonsoftJson();
            var sqlConnectionConfiguration = new SqlConnectionConfiguration(Configuration.GetConnectionString("SqlDBContext"));
            services.AddSingleton(sqlConnectionConfiguration);
            services.AddScoped<IApplicConfsService, ApplicConfsService>();
            services.AddScoped<IPOSSUMMARYService, POSSUMMARYService>();
            services.AddScoped<IPOSDETAILService, POSDETAILService>();
            services.AddScoped<IDESCRIPTIONTYPEService, DESCRIPTIONTYPEService>();
            services.AddScoped<IIMPService, IMPService>();
            services.AddScoped<IITEMCATEGORYService, ITEMCATEGORYService>();
            services.AddScoped<IKNOWDEPService, KNOWDEPService>();
            services.AddScoped<IMembersService, MembersService>();
            services.AddScoped<IPRDSRVService, PRDSRVService>();
            services.AddScoped<IPROCESSESService, PROCESSESService>();
            services.AddScoped<ITASKKNOService, TASKKNOService>();
            services.AddScoped<ITMPOVERLAPService, TMPOVERLAPService>();
            services.AddScoped<ITEXTUALService, TEXTUALService>();
            services.AddScoped<ITIMESCALEService, TIMESCALEService>();
            services.AddScoped<IWORKHIERService, WORKHIERService>();
            services.AddScoped<ICalculateImportanceService, CalculateImportanceService>();
            services.AddScoped<ICalculateFTEService, CalculateFTEService>();
        }
    }
}

使用Microsoft.AspNetCore.Builder；
使用Microsoft.AspNetCore.Components；
使用Microsoft.AspNetCore.Hosting；
使用Microsoft.AspNetCore.HttpsPolicy；
使用Microsoft.Extensions.Configuration；
使用Microsoft.Extensions.DependencyInjection；
使用Microsoft.Extensions.Hosting；
使用制度；
使用System.Collections.Generic；
使用System.Linq；
使用System.Threading.Tasks；
使用PositionerBlazorServerDapperSyncFusion.Data；
使用Syncfusion.Blazor；
命名空间PositionerBlazorServerDapperSyncFusion
{
公营创业
{
公共启动（IConfiguration配置）
{
配置=配置；
}
公共IConfiguration配置{get；}
public void配置服务（IServiceCollection服务）
{
services.AddRazorPages（）；
AddServerSideBlazor（）；
//services.AddSingleton（）；
//融合支持
services.AddSyncfusionBlazor（）；
services.AddControllers（）.AddNewtonsoftJson（）；
var sqlConnectionConfiguration=新的sqlConnectionConfiguration（Configuration.GetConnectionString（“SqlDBContext”）；
AddSingleton（sqlConnectionConfiguration）；
services.addScope（）；
services.addScope（）；
services.addScope（）；
services.addScope（）；
services.addScope（）；
services.addScope（）；
services.addScope（）；
services.addScope（）；
services.addScope（）；
services.addScope（）；
services.addScope（）；
services.addScope（）；
services.addScope（）；
services.addScope（）；
services.addScope（）；
services.addScope（）；
services.addScope（）；
}
}
}

存储过程没有参数，只是在数据库上执行处理

任何帮助都将不胜感激。谢谢你的改变

@inject CalculateImportanceService ICalculateImportanceService

到

再往下

// await ICalculateImportanceService.CalculateImportance();
   await CalculateImportanceService.CalculateImportance();